refactor: refactor project flow and structure

Author: balajz

internal/cli/root.go

@@ -8,6 +8,7 @@ import (
 	"github.com/balaji01-4d/pgxcli/internal/config"
 	"github.com/balaji01-4d/pgxcli/internal/database"
 	"github.com/balaji01-4d/pgxcli/internal/logger"
+	"github.com/balaji01-4d/pgxcli/internal/repl"
 
 	"github.com/fatih/color"
 	"github.com/spf13/cobra"
@@ -79,23 +80,23 @@ var rootCmd = &cobra.Command{
 		ctx := context.Background()
 
 		postgres := database.New(neverPrompt, forcePrompt, ctx, cfg)
-		defer postgres.Close()
+		defer postgres.Close(ctx)
 
 		if strings.Contains(finalDB, "://") {
-			err := postgres.ConnectURI(finalDB)
+			err := postgres.ConnectURI(ctx, finalDB)
 			if err != nil {
 				printErr(os.Stderr, "%v\n", err)
 				os.Exit(1)
 			}
 		} else if strings.Contains(finalDB, "=") {
-			err := postgres.ConnectDSN(finalDB)
+			err := postgres.ConnectDSN(ctx, finalDB)
 			if err != nil {
 				printErr(os.Stderr, "%v\n", err)
 				os.Exit(1)
 			}
 		} else {
 			logger.Log.Info("Connecting to database", "host", host, "port", port, "database", finalDB, "user", finalUser)
-			err := postgres.Connect(host, finalUser, "", finalDB, "", port)
+			err := postgres.Connect(ctx, host, finalUser, "", finalDB, "", port)
 			if err != nil {
 				logger.Log.Error("Connection failed", "error", err, "host", host, "database", finalDB)
 				printErr(os.Stderr, "%v\n", err)
@@ -106,8 +107,10 @@ var rootCmd = &cobra.Command{
 			printErr(os.Stderr, "Not connected to any database\n")
 			os.Exit(1)
 		}
-		postgres.RunCli()
-		postgres.Close()
+
+		repl := repl.New(postgres, cfg)
+		repl.Run(ctx)
+		repl.Close()
 	},
 }
 

internal/config/config.go

@@ -7,14 +7,25 @@ import (
 	"github.com/BurntSushi/toml"
 )
 
-const filename = "config.toml"
+const (
+	Default  = "default"
+	filename = "config.toml"
+)
 
 type Config struct {
-	Prompt string `toml:"prompt"`
+	Main main `toml:"main"`
+}
+
+type main struct {
+	Prompt      string `toml:"prompt"`
+	HistoryFile string `toml:"history_file"`
 }
 
 var DefaultConfig = Config{
-	Prompt: `\u@\h:\d> `,
+	Main: main{
+		Prompt:      `\u@\h:\d> `,
+		HistoryFile: "default",
+	},
 }
 
 func GetConfigDir() (string, error) {

internal/config/config.toml

@@ -1,3 +1,4 @@
+[main]
 # Postgres prompt
 # \t - Current date and time
 # \u - Username
@@ -7,3 +8,7 @@
 # \p - Database port
 # \n - Newline
 prompt = '\u@\h:\d> '
+
+
+# history
+history_file = default

internal/config/config_test.go

@@ -1,12 +1,10 @@
-package config_test
+package config
 
 import (
 	"os"
 	path "path/filepath"
 	"testing"
 
-	"github.com/balaji01-4d/pgxcli/internal/config"
-
 	"github.com/stretchr/testify/assert"
 )
 
@@ -18,9 +16,9 @@ func TestLoadConfig_ValidConfig(t *testing.T) {
 	err := os.WriteFile(configPath, []byte(configContent), 0644)
 	assert.NoError(t, err)
 
-	cfg, err := config.LoadConfig(configPath)
+	cfg, err := LoadConfig(configPath)
 	assert.NoError(t, err)
-	assert.Equal(t, "\\u@\\h:\\d> ", cfg.Prompt)
+	assert.Equal(t, "\\u@\\h:\\d> ", cfg.Main.Prompt)
 }
 
 func TestLoadConfig_InvalidConfig(t *testing.T) {
@@ -31,26 +29,29 @@ func TestLoadConfig_InvalidConfig(t *testing.T) {
 	err := os.WriteFile(configPath, []byte(invalidContent), 0644)
 	assert.NoError(t, err)
 
-	_, err = config.LoadConfig(configPath)
+	_, err = LoadConfig(configPath)
 	assert.Error(t, err)
 }
 
 func TestLoadConfig_MissingFile(t *testing.T) {
-	_, err := config.LoadConfig("non_existent_config.toml")
+	_, err := LoadConfig("non_existent_config.toml")
 	assert.Error(t, err)
 }
 
 func TestSaveConfig(t *testing.T) {
 	tempDir := t.TempDir()
 	configPath := path.Join(tempDir, "config.toml")
 
-	cfg := config.Config{
-		Prompt: "\\u@\\h:\\d> ",
+	cfg := Config{
+		Main: main{
+			Prompt:      "\\u@\\h:\\d> ",
+			HistoryFile: "default",
+		},
 	}
 
-	err := config.SaveConfig(configPath, cfg)
+	err := SaveConfig(configPath, cfg)
 	assert.NoError(t, err)
-	loadedCfg, err := config.LoadConfig(configPath)
+	loadedCfg, err := LoadConfig(configPath)
 	assert.NoError(t, err)
-	assert.Equal(t, cfg.Prompt, loadedCfg.Prompt)
+	assert.Equal(t, cfg.Main.Prompt, loadedCfg.Main.Prompt)
 }

internal/database/client.go

@@ -4,29 +4,22 @@ import (
 	"context"
 	"fmt"
 	"os"
+	osUser "os/user"
 	"strings"
 	"time"
 
 	"github.com/balaji01-4d/pgxcli/internal/config"
 	"github.com/balaji01-4d/pgxcli/internal/logger"
-
-	osUser "os/user"
+	"github.com/balaji01-4d/pgxspecial"
 
 	"github.com/jackc/pgx/v5"
 )
 
-const (
-	DefaultPrompt = `\u@\h:\d> `
-	MaxLenPrompt  = 30
-)
-
 type Client struct {
 	CurrentDB           string
 	Executor            *Executor
 	ForcePasswordPrompt bool
 	NeverPasswordPrompt bool
-	ctx                 context.Context
-	Config              config.Config
 
 	now time.Time
 }
@@ -35,14 +28,12 @@ func New(neverPasswordPrompt, forcePasswordPrompt bool, ctx context.Context, cfg
 	postgres := &Client{
 		NeverPasswordPrompt: neverPasswordPrompt,
 		ForcePasswordPrompt: forcePasswordPrompt,
-		ctx:                 ctx,
-		Config:              cfg,
 		now:                 time.Now(),
 	}
 	return postgres
 }
 
-func (p *Client) Connect(host, user, password, database, dsn string, port uint16) error {
+func (c *Client) Connect(ctx context.Context, host, user, password, database, dsn string, port uint16) error {
 	if user == "" {
 		currentUser, err := osUser.Current()
 		if err != nil {
@@ -55,11 +46,11 @@ func (p *Client) Connect(host, user, password, database, dsn string, port uint16
 		database = user
 	}
 
-	if p.NeverPasswordPrompt && password == "" {
+	if c.NeverPasswordPrompt && password == "" {
 		password = os.Getenv("PGPASSWORD")
 	}
 
-	if p.ForcePasswordPrompt && password == "" {
+	if c.ForcePasswordPrompt && password == "" {
 		fmt.Print("Password: ")
 		var pwd string
 		fmt.Scanln(&pwd)
@@ -76,70 +67,129 @@ func (p *Client) Connect(host, user, password, database, dsn string, port uint16
 		port = parsedDsn.Port
 	}
 
-	exec, err := NewExecutor(host, database, user, password, port, dsn, p.ctx)
+	exec, err := NewExecutor(host, database, user, password, port, dsn, ctx)
 	if err != nil {
 		return err
 	}
-	p.Executor = exec
-	p.CurrentDB = database
+	c.Executor = exec
+	c.CurrentDB = database
 	logger.Log.Info("Database connection established", "database", database, "user", user)
 
 	return nil
 }
 
-func (p *Client) ConnectDSN(dsn string) error {
-	return p.Connect("", "", "", "", dsn, 0)
+func (c *Client) ConnectDSN(ctx context.Context, dsn string) error {
+	return c.Connect(ctx, "", "", "", "", dsn, 0)
 }
 
-func (p *Client) ConnectURI(uri string) error {
+func (c *Client) ConnectURI(ctx context.Context, uri string) error {
 	parsedURI, err := pgx.ParseConfig(uri)
 	if err != nil {
 		return fmt.Errorf("failed to parse URI: %w", err)
 	}
-	return p.Connect(parsedURI.Host, parsedURI.User, parsedURI.Password, parsedURI.Database, "", parsedURI.Port)
+	return c.Connect(ctx, parsedURI.Host, parsedURI.User, parsedURI.Password, parsedURI.Database, "", parsedURI.Port)
 }
 
-func (p *Client) Close() {
-	if p.Executor != nil {
-		p.Executor.Close(p.ctx)
-	}
+func (c *Client) ExecuteSpecial(ctx context.Context,
+	command string) (pgxspecial.SpecialCommandResult, bool, error) {
+	return pgxspecial.ExecuteSpecialCommand(ctx, c.Executor.Conn, command)
 }
 
-func (p *Client) IsConnected() bool {
-	return p.Executor != nil && p.Executor.IsConnected()
+func (c *Client) ExecuteQuery(ctx context.Context, query string) (Result, error) {
+	return c.Executor.Execute(ctx, query)
 }
 
-func (p *Client) GetConnectionInfo() {
-	logger.Log.Debug("Connection information",
-		"connection string", p.Executor.Conn.Config().ConnString(),
-		"host", p.Executor.Host,
-		"Port", p.Executor.Port,
-		"Database", p.Executor.Database,
-		"User", p.Executor.User,
-		"URI", p.Executor.URI,
-	)
+func (c *Client) IsConnected() bool {
+	return c.Executor != nil && c.Executor.IsConnected()
 }
 
-func (p *Client) ChangeDatabase(dbName string) error {
-	if !p.IsConnected() {
+func (c *Client) ChangeDatabase(ctx context.Context, dbName string) error {
+	if !c.IsConnected() {
 		return fmt.Errorf("not connected to any database")
 	}
 
 	exec, err := NewExecutor(
-		p.Executor.Host,
+		c.Executor.Host,
 		dbName,
-		p.Executor.User,
-		p.Executor.Password,
-		p.Executor.Port,
+		c.Executor.User,
+		c.Executor.Password,
+		c.Executor.Port,
 		"",
-		p.ctx,
+		ctx,
 	)
 	if err != nil {
 		return err
 	}
-	p.Executor = exec
-	p.CurrentDB = dbName
+	c.Executor = exec
+	c.CurrentDB = dbName
 	logger.Log.Info("Database changed", "database", dbName)
 
 	return nil
 }
+
+func (c *Client) ParsePrompt(str string) string {
+	str = strings.ReplaceAll(str, "\\t", c.now.Format("02/06/2006 15:04:05"))
+	if c.Executor.User != "" {
+		str = strings.ReplaceAll(str, "\\u", c.Executor.User)
+	} else {
+		str = strings.ReplaceAll(str, "\\u", "(nil)")
+	}
+
+	if c.Executor.Host != "" {
+		str = strings.ReplaceAll(str, "\\H", c.Executor.Host)
+		str = strings.ReplaceAll(str, "\\h", func() string {
+			return strings.Split(c.Executor.Host, ".")[0]
+		}())
+	} else {
+		str = strings.ReplaceAll(str, "\\H", "(nil)")
+		str = strings.ReplaceAll(str, "\\h", "(nil)")
+	}
+
+	if c.CurrentDB != "" {
+		str = strings.ReplaceAll(str, "\\d", c.CurrentDB)
+	} else {
+		str = strings.ReplaceAll(str, "\\d", "(nil)")
+	}
+	if c.Executor.Port != 0 {
+		str = strings.ReplaceAll(str, "\\p", fmt.Sprintf("%d", c.Executor.Port))
+	} else {
+		str = strings.ReplaceAll(str, "\\p", "5432")
+	}
+
+	str = strings.ReplaceAll(str, "\\n", "\n")
+
+	return str
+}
+
+func (c *Client) GetUser() string {
+	return c.Executor.User
+}
+
+func (c *Client) GetDatabase() string {
+	return c.Executor.Database
+}
+
+func (c *Client) GetPort() uint16 {
+	return c.Executor.Port
+}
+
+func (c *Client) GetHost() string {
+	return c.Executor.Host
+}
+
+func (c *Client) GetConnectionInfo() {
+	logger.Log.Debug("Connection information",
+		"connection string", c.Executor.Conn.Config().ConnString(),
+		"host", c.Executor.Host,
+		"Port", c.Executor.Port,
+		"Database", c.Executor.Database,
+		"User", c.Executor.User,
+		"URI", c.Executor.URI,
+	)
+}
+
+func (c *Client) Close(ctx context.Context) {
+	if c.Executor != nil {
+		c.Executor.Close(ctx)
+	}
+}

internal/database/exec_result.go

@@ -13,9 +13,7 @@ type ExecResult struct {
 	Duration     time.Duration
 }
 
-func (e *ExecResult) GetType() string {
-	return "EXEC"
-}
+func (e *ExecResult) isResult() {}
 
 func (e *ExecResult) Render() string {
 	return fmt.Sprintf(

internal/database/executor.go

@@ -13,7 +13,7 @@ import (
 )
 
 type Result interface {
-	GetType() string
+	isResult()
 }
 
 // executor struct to execute queries