doctor: report DB dialect/DSN validity and cover empty durable-state tables

Author: Cod-e-Codes

ARCHITECTURE.md

@@ -209,7 +209,7 @@ The **client** stores `config.json`, `profiles.json`, keystore (unless legacy `k
 
 ### Diagnostics (`internal/doctor`)
 
-Shared package invoked by **`marchat-client`** and **`marchat-server`** when passed **`-doctor`** (human-readable report) or **`-doctor-json`** (JSON on stdout). It summarizes Go/OS, resolved config directories, known `MARCHAT_*` variables with secrets masked, role-specific checks (client: profiles, clipboard, TTY; server: `.env`, validation, DB/TLS/sqlite ping), and optionally compares the embedded version to the latest GitHub release. Set **`MARCHAT_DOCTOR_NO_NETWORK=1`** to skip the release check (e.g. air-gapped environments).
+Shared package invoked by **`marchat-client`** and **`marchat-server`** when passed **`-doctor`** (human-readable report) or **`-doctor-json`** (JSON on stdout). It summarizes Go/OS, resolved config directories, known `MARCHAT_*` variables with secrets masked, role-specific checks (client: profiles, clipboard, TTY; server: `.env`, validation, detected DB dialect, DB connection-string format validation, DB/TLS ping checks), and optionally compares the embedded version to the latest GitHub release. Set **`MARCHAT_DOCTOR_NO_NETWORK=1`** to skip the release check (e.g. air-gapped environments).
 
 ### Command Line Tools (`cmd/`)
 

README.md

@@ -270,7 +270,7 @@ The repository’s `config/` directory holds **server** runtime files and the **
 
 ### Diagnostics (`-doctor`)
 
-Run **`./marchat-client -doctor`** or **`./marchat-server -doctor`** for a text report (paths, masked `MARCHAT_*` env, sanity checks). Use **`-doctor-json`** for machine-readable output. If both flags were passed, `-doctor-json` wins. Exits without starting the TUI or listening on a port. See [ARCHITECTURE.md](ARCHITECTURE.md) for details.
+Run **`./marchat-client -doctor`** or **`./marchat-server -doctor`** for a text report (paths, masked `MARCHAT_*` env, sanity checks). Server doctor also reports the detected DB dialect, validates the configured DB connection string format, and attempts a DB ping. Use **`-doctor-json`** for machine-readable output. If both flags were passed, `-doctor-json` wins. Exits without starting the TUI or listening on a port. See [ARCHITECTURE.md](ARCHITECTURE.md) for details.
 
 ## Admin Commands
 

internal/doctor/db_checks.go

@@ -0,0 +1,51 @@
+package doctor
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-sql-driver/mysql"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+type dbTarget struct {
+	driver  string
+	dialect string
+	dsn     string
+}
+
+func detectDBTarget(conn string) dbTarget {
+	v := strings.TrimSpace(conn)
+	switch {
+	case strings.HasPrefix(v, "postgres://"), strings.HasPrefix(v, "postgresql://"):
+		return dbTarget{driver: "pgx", dialect: "postgres", dsn: v}
+	case strings.HasPrefix(v, "mysql://"):
+		return dbTarget{driver: "mysql", dialect: "mysql", dsn: strings.TrimPrefix(v, "mysql://")}
+	case strings.HasPrefix(v, "mysql:"):
+		return dbTarget{driver: "mysql", dialect: "mysql", dsn: strings.TrimPrefix(v, "mysql:")}
+	default:
+		return dbTarget{driver: "sqlite", dialect: "sqlite", dsn: v}
+	}
+}
+
+func validateConnectionString(t dbTarget) error {
+	switch t.dialect {
+	case "postgres":
+		_, err := pgconn.ParseConfig(t.dsn)
+		if err != nil {
+			return fmt.Errorf("invalid Postgres DSN: %w", err)
+		}
+		return nil
+	case "mysql":
+		_, err := mysql.ParseDSN(t.dsn)
+		if err != nil {
+			return fmt.Errorf("invalid MySQL DSN: %w", err)
+		}
+		return nil
+	default:
+		if strings.TrimSpace(t.dsn) == "" {
+			return fmt.Errorf("sqlite path is empty")
+		}
+		return nil
+	}
+}

internal/doctor/db_checks_test.go

@@ -0,0 +1,61 @@
+package doctor
+
+import "testing"
+
+func TestDetectDBTarget(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		in      string
+		dialect string
+		driver  string
+		dsn     string
+	}{
+		{"postgres://u:p@localhost:5432/marchat?sslmode=disable", "postgres", "pgx", "postgres://u:p@localhost:5432/marchat?sslmode=disable"},
+		{"mysql://u:p@tcp(localhost:3306)/marchat?parseTime=true", "mysql", "mysql", "u:p@tcp(localhost:3306)/marchat?parseTime=true"},
+		{"mysql:u:p@tcp(localhost:3306)/marchat?parseTime=true", "mysql", "mysql", "u:p@tcp(localhost:3306)/marchat?parseTime=true"},
+		{"./config/marchat.db", "sqlite", "sqlite", "./config/marchat.db"},
+	}
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.in, func(t *testing.T) {
+			t.Parallel()
+			got := detectDBTarget(tc.in)
+			if got.dialect != tc.dialect || got.driver != tc.driver || got.dsn != tc.dsn {
+				t.Fatalf("detectDBTarget(%q) = %+v", tc.in, got)
+			}
+		})
+	}
+}
+
+func TestValidateConnectionString(t *testing.T) {
+	t.Parallel()
+	valid := []dbTarget{
+		{dialect: "sqlite", dsn: "./config/marchat.db"},
+		{dialect: "postgres", dsn: "postgres://u:p@localhost:5432/marchat?sslmode=disable"},
+		{dialect: "mysql", dsn: "u:p@tcp(localhost:3306)/marchat?parseTime=true"},
+	}
+	for _, tc := range valid {
+		tc := tc
+		t.Run(tc.dialect+"_valid", func(t *testing.T) {
+			t.Parallel()
+			if err := validateConnectionString(tc); err != nil {
+				t.Fatalf("expected valid connection string, got error: %v", err)
+			}
+		})
+	}
+
+	invalid := []dbTarget{
+		{dialect: "sqlite", dsn: "   "},
+		{dialect: "postgres", dsn: "postgres://%"},
+		{dialect: "mysql", dsn: "not-a-dsn"},
+	}
+	for _, tc := range invalid {
+		tc := tc
+		t.Run(tc.dialect+"_invalid", func(t *testing.T) {
+			t.Parallel()
+			if err := validateConnectionString(tc); err == nil {
+				t.Fatal("expected invalid connection string error")
+			}
+		})
+	}
+}

internal/doctor/doctor.go

@@ -18,6 +18,8 @@ import (
 	"github.com/Cod-e-Codes/marchat/shared"
 	"github.com/atotto/clipboard"
 	"github.com/charmbracelet/x/term"
+	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/jackc/pgx/v5/stdlib"
 	_ "modernc.org/sqlite"
 )
 
@@ -144,19 +146,31 @@ func RunServer(o Options) error {
 
 		dbPath := cfg.DBPath
 		appendCheck(&checks, "db_path", "ok", fmt.Sprintf("database path: %s", dbPath))
-		parent := filepath.Dir(dbPath)
-		if fi, err := os.Stat(parent); err != nil {
-			appendCheck(&checks, "db_parent", "warn", fmt.Sprintf("database parent dir: %v", err))
-		} else if !fi.IsDir() {
-			appendCheck(&checks, "db_parent", "error", "database parent path is not a directory")
+
+		target := detectDBTarget(dbPath)
+		appendCheck(&checks, "db_dialect", "ok", fmt.Sprintf("detected DB dialect: %s (driver: %s)", target.dialect, target.driver))
+
+		if err := validateConnectionString(target); err != nil {
+			appendCheck(&checks, "db_connection_string", "error", err.Error())
 		} else {
-			f, err := os.CreateTemp(parent, "marchat-doctor-*.tmp")
-			if err != nil {
-				appendCheck(&checks, "db_parent_writable", "warn", fmt.Sprintf("cannot create temp file in DB parent: %v", err))
+			appendCheck(&checks, "db_connection_string", "ok", "connection string format is valid")
+		}
+
+		if target.dialect == "sqlite" {
+			parent := filepath.Dir(dbPath)
+			if fi, err := os.Stat(parent); err != nil {
+				appendCheck(&checks, "db_parent", "warn", fmt.Sprintf("database parent dir: %v", err))
+			} else if !fi.IsDir() {
+				appendCheck(&checks, "db_parent", "error", "database parent path is not a directory")
 			} else {
-				_ = f.Close()
-				_ = os.Remove(f.Name())
-				appendCheck(&checks, "db_parent_writable", "ok", "database parent directory is writable")
+				f, err := os.CreateTemp(parent, "marchat-doctor-*.tmp")
+				if err != nil {
+					appendCheck(&checks, "db_parent_writable", "warn", fmt.Sprintf("cannot create temp file in DB parent: %v", err))
+				} else {
+					_ = f.Close()
+					_ = os.Remove(f.Name())
+					appendCheck(&checks, "db_parent_writable", "ok", "database parent directory is writable")
+				}
 			}
 		}
 
@@ -181,15 +195,15 @@ func RunServer(o Options) error {
 
 		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 		defer cancel()
-		db, err := sql.Open("sqlite", dbPath)
+		db, err := sql.Open(target.driver, target.dsn)
 		if err != nil {
-			appendCheck(&checks, "sqlite_ping", "warn", fmt.Sprintf("open sqlite: %v", err))
+			appendCheck(&checks, "db_ping", "warn", fmt.Sprintf("open %s: %v", target.dialect, err))
 		} else {
 			defer db.Close()
 			if err := db.PingContext(ctx); err != nil {
-				appendCheck(&checks, "sqlite_ping", "warn", fmt.Sprintf("sqlite ping: %v", err))
+				appendCheck(&checks, "db_ping", "warn", fmt.Sprintf("%s ping: %v", target.dialect, err))
 			} else {
-				appendCheck(&checks, "sqlite_ping", "ok", "sqlite database reachable")
+				appendCheck(&checks, "db_ping", "ok", fmt.Sprintf("%s database reachable", target.dialect))
 			}
 		}
 	}

server/message_state_test.go

@@ -74,3 +74,32 @@ func TestPersistReaction_RemovalUsesReactionTargetID(t *testing.T) {
 		t.Fatalf("expected 0 replayed reactions after removal, got %d", len(replayed))
 	}
 }
+
+func TestDurableStateLoaders_HandleEmptyTablesOnFirstBoot(t *testing.T) {
+	db, err := InitDB(":memory:")
+	if err != nil {
+		t.Fatalf("InitDB failed: %v", err)
+	}
+	defer db.Close()
+	CreateSchema(db)
+
+	id, err := InsertMessage(db, shared.Message{Sender: "alice", Content: "hello", CreatedAt: time.Now()})
+	if err != nil {
+		t.Fatalf("InsertMessage failed: %v", err)
+	}
+
+	reactions := LoadReactionsForMessages(db, []int64{id})
+	if len(reactions) != 0 {
+		t.Fatalf("expected no reactions from empty message_reactions table, got %d", len(reactions))
+	}
+
+	receipts := LoadReadReceiptsForMessages(db, "alice", []int64{id})
+	if len(receipts) != 0 {
+		t.Fatalf("expected no receipts from empty read_receipts table, got %d", len(receipts))
+	}
+
+	channel := LoadUserChannel(db, "alice")
+	if channel != "" {
+		t.Fatalf("expected empty channel from empty user_channels table, got %q", channel)
+	}
+}