feat(cli): add --dry-run to convert, merge and split

Read and validate inputs, apply filtering/merging in memory, validate the
output target (format, --package, --schema, --extra-fields) and print the
plan to stdout without writing any output. Closes #35.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

cmd/relspec/convert.go

@@ -3,6 +3,7 @@ package main
 import (
 	stdjson "encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"strings"
 	"time"
@@ -57,6 +58,7 @@ var (
 	convertNullableArrays  string
 	convertContinueOnError bool
 	convertExtraFields     string
+	convertDryRun          bool
 )
 
 var convertCmd = &cobra.Command{
@@ -185,6 +187,8 @@ func init() {
 	convertCmd.Flags().BoolVar(&convertContinueOnError, "continue-on-error", false, "Prepend \\set ON_ERROR_STOP off to generated SQL so psql continues past errors (pgsql output only)")
 	convertCmd.Flags().StringVar(&convertExtraFields, "extra-fields", "", "Path to JSON file containing extra Bun model fields to inject (bun output only); fields support target_table, name, type, bun_tag, json_tag, comment")
 
+	convertCmd.Flags().BoolVar(&convertDryRun, "dry-run", false, "Read and validate the input and print the plan without writing any output")
+
 	err := convertCmd.MarkFlagRequired("from")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error marking from flag as required: %v\n", err)
@@ -240,6 +244,22 @@ func runConvert(cmd *cobra.Command, args []string) error {
 	}
 	fmt.Fprintf(os.Stderr, "      Found: %d table(s)\n\n", totalTables)
 
+	if convertDryRun {
+		if err := validateWriteTarget(db, convertTargetType, convertPackageName, convertSchemaFilter, convertExtraFields); err != nil {
+			return fmt.Errorf("dry run validation failed: %w", err)
+		}
+		out := outWriter(cmd)
+		fmt.Fprintf(out, "RelSpec convert plan (dry run - nothing written):\n")
+		fmt.Fprintf(out, "  Input:  %s database '%s'\n", convertSourceType, db.Name)
+		fmt.Fprintf(out, "  Output: %s -> %s\n", convertTargetType, convertTargetPath)
+		if convertSchemaFilter != "" {
+			fmt.Fprintf(out, "  Schema filter: %s\n", convertSchemaFilter)
+		}
+		printDryRunPlan(out, db)
+		fmt.Fprintf(os.Stderr, "=== Dry run complete: no output written ===\n\n")
+		return nil
+	}
+
 	// Write to target format
 	fmt.Fprintf(os.Stderr, "[2/2] Writing to target format...\n")
 	fmt.Fprintf(os.Stderr, "      Format: %s\n", convertTargetType)
@@ -408,23 +428,12 @@ func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaF
 
 	writerOpts := newWriterOptions(outputPath, packageName, flattenSchema, nullableTypes, nullableArrays, continueOnError)
 	if extraFields != "" {
-		if !strings.EqualFold(dbType, "bun") {
-			return fmt.Errorf("--extra-fields is only supported for Bun output")
-		}
-		extraFieldsJSON, err := os.ReadFile(extraFields)
+		extraFieldsJSON, err := loadExtraFields(dbType, extraFields)
 		if err != nil {
-			return fmt.Errorf("failed to read --extra-fields file %q: %w", extraFields, err)
-		}
-
-		var parsed []wbun.ExtraFieldConfig
-		if err := stdjson.Unmarshal(extraFieldsJSON, &parsed); err != nil {
-			return fmt.Errorf("invalid --extra-fields JSON in %q: %w", extraFields, err)
-		}
-		if len(parsed) == 0 {
-			return fmt.Errorf("--extra-fields must contain at least one field")
+			return err
 		}
 		writerOpts.Metadata = map[string]interface{}{
-			"extra_fields": string(extraFieldsJSON),
+			"extra_fields": extraFieldsJSON,
 		}
 	}
 
@@ -529,6 +538,95 @@ func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaF
 	return nil
 }
 
+// loadExtraFields reads and validates the --extra-fields JSON file, returning
+// its raw content.
+func loadExtraFields(dbType, path string) (string, error) {
+	if !strings.EqualFold(dbType, "bun") {
+		return "", fmt.Errorf("--extra-fields is only supported for Bun output")
+	}
+	extraFieldsJSON, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read --extra-fields file %q: %w", path, err)
+	}
+
+	var parsed []wbun.ExtraFieldConfig
+	if err := stdjson.Unmarshal(extraFieldsJSON, &parsed); err != nil {
+		return "", fmt.Errorf("invalid --extra-fields JSON in %q: %w", path, err)
+	}
+	if len(parsed) == 0 {
+		return "", fmt.Errorf("--extra-fields must contain at least one field")
+	}
+	return string(extraFieldsJSON), nil
+}
+
+// validateWriteTarget performs the checks writeDatabase makes before writing,
+// without constructing a writer or touching the output path. Used by --dry-run.
+func validateWriteTarget(db *models.Database, dbType, packageName, schemaFilter, extraFields string) error {
+	if extraFields != "" {
+		if _, err := loadExtraFields(dbType, extraFields); err != nil {
+			return err
+		}
+	}
+
+	switch strings.ToLower(dbType) {
+	case "dbml", "dctx", "drawdb", "json", "yaml", "yml", "drizzle",
+		"pgsql", "postgres", "postgresql", "sql",
+		"mssql", "sqlserver", "mssql2016", "mssql2017", "mssql2019", "mssql2022",
+		"sqlite", "sqlite3", "prisma", "typeorm", "graphql", "gql":
+	case "gorm", "bun":
+		if packageName == "" {
+			return fmt.Errorf("package name is required for %s format (use --package flag)", dbType)
+		}
+	default:
+		return fmt.Errorf("unsupported target format: %s", dbType)
+	}
+
+	if schemaFilter != "" {
+		for _, schema := range db.Schemas {
+			if schema.Name == schemaFilter {
+				return nil
+			}
+		}
+		return fmt.Errorf("schema '%s' not found in database. Available schemas: %v",
+			schemaFilter, getSchemaNames(db))
+	}
+
+	if strings.EqualFold(dbType, "dctx") {
+		if len(db.Schemas) == 0 {
+			return fmt.Errorf("no schemas found in database")
+		}
+		if len(db.Schemas) > 1 {
+			return fmt.Errorf("multiple schemas found, please specify which schema to export using --schema flag. Available schemas: %v",
+				getSchemaNames(db))
+		}
+	}
+	return nil
+}
+
+// outWriter returns the command's stdout, falling back to os.Stdout when the
+// command is nil (tests call the run functions directly).
+func outWriter(cmd *cobra.Command) io.Writer {
+	if cmd == nil {
+		return os.Stdout
+	}
+	return cmd.OutOrStdout()
+}
+
+// printDryRunPlan prints the schemas and tables that would be written.
+func printDryRunPlan(out io.Writer, db *models.Database) {
+	for _, schema := range db.Schemas {
+		names := make([]string, 0, len(schema.Tables))
+		for _, t := range schema.Tables {
+			names = append(names, t.Name)
+		}
+		fmt.Fprintf(out, "    schema %q: %d table(s)", schema.Name, len(schema.Tables))
+		if len(names) > 0 {
+			fmt.Fprintf(out, " [%s]", strings.Join(names, ", "))
+		}
+		fmt.Fprintln(out)
+	}
+}
+
 // getSchemaNames returns a slice of schema names from a database
 func getSchemaNames(db *models.Database) []string {
 	names := make([]string, len(db.Schemas))

cmd/relspec/dry_run_test.go

@@ -0,0 +1,158 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func newDryRunCmd() (*cobra.Command, *bytes.Buffer) {
+	var buf bytes.Buffer
+	cmd := &cobra.Command{}
+	cmd.SetOut(&buf)
+	return cmd, &buf
+}
+
+func TestRunConvert_DryRunWritesNothing(t *testing.T) {
+	defer func(a, b, c, d string, e bool) {
+		convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun = a, b, c, d, e
+	}(convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun)
+
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.json")
+	out := filepath.Join(dir, "out.json")
+	writeTestJSON(t, in, []string{"users", "posts"})
+
+	convertSourceType, convertSourcePath = "json", in
+	convertTargetType, convertTargetPath = "json", out
+	convertDryRun = true
+
+	cmd, buf := newDryRunCmd()
+	if err := runConvert(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output file")
+	}
+	for _, want := range []string{"dry run", "users", "posts", out} {
+		if !strings.Contains(buf.String(), want) {
+			t.Errorf("plan missing %q:\n%s", want, buf.String())
+		}
+	}
+
+	// Normal behavior is unchanged.
+	convertDryRun = false
+	if err := runConvert(cmd, nil); err != nil {
+		t.Fatalf("real run: %v", err)
+	}
+	if _, err := os.Stat(out); err != nil {
+		t.Fatalf("real run should write output: %v", err)
+	}
+}
+
+func TestRunConvert_DryRunValidatesTarget(t *testing.T) {
+	defer func(a, b, c, d string, e bool) {
+		convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun = a, b, c, d, e
+	}(convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun)
+
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.json")
+	out := filepath.Join(dir, "models")
+	writeTestJSON(t, in, []string{"users"})
+
+	convertSourceType, convertSourcePath = "json", in
+	convertDryRun = true
+
+	// gorm without --package must fail validation, as a real run would.
+	convertTargetType, convertTargetPath = "gorm", out
+	cmd, _ := newDryRunCmd()
+	err := runConvert(cmd, nil)
+	if err == nil || !strings.Contains(err.Error(), "package name is required") {
+		t.Fatalf("expected package validation error, got %v", err)
+	}
+
+	convertTargetType = "nope"
+	err = runConvert(cmd, nil)
+	if err == nil || !strings.Contains(err.Error(), "unsupported target format") {
+		t.Fatalf("expected unsupported format error, got %v", err)
+	}
+	if _, statErr := os.Stat(out); !os.IsNotExist(statErr) {
+		t.Fatal("dry run must not create the output path")
+	}
+}
+
+func TestRunSplit_DryRunWritesNothing(t *testing.T) {
+	defer func(a, b, c, d, e string, f bool) {
+		splitSourceType, splitSourcePath, splitTargetType, splitTargetPath, splitTables, splitDryRun = a, b, c, d, e, f
+	}(splitSourceType, splitSourcePath, splitTargetType, splitTargetPath, splitTables, splitDryRun)
+
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.json")
+	out := filepath.Join(dir, "subset.json")
+	writeTestJSON(t, in, []string{"users", "posts", "comments"})
+
+	splitSourceType, splitSourcePath = "json", in
+	splitTargetType, splitTargetPath = "json", out
+	splitTables = "users,posts"
+	splitDryRun = true
+
+	cmd, buf := newDryRunCmd()
+	if err := runSplit(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output file")
+	}
+	got := buf.String()
+	if !strings.Contains(got, "2 table(s)") || strings.Contains(got, "comments") {
+		t.Errorf("plan should show only the 2 selected tables:\n%s", got)
+	}
+
+	// A selection that matches nothing fails validation in dry-run too.
+	splitTables = "does_not_exist"
+	if err := runSplit(cmd, nil); err == nil {
+		t.Fatal("expected error for empty selection")
+	}
+}
+
+func TestRunMerge_DryRunWritesNothing(t *testing.T) {
+	saved := saveMergeState()
+	defer restoreMergeState(saved)
+	defer func(v bool) { mergeDryRun = v }(mergeDryRun)
+
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target.json")
+	source := filepath.Join(dir, "source.json")
+	out := filepath.Join(dir, "merged.json")
+	writeTestJSON(t, target, []string{"users"})
+	writeTestJSON(t, source, []string{"posts"})
+
+	mergeTargetType, mergeTargetPath, mergeTargetConn = "json", target, ""
+	mergeSourceType, mergeSourcePath, mergeSourceConn = "json", source, ""
+	mergeFromList = nil
+	mergeOutputType, mergeOutputPath, mergeOutputConn = "json", out, ""
+	mergeSkipTables, mergeReportPath = "", ""
+	mergeDryRun = true
+
+	cmd, buf := newDryRunCmd()
+	if err := runMerge(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output file")
+	}
+	for _, want := range []string{"dry run", "users", "posts", out} {
+		if !strings.Contains(buf.String(), want) {
+			t.Errorf("plan missing %q:\n%s", want, buf.String())
+		}
+	}
+
+	mergeOutputType = "nope"
+	if err := runMerge(cmd, nil); err == nil || !strings.Contains(err.Error(), "unsupported format") {
+		t.Fatalf("expected unsupported output format error, got %v", err)
+	}
+}

cmd/relspec/merge.go

@@ -61,6 +61,7 @@ var (
 	mergeReportPath    string // Path to write merge report
 	mergeFullDDL       bool   // Execute full DDL instead of diffing the live pgsql database
 	mergeFlattenSchema bool
+	mergeDryRun        bool
 )
 
 var mergeCmd = &cobra.Command{
@@ -130,6 +131,7 @@ func init() {
 	mergeCmd.Flags().BoolVar(&mergeVerbose, "verbose", false, "Show verbose output")
 	mergeCmd.Flags().BoolVar(&mergeFullDDL, "full-ddl", false, "pgsql database output: execute the full DDL instead of only the differences from the live database")
 	mergeCmd.Flags().StringVar(&mergeReportPath, "merge-report", "", "Path to write merge report (JSON format)")
+	mergeCmd.Flags().BoolVar(&mergeDryRun, "dry-run", false, "Read and merge in memory, then print the merge plan without writing any output")
 	mergeCmd.Flags().BoolVar(&mergeFlattenSchema, "flatten-schema", false, "Flatten schema.table names to schema_table (useful for databases like SQLite that do not support schemas)")
 }
 
@@ -264,6 +266,29 @@ func runMerge(cmd *cobra.Command, args []string) error {
 			merge.GetColumnTypeConflictSummary(result, 10))
 	}
 
+	if mergeDryRun {
+		if !isMergeOutputFormat(mergeOutputType) {
+			return fmt.Errorf("dry run validation failed: Output: unsupported format '%s'", mergeOutputType)
+		}
+		out := outWriter(cmd)
+		fmt.Fprintf(out, "RelSpec merge plan (dry run - nothing written):\n")
+		fmt.Fprintf(out, "  Target: %s database '%s'\n", mergeTargetType, targetDB.Name)
+		fmt.Fprintf(out, "  Source: %s database '%s'\n", mergeSourceType, sourceDB.Name)
+		switch {
+		case mergeOutputPath != "":
+			fmt.Fprintf(out, "  Output: %s -> %s\n", mergeOutputType, mergeOutputPath)
+		case mergeOutputConn != "":
+			fmt.Fprintf(out, "  Output: %s -> %s\n", mergeOutputType, maskPassword(mergeOutputConn))
+		default:
+			fmt.Fprintf(out, "  Output: %s\n", mergeOutputType)
+		}
+		fmt.Fprintf(out, "  Result:\n")
+		printDryRunPlan(out, targetDB)
+		fmt.Fprintf(out, "\n%s\n", merge.GetMergeSummary(result))
+		fmt.Fprintf(os.Stderr, "\n=== Dry run complete: no output written ===\n")
+		return nil
+	}
+
 	// Step 4: Write output
 	fmt.Fprintf(os.Stderr, "\n[4/4] Writing output...\n")
 	fmt.Fprintf(os.Stderr, "      Format: %s\n", mergeOutputType)
@@ -285,6 +310,16 @@ func runMerge(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+// isMergeOutputFormat reports whether writeDatabaseForMerge supports dbType.
+func isMergeOutputFormat(dbType string) bool {
+	switch strings.ToLower(dbType) {
+	case "dbml", "dctx", "drawdb", "graphql", "json", "yaml", "gorm", "bun",
+		"drizzle", "prisma", "typeorm", "sqlite", "sqlite3", "pgsql":
+		return true
+	}
+	return false
+}
+
 func readDatabaseForMerge(dbType, filePath, connString, label string) (*models.Database, error) {
 	var reader readers.Reader
 

cmd/relspec/split.go

@@ -24,6 +24,7 @@ var (
 	splitExcludeTables  string
 	splitNullableTypes  string
 	splitNullableArrays string
+	splitDryRun         bool
 )
 
 var splitCmd = &cobra.Command{
@@ -115,6 +116,8 @@ func init() {
 	splitCmd.Flags().StringVar(&splitNullableTypes, "types", "", "Nullable type package for code-gen writers (bun/gorm): 'baselib' (default, Go pointer types), 'stdlib' (database/sql), or 'sqltypes'")
 	splitCmd.Flags().StringVar(&splitNullableArrays, "array-nullable", "", "Nullable PostgreSQL array representation for the Bun writer in stdlib/baselib --types mode: 'slice' (default, plain slice) or 'pointer_slice' (*[]T, distinguishes NULL from '{}')")
 
+	splitCmd.Flags().BoolVar(&splitDryRun, "dry-run", false, "Read, filter and validate the selection and print the plan without writing any output")
+
 	err := splitCmd.MarkFlagRequired("from")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error marking from flag as required: %v\n", err)
@@ -174,6 +177,26 @@ func runSplit(cmd *cobra.Command, args []string) error {
 	}
 	fmt.Fprintf(os.Stderr, "      ✓ Filtered to: %d schema(s), %d table(s)\n\n", len(filteredDB.Schemas), filteredTables)
 
+	if splitDryRun {
+		if err := validateWriteTarget(filteredDB, splitTargetType, splitPackageName, "", ""); err != nil {
+			return fmt.Errorf("dry run validation failed: %w", err)
+		}
+		out := outWriter(cmd)
+		fmt.Fprintf(out, "RelSpec split plan (dry run - nothing written):\n")
+		fmt.Fprintf(out, "  Input:  %s database '%s'\n", splitSourceType, db.Name)
+		fmt.Fprintf(out, "  Output: %s -> %s\n", splitTargetType, splitTargetPath)
+		fmt.Fprintf(out, "  Selection: %s\n", splitSelection{
+			Schemas:        parseCommaSeparated(splitSchemas),
+			Tables:         parseCommaSeparated(splitTables),
+			ExcludeSchemas: parseCommaSeparated(splitExcludeSchema),
+			ExcludeTables:  parseCommaSeparated(splitExcludeTables),
+			DatabaseName:   splitDatabaseName,
+		}.summary())
+		printDryRunPlan(out, filteredDB)
+		fmt.Fprintf(os.Stderr, "=== Dry run complete: no output written ===\n\n")
+		return nil
+	}
+
 	// Write to target format
 	fmt.Fprintf(os.Stderr, "[3/3] Writing to target format...\n")
 	fmt.Fprintf(os.Stderr, "      Format: %s\n", splitTargetType)

pkg/ui/domain_screens.go

@@ -207,10 +207,6 @@ func (se *SchemaEditor) showDomainEditor(index int, domain *models.Domain) {
 		se.showDomainList()
 	})
 
-	form.AddButton("Tables", func() {
-		se.showDomainTables(index)
-	})
-
 	form.AddButton("Delete", func() {
 		se.showDeleteDomainConfirm(index)
 	})

pkg/ui/main_menu.go

@@ -39,18 +39,6 @@ func (se *SchemaEditor) createMainMenu() tview.Primitive {
 		AddItem("Manage Domains", "View, create, edit, and delete domains", 'd', func() {
 			se.showDomainList()
 		}).
-		AddItem("Manage Indexes", "View, create, edit, and delete table indexes", 'x', func() {
-			se.showObjectList(se.indexKind())
-		}).
-		AddItem("Manage Views", "View, create, edit, and delete views", 'v', func() {
-			se.showObjectList(se.viewKind())
-		}).
-		AddItem("Manage Sequences", "View, create, edit, and delete sequences", 'u', func() {
-			se.showObjectList(se.sequenceKind())
-		}).
-		AddItem("Manage Scripts", "View, create, edit, and delete SQL scripts", 'c', func() {
-			se.showObjectList(se.scriptKind())
-		}).
 		AddItem("Import & Merge", "Import and merge schema from another database", 'i', func() {
 			se.showImportScreen()
 		}).

pkg/ui/object_dataops.go

@@ -1,263 +0,0 @@
-package ui
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"git.warky.dev/wdevs/relspecgo/pkg/models"
-)
-
-// Data operations for indexes, views, sequences, scripts and domain/table assignment.
-
-func (se *SchemaEditor) schemaAt(schemaIndex int) (*models.Schema, error) {
-	if schemaIndex < 0 || schemaIndex >= len(se.db.Schemas) {
-		return nil, errors.New("schema not found")
-	}
-	return se.db.Schemas[schemaIndex], nil
-}
-
-func (se *SchemaEditor) tableAt(schemaIndex, tableIndex int) (*models.Schema, *models.Table, error) {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil {
-		return nil, nil, err
-	}
-	if tableIndex < 0 || tableIndex >= len(schema.Tables) {
-		return nil, nil, errors.New("table not found")
-	}
-	return schema, schema.Tables[tableIndex], nil
-}
-
-// splitList splits a comma separated list, trimming blanks and dropping empty entries.
-func splitList(s string) []string {
-	parts := make([]string, 0)
-	for _, p := range strings.Split(s, ",") {
-		if p = strings.TrimSpace(p); p != "" {
-			parts = append(parts, p)
-		}
-	}
-	return parts
-}
-
-// SaveIndex adds an index to a table. When oldName is non-empty the index of that
-// name is replaced (and renamed if needed).
-func (se *SchemaEditor) SaveIndex(schemaIndex, tableIndex int, oldName string, idx *models.Index) error {
-	schema, table, err := se.tableAt(schemaIndex, tableIndex)
-	if err != nil {
-		return err
-	}
-	idx.Name = strings.TrimSpace(idx.Name)
-	if idx.Name == "" {
-		return errors.New("index name is required")
-	}
-	if len(idx.Columns) == 0 {
-		return errors.New("index needs at least one column")
-	}
-	for _, c := range idx.Columns {
-		if _, ok := table.Columns[c]; !ok {
-			return fmt.Errorf("column %q not found in table %s", c, table.Name)
-		}
-	}
-	if _, exists := table.Indexes[idx.Name]; exists && idx.Name != oldName {
-		return fmt.Errorf("index %q already exists", idx.Name)
-	}
-	if table.Indexes == nil {
-		table.Indexes = make(map[string]*models.Index)
-	}
-	if oldName != "" {
-		delete(table.Indexes, oldName)
-	}
-	idx.Table = table.Name
-	idx.Schema = schema.Name
-	table.Indexes[idx.Name] = idx
-	table.UpdateDate()
-	se.db.UpdateDate()
-	return nil
-}
-
-// DeleteIndex removes an index from a table.
-func (se *SchemaEditor) DeleteIndex(schemaIndex, tableIndex int, name string) bool {
-	_, table, err := se.tableAt(schemaIndex, tableIndex)
-	if err != nil {
-		return false
-	}
-	if _, ok := table.Indexes[name]; !ok {
-		return false
-	}
-	delete(table.Indexes, name)
-	table.UpdateDate()
-	se.db.UpdateDate()
-	return true
-}
-
-// SaveView adds a view to a schema, or replaces the one at position at (use -1 to add).
-func (se *SchemaEditor) SaveView(schemaIndex, at int, v *models.View) error {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil {
-		return err
-	}
-	v.Name = strings.TrimSpace(v.Name)
-	if v.Name == "" {
-		return errors.New("view name is required")
-	}
-	if strings.TrimSpace(v.Definition) == "" {
-		return errors.New("view definition is required")
-	}
-	for i, o := range schema.Views {
-		if i != at && o.Name == v.Name {
-			return fmt.Errorf("view %q already exists", v.Name)
-		}
-	}
-	v.Schema = schema.Name
-	if at >= 0 && at < len(schema.Views) {
-		schema.Views[at] = v
-	} else {
-		schema.Views = append(schema.Views, v)
-	}
-	schema.UpdateDate()
-	se.db.UpdateDate()
-	return nil
-}
-
-// DeleteView removes the view at position at.
-func (se *SchemaEditor) DeleteView(schemaIndex, at int) bool {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil || at < 0 || at >= len(schema.Views) {
-		return false
-	}
-	schema.Views = append(schema.Views[:at], schema.Views[at+1:]...)
-	schema.UpdateDate()
-	se.db.UpdateDate()
-	return true
-}
-
-// SaveSequence adds a sequence to a schema, or replaces the one at position at (use -1 to add).
-func (se *SchemaEditor) SaveSequence(schemaIndex, at int, s *models.Sequence) error {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil {
-		return err
-	}
-	s.Name = strings.TrimSpace(s.Name)
-	if s.Name == "" {
-		return errors.New("sequence name is required")
-	}
-	if s.IncrementBy == 0 {
-		return errors.New("increment must not be zero")
-	}
-	for i, o := range schema.Sequences {
-		if i != at && o.Name == s.Name {
-			return fmt.Errorf("sequence %q already exists", s.Name)
-		}
-	}
-	s.Schema = schema.Name
-	if at >= 0 && at < len(schema.Sequences) {
-		schema.Sequences[at] = s
-	} else {
-		schema.Sequences = append(schema.Sequences, s)
-	}
-	schema.UpdateDate()
-	se.db.UpdateDate()
-	return nil
-}
-
-// DeleteSequence removes the sequence at position at.
-func (se *SchemaEditor) DeleteSequence(schemaIndex, at int) bool {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil || at < 0 || at >= len(schema.Sequences) {
-		return false
-	}
-	schema.Sequences = append(schema.Sequences[:at], schema.Sequences[at+1:]...)
-	schema.UpdateDate()
-	se.db.UpdateDate()
-	return true
-}
-
-// SaveScript adds a script to a schema, or replaces the one at position at (use -1 to add).
-func (se *SchemaEditor) SaveScript(schemaIndex, at int, s *models.Script) error {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil {
-		return err
-	}
-	s.Name = strings.TrimSpace(s.Name)
-	if s.Name == "" {
-		return errors.New("script name is required")
-	}
-	if strings.TrimSpace(s.SQL) == "" {
-		return errors.New("script SQL is required")
-	}
-	for i, o := range schema.Scripts {
-		if i != at && o.Name == s.Name {
-			return fmt.Errorf("script %q already exists", s.Name)
-		}
-	}
-	s.Schema = schema.Name
-	if at >= 0 && at < len(schema.Scripts) {
-		schema.Scripts[at] = s
-	} else {
-		schema.Scripts = append(schema.Scripts, s)
-	}
-	schema.UpdateDate()
-	se.db.UpdateDate()
-	return nil
-}
-
-// DeleteScript removes the script at position at.
-func (se *SchemaEditor) DeleteScript(schemaIndex, at int) bool {
-	schema, err := se.schemaAt(schemaIndex)
-	if err != nil || at < 0 || at >= len(schema.Scripts) {
-		return false
-	}
-	schema.Scripts = append(schema.Scripts[:at], schema.Scripts[at+1:]...)
-	schema.UpdateDate()
-	se.db.UpdateDate()
-	return true
-}
-
-// AssignTableToDomain adds a reference to schemaName.tableName to the domain at domainIndex.
-func (se *SchemaEditor) AssignTableToDomain(domainIndex int, schemaName, tableName string) error {
-	if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
-		return errors.New("domain not found")
-	}
-	domain := se.db.Domains[domainIndex]
-	var table *models.Table
-	for _, s := range se.db.Schemas {
-		if s.Name != schemaName {
-			continue
-		}
-		for _, t := range s.Tables {
-			if t.Name == tableName {
-				table = t
-			}
-		}
-	}
-	if table == nil {
-		return fmt.Errorf("table %s.%s not found", schemaName, tableName)
-	}
-	for _, dt := range domain.Tables {
-		if dt.SchemaName == schemaName && dt.TableName == tableName {
-			return fmt.Errorf("table %s.%s is already in domain %s", schemaName, tableName, domain.Name)
-		}
-	}
-	dt := models.InitDomainTable(tableName, schemaName)
-	dt.RefTable = table
-	dt.Sequence = uint(len(domain.Tables))
-	domain.Tables = append(domain.Tables, dt)
-	se.db.UpdateDate()
-	return nil
-}
-
-// UnassignTableFromDomain removes the reference to schemaName.tableName from the domain.
-func (se *SchemaEditor) UnassignTableFromDomain(domainIndex int, schemaName, tableName string) bool {
-	if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
-		return false
-	}
-	domain := se.db.Domains[domainIndex]
-	for i, dt := range domain.Tables {
-		if dt.SchemaName == schemaName && dt.TableName == tableName {
-			domain.Tables = append(domain.Tables[:i], domain.Tables[i+1:]...)
-			se.db.UpdateDate()
-			return true
-		}
-	}
-	return false
-}

pkg/ui/object_dataops_test.go

@@ -1,136 +0,0 @@
-package ui
-
-import (
-	"testing"
-
-	"git.warky.dev/wdevs/relspecgo/pkg/models"
-)
-
-func newTestEditor() *SchemaEditor {
-	db := models.InitDatabase("test")
-	schema := models.InitSchema("public")
-	table := models.InitTable("users", "public")
-	table.Columns["id"] = models.InitColumn("id", "users", "public")
-	table.Columns["email"] = models.InitColumn("email", "users", "public")
-	schema.Tables = append(schema.Tables, table)
-	db.Schemas = append(db.Schemas, schema)
-	return &SchemaEditor{db: db}
-}
-
-func TestSaveIndex(t *testing.T) {
-	se := newTestEditor()
-	table := se.db.Schemas[0].Tables[0]
-
-	tests := []struct {
-		name    string
-		old     string
-		idx     *models.Index
-		wantErr bool
-	}{
-		{"valid", "", &models.Index{Name: "idx_email", Columns: []string{"email"}, Unique: true}, false},
-		{"duplicate", "", &models.Index{Name: "idx_email", Columns: []string{"email"}}, true},
-		{"missing name", "", &models.Index{Columns: []string{"email"}}, true},
-		{"no columns", "", &models.Index{Name: "idx_none"}, true},
-		{"unknown column", "", &models.Index{Name: "idx_bad", Columns: []string{"nope"}}, true},
-		{"rename", "idx_email", &models.Index{Name: "idx_email2", Columns: []string{"email", "id"}}, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := se.SaveIndex(0, 0, tt.old, tt.idx); (err != nil) != tt.wantErr {
-				t.Fatalf("err = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-	if _, ok := table.Indexes["idx_email"]; ok {
-		t.Error("renamed index should be gone under old name")
-	}
-	if idx := table.Indexes["idx_email2"]; idx == nil || idx.Table != "users" || idx.Schema != "public" {
-		t.Errorf("unexpected renamed index: %+v", idx)
-	}
-	if !se.DeleteIndex(0, 0, "idx_email2") || se.DeleteIndex(0, 0, "idx_email2") {
-		t.Error("delete should succeed once")
-	}
-}
-
-func TestSaveViewSequenceScript(t *testing.T) {
-	se := newTestEditor()
-	schema := se.db.Schemas[0]
-
-	if err := se.SaveView(0, -1, &models.View{Name: "v", Definition: "select 1"}); err != nil {
-		t.Fatal(err)
-	}
-	if err := se.SaveView(0, -1, &models.View{Name: "v", Definition: "select 2"}); err == nil {
-		t.Error("duplicate view accepted")
-	}
-	if err := se.SaveView(0, 0, &models.View{Name: "v", Definition: "select 3"}); err != nil {
-		t.Errorf("editing in place should not conflict: %v", err)
-	}
-	if err := se.SaveView(0, -1, &models.View{Name: "w"}); err == nil {
-		t.Error("view without definition accepted")
-	}
-	if len(schema.Views) != 1 || schema.Views[0].Definition != "select 3" || schema.Views[0].Schema != "public" {
-		t.Errorf("unexpected views: %+v", schema.Views)
-	}
-	if !se.DeleteView(0, 0) || se.DeleteView(0, 0) {
-		t.Error("view delete mismatch")
-	}
-
-	if err := se.SaveSequence(0, -1, &models.Sequence{Name: "s", IncrementBy: 1, StartValue: 1}); err != nil {
-		t.Fatal(err)
-	}
-	if err := se.SaveSequence(0, -1, &models.Sequence{Name: "z"}); err == nil {
-		t.Error("zero increment accepted")
-	}
-	if !se.DeleteSequence(0, 0) || len(schema.Sequences) != 0 {
-		t.Error("sequence delete failed")
-	}
-
-	if err := se.SaveScript(0, -1, &models.Script{Name: "init", SQL: "select 1"}); err != nil {
-		t.Fatal(err)
-	}
-	if err := se.SaveScript(0, -1, &models.Script{Name: "empty"}); err == nil {
-		t.Error("script without SQL accepted")
-	}
-	if err := se.SaveScript(5, -1, &models.Script{Name: "x", SQL: "y"}); err == nil {
-		t.Error("bad schema index accepted")
-	}
-	if !se.DeleteScript(0, 0) || len(schema.Scripts) != 0 {
-		t.Error("script delete failed")
-	}
-}
-
-func TestDomainTableAssignment(t *testing.T) {
-	se := newTestEditor()
-	se.createDomainNoUI("core")
-
-	if err := se.AssignTableToDomain(0, "public", "users"); err != nil {
-		t.Fatal(err)
-	}
-	if err := se.AssignTableToDomain(0, "public", "users"); err == nil {
-		t.Error("duplicate assignment accepted")
-	}
-	if err := se.AssignTableToDomain(0, "public", "missing"); err == nil {
-		t.Error("unknown table accepted")
-	}
-	if err := se.AssignTableToDomain(3, "public", "users"); err == nil {
-		t.Error("bad domain index accepted")
-	}
-	dt := se.db.Domains[0].Tables[0]
-	if dt.RefTable != se.db.Schemas[0].Tables[0] {
-		t.Error("RefTable not linked")
-	}
-	if !se.UnassignTableFromDomain(0, "public", "users") || se.UnassignTableFromDomain(0, "public", "users") {
-		t.Error("unassign mismatch")
-	}
-}
-
-func (se *SchemaEditor) createDomainNoUI(name string) {
-	se.db.Domains = append(se.db.Domains, models.InitDomain(name))
-}
-
-func TestSplitList(t *testing.T) {
-	got := splitList(" a, b,, c ,")
-	if len(got) != 3 || got[0] != "a" || got[2] != "c" {
-		t.Errorf("got %v", got)
-	}
-}

pkg/ui/object_screens.go

@@ -1,476 +0,0 @@
-package ui
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/gdamore/tcell/v2"
-	"github.com/rivo/tview"
-
-	"git.warky.dev/wdevs/relspecgo/pkg/models"
-)
-
-// objectLocation identifies where a new object is created: a schema, and for indexes also a table.
-type objectLocation struct {
-	label       string
-	schemaIndex int
-	tableIndex  int
-}
-
-// objectRow is one existing object shown in an object list.
-type objectRow struct {
-	cells       []string
-	schemaIndex int
-	tableIndex  int
-	at          int    // position within the schema slice (views, sequences, scripts)
-	name        string // map key (indexes)
-}
-
-// objectKind describes how a kind of schema object is listed and edited.
-type objectKind struct {
-	page      string
-	title     string
-	singular  string
-	headers   []string
-	rows      func() []objectRow
-	locations func() []objectLocation
-	// buildForm adds the editable fields to the form for row (nil when creating) and
-	// returns a function that validates and saves the values at the given location.
-	buildForm func(form *tview.Form, row *objectRow) func(loc objectLocation) error
-	remove    func(row objectRow) bool
-}
-
-func (se *SchemaEditor) schemaLocations() []objectLocation {
-	locs := make([]objectLocation, 0, len(se.db.Schemas))
-	for si, s := range se.db.Schemas {
-		locs = append(locs, objectLocation{label: s.Name, schemaIndex: si, tableIndex: -1})
-	}
-	return locs
-}
-
-func (se *SchemaEditor) tableLocations() []objectLocation {
-	locs := make([]objectLocation, 0)
-	for si, s := range se.db.Schemas {
-		for ti, t := range s.Tables {
-			locs = append(locs, objectLocation{label: s.Name + "." + t.Name, schemaIndex: si, tableIndex: ti})
-		}
-	}
-	return locs
-}
-
-func (se *SchemaEditor) indexKind() objectKind {
-	return objectKind{
-		page:      "indexes",
-		title:     "Manage Indexes",
-		singular:  "Index",
-		headers:   []string{"Name", "Schema", "Table", "Type", "Unique", "Columns"},
-		locations: se.tableLocations,
-		rows: func() []objectRow {
-			var rows []objectRow
-			for si, s := range se.db.Schemas {
-				for ti, t := range s.Tables {
-					for _, name := range sortedKeys(t.Indexes) {
-						idx := t.Indexes[name]
-						rows = append(rows, objectRow{
-							cells:       []string{idx.Name, s.Name, t.Name, idx.Type, strconv.FormatBool(idx.Unique), strings.Join(idx.Columns, ",")},
-							schemaIndex: si, tableIndex: ti, name: name,
-						})
-					}
-				}
-			}
-			return rows
-		},
-		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
-			idx := models.InitIndex("", "", "")
-			idx.Type = "btree"
-			if row != nil {
-				idx = se.db.Schemas[row.schemaIndex].Tables[row.tableIndex].Indexes[row.name]
-			}
-			name, columns, typ, where := idx.Name, strings.Join(idx.Columns, ", "), idx.Type, idx.Where
-			unique := idx.Unique
-			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
-			form.AddInputField("Columns (comma separated)", columns, 50, nil, func(v string) { columns = v })
-			form.AddInputField("Type", typ, 20, nil, func(v string) { typ = v })
-			form.AddCheckbox("Unique", unique, func(v bool) { unique = v })
-			form.AddInputField("Where", where, 50, nil, func(v string) { where = v })
-			return func(loc objectLocation) error {
-				oldName := ""
-				if row != nil {
-					oldName = row.name
-				}
-				next := *idx
-				next.Name, next.Columns, next.Type, next.Unique, next.Where = name, splitList(columns), typ, unique, where
-				return se.SaveIndex(loc.schemaIndex, loc.tableIndex, oldName, &next)
-			}
-		},
-		remove: func(r objectRow) bool { return se.DeleteIndex(r.schemaIndex, r.tableIndex, r.name) },
-	}
-}
-
-func (se *SchemaEditor) viewKind() objectKind {
-	return objectKind{
-		page:      "views",
-		title:     "Manage Views",
-		singular:  "View",
-		headers:   []string{"Name", "Schema", "Description"},
-		locations: se.schemaLocations,
-		rows: func() []objectRow {
-			var rows []objectRow
-			for si, s := range se.db.Schemas {
-				for i, v := range s.Views {
-					rows = append(rows, objectRow{cells: []string{v.Name, s.Name, v.Description}, schemaIndex: si, at: i})
-				}
-			}
-			return rows
-		},
-		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
-			view := models.InitView("", "")
-			at := -1
-			if row != nil {
-				view, at = se.db.Schemas[row.schemaIndex].Views[row.at], row.at
-			}
-			name, desc, def := view.Name, view.Description, view.Definition
-			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
-			form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
-			form.AddTextArea("Definition (SQL)", def, 60, 8, 0, func(v string) { def = v })
-			return func(loc objectLocation) error {
-				next := *view
-				next.Name, next.Description, next.Definition = name, desc, def
-				return se.SaveView(loc.schemaIndex, at, &next)
-			}
-		},
-		remove: func(r objectRow) bool { return se.DeleteView(r.schemaIndex, r.at) },
-	}
-}
-
-func (se *SchemaEditor) sequenceKind() objectKind {
-	return objectKind{
-		page:      "sequences",
-		title:     "Manage Sequences",
-		singular:  "Sequence",
-		headers:   []string{"Name", "Schema", "Start", "Increment", "Cycle", "Description"},
-		locations: se.schemaLocations,
-		rows: func() []objectRow {
-			var rows []objectRow
-			for si, s := range se.db.Schemas {
-				for i, q := range s.Sequences {
-					rows = append(rows, objectRow{
-						cells: []string{q.Name, s.Name, strconv.FormatInt(q.StartValue, 10), strconv.FormatInt(q.IncrementBy, 10), strconv.FormatBool(q.Cycle), q.Description}, schemaIndex: si, at: i,
-					})
-				}
-			}
-			return rows
-		},
-		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
-			seq := models.InitSequence("", "")
-			at := -1
-			if row != nil {
-				seq, at = se.db.Schemas[row.schemaIndex].Sequences[row.at], row.at
-			}
-			name, desc := seq.Name, seq.Description
-			start, incr := strconv.FormatInt(seq.StartValue, 10), strconv.FormatInt(seq.IncrementBy, 10)
-			minV, maxV := strconv.FormatInt(seq.MinValue, 10), strconv.FormatInt(seq.MaxValue, 10)
-			cycle := seq.Cycle
-			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
-			form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
-			form.AddInputField("Start", start, 20, nil, func(v string) { start = v })
-			form.AddInputField("Increment", incr, 20, nil, func(v string) { incr = v })
-			form.AddInputField("Min (0 = none)", minV, 20, nil, func(v string) { minV = v })
-			form.AddInputField("Max (0 = none)", maxV, 20, nil, func(v string) { maxV = v })
-			form.AddCheckbox("Cycle", cycle, func(v bool) { cycle = v })
-			return func(loc objectLocation) error {
-				next := *seq
-				next.Name, next.Description, next.Cycle = name, desc, cycle
-				for _, f := range []struct {
-					label string
-					text  string
-					dst   *int64
-				}{{"start", start, &next.StartValue}, {"increment", incr, &next.IncrementBy}, {"min", minV, &next.MinValue}, {"max", maxV, &next.MaxValue}} {
-					n, err := strconv.ParseInt(strings.TrimSpace(f.text), 10, 64)
-					if err != nil {
-						return fmt.Errorf("%s must be an integer", f.label)
-					}
-					*f.dst = n
-				}
-				return se.SaveSequence(loc.schemaIndex, at, &next)
-			}
-		},
-		remove: func(r objectRow) bool { return se.DeleteSequence(r.schemaIndex, r.at) },
-	}
-}
-
-func (se *SchemaEditor) scriptKind() objectKind {
-	return objectKind{
-		page:      "scripts",
-		title:     "Manage Scripts",
-		singular:  "Script",
-		headers:   []string{"Name", "Schema", "Version", "Priority", "Description"},
-		locations: se.schemaLocations,
-		rows: func() []objectRow {
-			var rows []objectRow
-			for si, s := range se.db.Schemas {
-				for i, sc := range s.Scripts {
-					rows = append(rows, objectRow{cells: []string{sc.Name, s.Name, sc.Version, strconv.Itoa(sc.Priority), sc.Description}, schemaIndex: si, at: i})
-				}
-			}
-			return rows
-		},
-		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
-			script := models.InitScript("")
-			at := -1
-			if row != nil {
-				script, at = se.db.Schemas[row.schemaIndex].Scripts[row.at], row.at
-			}
-			name, desc, version, sql, rollback := script.Name, script.Description, script.Version, script.SQL, script.Rollback
-			priority, runAfter := strconv.Itoa(script.Priority), strings.Join(script.RunAfter, ", ")
-			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
-			form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
-			form.AddInputField("Version", version, 20, nil, func(v string) { version = v })
-			form.AddInputField("Priority", priority, 10, nil, func(v string) { priority = v })
-			form.AddInputField("Run after (comma separated)", runAfter, 50, nil, func(v string) { runAfter = v })
-			form.AddTextArea("SQL", sql, 60, 8, 0, func(v string) { sql = v })
-			form.AddTextArea("Rollback SQL", rollback, 60, 4, 0, func(v string) { rollback = v })
-			return func(loc objectLocation) error {
-				prio, err := strconv.Atoi(strings.TrimSpace(priority))
-				if err != nil {
-					return fmt.Errorf("priority must be an integer")
-				}
-				next := *script
-				next.Name, next.Description, next.Version, next.Priority = name, desc, version, prio
-				next.RunAfter, next.SQL, next.Rollback = splitList(runAfter), sql, rollback
-				return se.SaveScript(loc.schemaIndex, at, &next)
-			}
-		},
-		remove: func(r objectRow) bool { return se.DeleteScript(r.schemaIndex, r.at) },
-	}
-}
-
-func sortedKeys[V any](m map[string]V) []string {
-	keys := make([]string, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// showObjectList displays all objects of a kind across schemas.
-func (se *SchemaEditor) showObjectList(k objectKind) {
-	flex := tview.NewFlex().SetDirection(tview.FlexRow)
-	title := tview.NewTextView().SetText("[::b]" + k.title).SetDynamicColors(true).SetTextAlign(tview.AlignCenter)
-
-	table := tview.NewTable().SetBorders(true).SetSelectable(true, false).SetFixed(1, 0)
-	for i, h := range k.headers {
-		table.SetCell(0, i, tview.NewTableCell(h).SetTextColor(tcell.ColorYellow).SetSelectable(false).SetAlign(tview.AlignLeft))
-	}
-	rows := k.rows()
-	for r, row := range rows {
-		for c, text := range row.cells {
-			table.SetCell(r+1, c, tview.NewTableCell(text).SetSelectable(true))
-		}
-	}
-	table.SetTitle(" " + k.title[len("Manage "):] + " ").SetBorder(true).SetTitleAlign(tview.AlignLeft)
-
-	back := func() {
-		se.pages.SwitchToPage("main")
-		se.pages.RemovePage(k.page)
-	}
-	btnNew := tview.NewButton("New " + k.singular + " [n]").SetSelectedFunc(func() { se.showObjectForm(k, nil) })
-	btnBack := tview.NewButton("Back [b]").SetSelectedFunc(back)
-	btnNew.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		switch event.Key() {
-		case tcell.KeyBacktab:
-			se.app.SetFocus(table)
-			return nil
-		case tcell.KeyTab:
-			se.app.SetFocus(btnBack)
-			return nil
-		}
-		return event
-	})
-	btnBack.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		switch event.Key() {
-		case tcell.KeyBacktab:
-			se.app.SetFocus(btnNew)
-			return nil
-		case tcell.KeyTab:
-			se.app.SetFocus(table)
-			return nil
-		}
-		return event
-	})
-	btnFlex := tview.NewFlex().AddItem(btnNew, 0, 1, true).AddItem(btnBack, 0, 1, false)
-
-	table.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		switch {
-		case event.Key() == tcell.KeyEscape, event.Rune() == 'b':
-			back()
-			return nil
-		case event.Key() == tcell.KeyTab:
-			se.app.SetFocus(btnNew)
-			return nil
-		case event.Key() == tcell.KeyEnter:
-			if row, _ := table.GetSelection(); row > 0 && row <= len(rows) {
-				se.showObjectForm(k, &rows[row-1])
-				return nil
-			}
-		case event.Rune() == 'n':
-			se.showObjectForm(k, nil)
-			return nil
-		}
-		return event
-	})
-
-	flex.AddItem(title, 1, 0, false).AddItem(table, 0, 1, true).AddItem(btnFlex, 1, 0, false)
-	se.pages.AddPage(k.page, flex, true, true)
-}
-
-// showObjectForm shows the create (row == nil) or edit form for an object.
-func (se *SchemaEditor) showObjectForm(k objectKind, row *objectRow) {
-	formPage := k.page + "-form"
-	form := tview.NewForm()
-	errView := tview.NewTextView().SetDynamicColors(true)
-
-	locs := k.locations()
-	loc := objectLocation{schemaIndex: -1, tableIndex: -1}
-	switch {
-	case row != nil:
-		loc = objectLocation{schemaIndex: row.schemaIndex, tableIndex: row.tableIndex}
-	case len(locs) > 0:
-		loc = locs[0]
-		labels := make([]string, len(locs))
-		for i, l := range locs {
-			labels[i] = l.label
-		}
-		form.AddDropDown("Location", labels, 0, func(_ string, i int) { loc = locs[i] })
-	}
-
-	save := k.buildForm(form, row)
-
-	closeForm := func() {
-		se.pages.RemovePage(formPage)
-		se.pages.RemovePage(k.page)
-		se.showObjectList(k)
-	}
-	form.AddButton("Save", func() {
-		if err := save(loc); err != nil {
-			errView.SetText("[red]" + tview.Escape(err.Error()))
-			return
-		}
-		closeForm()
-	})
-	if row != nil {
-		form.AddButton("Delete", func() {
-			modal := tview.NewModal().
-				SetText(fmt.Sprintf("Delete %s '%s'? This action cannot be undone.", strings.ToLower(k.singular), row.cells[0])).
-				AddButtons([]string{"Cancel", "Delete"}).
-				SetDoneFunc(func(_ int, label string) {
-					se.pages.RemovePage(formPage + "-delete")
-					if label == "Delete" {
-						k.remove(*row)
-						closeForm()
-					}
-				})
-			se.pages.AddAndSwitchToPage(formPage+"-delete", modal, true)
-		})
-	}
-	form.AddButton("Back", closeForm)
-
-	verb := "New"
-	if row != nil {
-		verb = "Edit"
-	}
-	form.SetBorder(true).SetTitle(" " + verb + " " + k.singular + " ").SetTitleAlign(tview.AlignLeft)
-	form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		if event.Key() == tcell.KeyEscape {
-			se.showExitConfirmation(formPage, k.page)
-			return nil
-		}
-		return event
-	})
-
-	if len(locs) == 0 && row == nil {
-		errView.SetText("[red]No schema/table available. Create one first.")
-	}
-	flex := tview.NewFlex().SetDirection(tview.FlexRow).AddItem(form, 0, 1, true).AddItem(errView, 1, 0, false)
-	se.pages.AddPage(formPage, flex, true, true)
-}
-
-// showDomainTables lists the tables assigned to a domain and allows assigning/unassigning.
-func (se *SchemaEditor) showDomainTables(domainIndex int) {
-	if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
-		return
-	}
-	domain := se.db.Domains[domainIndex]
-	page := "domain-tables"
-	list := tview.NewList().ShowSecondaryText(true)
-	refresh := func() {
-		se.pages.RemovePage(page)
-		se.showDomainTables(domainIndex)
-	}
-
-	for _, dt := range domain.Tables {
-		dt := dt
-		list.AddItem(dt.SchemaName+"."+dt.TableName, "Enter to remove from domain", 0, func() {
-			se.UnassignTableFromDomain(domainIndex, dt.SchemaName, dt.TableName)
-			refresh()
-		})
-	}
-	list.AddItem("[Assign Table]", "Add a table to this domain", 'a', func() {
-		se.showAssignDomainTable(domainIndex, refresh)
-	})
-	list.AddItem("[Back]", "Return to domain", 'b', func() {
-		se.pages.RemovePage(page)
-	})
-	list.SetBorder(true).SetTitle(" Domain " + domain.Name + " - Tables ").SetTitleAlign(tview.AlignLeft)
-	list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		if event.Key() == tcell.KeyEscape {
-			se.pages.RemovePage(page)
-			return nil
-		}
-		return event
-	})
-	se.pages.AddPage(page, list, true, true)
-}
-
-// showAssignDomainTable shows a form to pick a table not yet in the domain.
-func (se *SchemaEditor) showAssignDomainTable(domainIndex int, done func()) {
-	page := "assign-domain-table"
-	domain := se.db.Domains[domainIndex]
-	var options []string
-	var refs []models.DomainTable
-	for _, s := range se.db.Schemas {
-		for _, t := range s.Tables {
-			taken := false
-			for _, dt := range domain.Tables {
-				taken = taken || (dt.SchemaName == s.Name && dt.TableName == t.Name)
-			}
-			if !taken {
-				options = append(options, s.Name+"."+t.Name)
-				refs = append(refs, models.DomainTable{SchemaName: s.Name, TableName: t.Name})
-			}
-		}
-	}
-	form := tview.NewForm()
-	selected := 0
-	form.AddDropDown("Table", options, 0, func(_ string, i int) { selected = i })
-	form.AddButton("Assign", func() {
-		if len(refs) > 0 {
-			_ = se.AssignTableToDomain(domainIndex, refs[selected].SchemaName, refs[selected].TableName)
-		}
-		se.pages.RemovePage(page)
-		done()
-	})
-	form.AddButton("Back", func() { se.pages.RemovePage(page) })
-	form.SetBorder(true).SetTitle(" Assign Table ").SetTitleAlign(tview.AlignLeft)
-	form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		if event.Key() == tcell.KeyEscape {
-			se.pages.RemovePage(page)
-			return nil
-		}
-		return event
-	})
-	se.pages.AddPage(page, form, true, true)
-}