feat(ui): manage indexes, views, sequences, scripts and domain tables in TUI

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

README.md

@@ -23,8 +23,6 @@ go install -v git.warky.dev/wdevs/relspecgo/cmd/relspec@latest
 | **Readers** | `bun` `dbml` `dctx` `drawdb` `drizzle` `gorm` `graphql` `json` `mssql` `pgsql` `prisma` `sqldir` `sqlite` `typeorm` `yaml` |
 | **Writers** | `bun` `dbml` `dctx` `drawdb` `drizzle` `gorm` `graphql` `json` `mssql` `pgsql` `prisma` `sqlexec` `sqlite` `template` `typeorm` `yaml` |
 
-See [docs/FORMAT_EXAMPLES.md](docs/FORMAT_EXAMPLES.md) for usage examples covering every format.
-
 ## Commands
 
 ### `convert` — Schema conversion
@@ -218,23 +216,6 @@ see [`bun`'s `--array-nullable`](./pkg/writers/bun/README.md#nullablearrays)
 flag for nullable-array handling. The `SqlXxxArray` wrapper types remain
 available in `pkg/sqltypes` and are still used by the `gorm` writer.
 
-#### Custom type mapping
-
-Override the built-in SQL → Go mapping of the `bun` and `gorm` writers with the
-repeatable `--type-map sqltype=gotype` flag:
-
-```bash
-relspec convert --from pgsql --from-conn "$DSN" --to gorm --to-path models.go \
-  --type-map uuid=string --type-map jsonb=json.RawMessage
-```
-
-SQL type names are matched case-insensitively on the base type (modifiers such
-as `(10,2)` are ignored; aliases like `int4` resolve to `integer`). NOT NULL
-columns use the Go type verbatim, nullable columns get a `*` prefix (unless the
-type is already a pointer, slice, map or `any`), and arrays become `[]gotype`.
-Unmapped types keep their defaults. The flag does not add imports: use types
-that need none, or add the import afterwards (e.g. with `goimports`).
-
 ## Contributing
 
 1. Register or sign in with GitHub at [git.warky.dev](https://git.warky.dev)

cmd/relspec/convert.go

@@ -3,7 +3,6 @@ package main
 import (
 	stdjson "encoding/json"
 	"fmt"
-	"io"
 	"os"
 	"strings"
 	"time"
@@ -58,7 +57,6 @@ var (
 	convertNullableArrays  string
 	convertContinueOnError bool
 	convertExtraFields     string
-	convertDryRun          bool
 )
 
 var convertCmd = &cobra.Command{
@@ -187,8 +185,6 @@ 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)
@@ -244,22 +240,6 @@ 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)
@@ -428,12 +408,23 @@ func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaF
 
 	writerOpts := newWriterOptions(outputPath, packageName, flattenSchema, nullableTypes, nullableArrays, continueOnError)
 	if extraFields != "" {
-		extraFieldsJSON, err := loadExtraFields(dbType, extraFields)
+		if !strings.EqualFold(dbType, "bun") {
+			return fmt.Errorf("--extra-fields is only supported for Bun output")
+		}
+		extraFieldsJSON, err := os.ReadFile(extraFields)
 		if err != nil {
-			return err
+			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")
 		}
 		writerOpts.Metadata = map[string]interface{}{
-			"extra_fields": extraFieldsJSON,
+			"extra_fields": string(extraFieldsJSON),
 		}
 	}
 
@@ -538,95 +529,6 @@ 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

@@ -1,158 +0,0 @@
-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,7 +61,6 @@ 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{
@@ -131,7 +130,6 @@ 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)")
 }
 
@@ -266,29 +264,6 @@ 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)
@@ -310,16 +285,6 @@ 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/prisma_options.go

@@ -27,7 +27,6 @@ func newWriterOptions(outputPath, packageName string, flattenSchema bool, nullab
 		FlattenSchema:    flattenSchema,
 		NullableTypes:    nullableTypes,
 		NullableArrays:   nullableArrays,
-		TypeMappings:     typeMappings,
 		Prisma7:          prisma7,
 		ContinueOnError:  continueOnError,
 		StrictDirectives: strictDirectives,

cmd/relspec/root.go

@@ -6,7 +6,6 @@ import (
 	"github.com/spf13/cobra"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
-	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
 // version/buildDate mirror pkg/buildinfo so existing call sites keep working.
@@ -18,8 +17,6 @@ var (
 	noVersion        bool
 	silent           bool
 	strictDirectives bool
-	typeMapFlags     []string
-	typeMappings     map[string]string
 )
 
 var rootCmd = &cobra.Command{
@@ -31,11 +28,6 @@ bidirectional conversion between various database schema formats.
 It reads database schemas from multiple sources (live databases, DBML,
 DCTX, DrawDB, etc.) and writes them to various formats (GORM, Bun,
 JSON, YAML, SQL, etc.).`,
-	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-		var err error
-		typeMappings, err = writers.ParseTypeMappings(typeMapFlags)
-		return err
-	},
 }
 
 func init() {
@@ -52,7 +44,6 @@ func init() {
 	rootCmd.AddCommand(versionCmd)
 	rootCmd.AddCommand(reportCmd)
 	rootCmd.PersistentFlags().BoolVar(&prisma7, "prisma7", false, "Use Prisma 7 generator conventions when reading/writing Prisma schemas")
-	rootCmd.PersistentFlags().StringArrayVar(&typeMapFlags, "type-map", nil, "Override a SQL-to-Go type mapping for bun/gorm output as sqltype=gotype (repeatable), e.g. --type-map uuid=uuid.UUID --type-map numeric=decimal.Decimal")
 	rootCmd.PersistentFlags().BoolVar(&noVersion, "no-version", false, "Suppress the RelSpec version header")
 	rootCmd.PersistentFlags().BoolVar(&silent, "silent", false, "Suppress progress and status messages (errors are still shown)")
 	rootCmd.PersistentFlags().BoolVar(&strictDirectives, "strict-directives", false, "Fail on unknown or untranslatable DBML dialect directives (@postgres:, @sqlite:, …)")

cmd/relspec/split.go

@@ -24,7 +24,6 @@ var (
 	splitExcludeTables  string
 	splitNullableTypes  string
 	splitNullableArrays string
-	splitDryRun         bool
 )
 
 var splitCmd = &cobra.Command{
@@ -116,8 +115,6 @@ 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)
@@ -177,26 +174,6 @@ 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)

docs/FORMAT_EXAMPLES.md

@@ -1,103 +0,0 @@
-# Format Usage Examples
-
-Examples for `relspec convert` covering the file-based reader and writer
-formats. The "Writers" and "Readers" sections below were run against
-`examples/test_schema.dbml`. The cross-format and live-database examples were
-not run; they follow the flags shown in `relspec convert --help` and require
-matching input files or reachable databases.
-
-Any reader can be combined with any writer: pick `--from`/`--from-path` for the
-source and `--to`/`--to-path` for the target. Add `--silent` to suppress progress
-output.
-
-## Writers: DBML to every format
-
-```bash
-S="--from dbml --from-path examples/test_schema.dbml"
-
-relspec convert $S --to json    --to-path schema.json
-relspec convert $S --to yaml    --to-path schema.yaml
-relspec convert $S --to dctx    --to-path schema.dctx
-relspec convert $S --to drawdb  --to-path schema.drawdb.json
-relspec convert $S --to graphql --to-path schema.graphql
-relspec convert $S --to prisma  --to-path schema.prisma
-relspec convert $S --to pgsql   --to-path schema.pg.sql
-relspec convert $S --to mssql   --to-path schema.mssql.sql
-relspec convert $S --to sqlite  --to-path schema.sqlite.sql
-relspec convert $S --to drizzle --to-path schema.ts
-relspec convert $S --to typeorm --to-path entities.ts
-relspec convert $S --to gorm    --to-path models.go --package models
-relspec convert $S --to bun     --to-path models.go --package models
-```
-
-Notes:
-
-- Code-generation writers (`gorm`, `bun`) take `--package`. They also accept
-  `--types baselib|stdlib|sqltypes` to choose the nullable type package.
-- When `--to-path` is a directory it must already exist.
-- `sqlite` output automatically flattens `schema.table` names. Use
-  `--flatten-schema` for other formats if the target has no schema support.
-- `dctx` supports a single schema only; use `--schema <name>` to select one.
-
-## Readers: file-based formats into DBML (or JSON where noted)
-
-```bash
-relspec convert --from json     --from-path schema.json         --to dbml --to-path out.dbml
-relspec convert --from yaml     --from-path schema.yaml         --to dbml --to-path out.dbml
-relspec convert --from dctx     --from-path schema.dctx         --to dbml --to-path out.dbml
-relspec convert --from drawdb   --from-path schema.drawdb.json  --to dbml --to-path out.dbml
-relspec convert --from graphql  --from-path schema.graphql      --to dbml --to-path out.dbml
-relspec convert --from prisma   --from-path schema.prisma       --to dbml --to-path out.dbml
-relspec convert --from drizzle  --from-path schema.ts           --to dbml --to-path out.dbml
-relspec convert --from typeorm  --from-path entities.ts         --to dbml --to-path out.dbml
-relspec convert --from bun      --from-path models.go           --to dbml --to-path out.dbml
-relspec convert --from gorm     --from-path models.go           --to json --to-path out.json
-```
-
-Code-first readers (`gorm`, `bun`, `drizzle`, `typeorm`) accept a single file or a
-directory of model files.
-
-> Known issue: reading GORM models and writing DBML currently panics in the DBML
-> writer (`pkg/writers/dbml/writer.go`, `constraintToDBML`). Use another target
-> such as JSON until this is fixed.
-
-## Cross-format combinations
-
-```bash
-# ORM models to SQL DDL
-relspec convert --from gorm --from-path models.go --to pgsql --to-path schema.sql
-
-# Prisma to Drizzle
-relspec convert --from prisma --from-path schema.prisma --to drizzle --to-path schema.ts
-
-# DrawDB diagram to GraphQL
-relspec convert --from drawdb --from-path diagram.json --to graphql --to-path schema.graphql
-
-# Merge several files while converting
-relspec convert --from json --from-list "a.json,b.json" --to yaml --to-path merged.yaml
-```
-
-## Live databases
-
-These need a reachable database:
-
-```bash
-# PostgreSQL
-relspec convert --from pgsql --from-conn "postgres://user:pass@localhost:5432/mydb" \
-                --to dbml --to-path schema.dbml
-
-# SQL Server
-relspec convert --from mssql --from-conn "<mssql connection string>" \
-                --to json --to-path schema.json
-
-# SQLite database file (--from-conn takes the file path)
-relspec convert --from sqlite --from-conn ./app.db --to dbml --to-path schema.dbml
-```
-
-## Formats outside `convert`
-
-- `sqldir` (SQL script directory reader) and `sqlexec` (SQL execution writer) are
-  used by `relspec scripts` and `relspec job`, and `sqldir` by `relspec diff`.
-  See [SCRIPTS_COMMAND.md](SCRIPTS_COMMAND.md) and [JOB_FILES.md](JOB_FILES.md).
-- The `template` writer is exposed through `relspec templ`. See
-  [TEMPLATE_MODE.md](TEMPLATE_MODE.md).

pkg/writers/bun/type_mapper.go

@@ -12,7 +12,6 @@ import (
 // TypeMapper handles type conversions between SQL and Go types for Bun
 type TypeMapper struct {
 	sqlTypesAlias string
-	typeMappings  map[string]string
 	typeStyle     string // writers.NullableTypeSqlTypes | writers.NullableTypeStdlib | writers.NullableTypeBaselib
 	arrayNullable string // writers.NullableArraysSlice | writers.NullableArraysPointerSlice
 }
@@ -38,10 +37,6 @@ func NewTypeMapper(typeStyle, arrayNullable string) *TypeMapper {
 
 // SQLTypeToGoType converts a SQL type to its Go equivalent.
 func (tm *TypeMapper) SQLTypeToGoType(sqlType string, notNull bool) string {
-	if goType, ok := tm.overrideGoType(sqlType, notNull); ok {
-		return goType
-	}
-
 	// Array columns always use a native Go slice, regardless of typeStyle.
 	if pgsql.IsArrayType(sqlType) {
 		goType := tm.arrayGoType(tm.extractBaseType(sqlType))
@@ -73,26 +68,6 @@ func (tm *TypeMapper) SQLTypeToGoType(sqlType string, notNull bool) string {
 	return tm.bunGoType(baseType)
 }
 
-// SetTypeMappings installs user-configured SQL-to-Go type overrides.
-func (tm *TypeMapper) SetTypeMappings(mappings map[string]string) {
-	tm.typeMappings = mappings
-}
-
-// overrideGoType applies a configured override, if any, for the column type.
-func (tm *TypeMapper) overrideGoType(sqlType string, notNull bool) (string, bool) {
-	if len(tm.typeMappings) == 0 {
-		return "", false
-	}
-	goType, ok := writers.LookupTypeMapping(tm.typeMappings, tm.extractBaseType(sqlType))
-	if !ok {
-		return "", false
-	}
-	if pgsql.IsArrayType(sqlType) {
-		return "[]" + goType, true
-	}
-	return writers.ApplyTypeMapping(goType, notNull), true
-}
-
 // extractBaseType extracts the base type from a SQL type string
 func (tm *TypeMapper) extractBaseType(sqlType string) string {
 	return pgsql.CanonicalizeBaseType(pgsql.ExtractBaseTypeLower(sqlType))

pkg/writers/bun/type_mapper_override_test.go

@@ -1,25 +0,0 @@
-package bun
-
-import "testing"
-
-func TestTypeMapper_CustomTypeMappings(t *testing.T) {
-	mapper := NewTypeMapper("", "")
-	mapper.SetTypeMappings(map[string]string{"uuid": "uuid.UUID", "numeric": "decimal.Decimal"})
-
-	tests := []struct {
-		sqlType string
-		notNull bool
-		want    string
-	}{
-		{"uuid", true, "uuid.UUID"},
-		{"uuid", false, "*uuid.UUID"},
-		{"numeric(10,2)", true, "decimal.Decimal"},
-		{"UUID[]", false, "[]uuid.UUID"},
-		{"bigint", true, "int64"}, // unmapped types keep defaults
-	}
-	for _, tt := range tests {
-		if got := mapper.SQLTypeToGoType(tt.sqlType, tt.notNull); got != tt.want {
-			t.Errorf("SQLTypeToGoType(%q, %v) = %q, want %q", tt.sqlType, tt.notNull, got, tt.want)
-		}
-	}
-}

pkg/writers/bun/writer.go

@@ -28,8 +28,6 @@ func NewWriter(options *writers.WriterOptions) *Writer {
 		config:     LoadMethodConfigFromMetadata(options.Metadata),
 	}
 
-	w.typeMapper.SetTypeMappings(options.TypeMappings)
-
 	// Initialize templates
 	tmpl, err := NewTemplates()
 	if err != nil {

pkg/writers/gorm/type_mapper.go

@@ -12,7 +12,6 @@ import (
 // TypeMapper handles type conversions between SQL and Go types
 type TypeMapper struct {
 	sqlTypesAlias string
-	typeMappings  map[string]string
 	typeStyle     string // writers.NullableTypeSqlTypes | writers.NullableTypeStdlib | writers.NullableTypeBaselib
 }
 
@@ -31,10 +30,6 @@ func NewTypeMapper(typeStyle string) *TypeMapper {
 
 // SQLTypeToGoType converts a SQL type to its Go equivalent.
 func (tm *TypeMapper) SQLTypeToGoType(sqlType string, notNull bool) string {
-	if goType, ok := tm.overrideGoType(sqlType, notNull); ok {
-		return goType
-	}
-
 	// Array types are handled separately for both styles.
 	if pgsql.IsArrayType(sqlType) {
 		return tm.arrayGoType(tm.extractBaseType(sqlType))
@@ -62,26 +57,6 @@ func (tm *TypeMapper) SQLTypeToGoType(sqlType string, notNull bool) string {
 	return tm.nullableGoType(baseType)
 }
 
-// SetTypeMappings installs user-configured SQL-to-Go type overrides.
-func (tm *TypeMapper) SetTypeMappings(mappings map[string]string) {
-	tm.typeMappings = mappings
-}
-
-// overrideGoType applies a configured override, if any, for the column type.
-func (tm *TypeMapper) overrideGoType(sqlType string, notNull bool) (string, bool) {
-	if len(tm.typeMappings) == 0 {
-		return "", false
-	}
-	goType, ok := writers.LookupTypeMapping(tm.typeMappings, tm.extractBaseType(sqlType))
-	if !ok {
-		return "", false
-	}
-	if pgsql.IsArrayType(sqlType) {
-		return "[]" + goType, true
-	}
-	return writers.ApplyTypeMapping(goType, notNull), true
-}
-
 // extractBaseType extracts the base type from a SQL type string
 // Examples: varchar(100) → varchar, numeric(10,2) → numeric
 func (tm *TypeMapper) extractBaseType(sqlType string) string {

pkg/writers/gorm/type_mapper_override_test.go

@@ -1,25 +0,0 @@
-package gorm
-
-import "testing"
-
-func TestTypeMapper_CustomTypeMappings(t *testing.T) {
-	mapper := NewTypeMapper("")
-	mapper.SetTypeMappings(map[string]string{"uuid": "uuid.UUID", "numeric": "decimal.Decimal"})
-
-	tests := []struct {
-		sqlType string
-		notNull bool
-		want    string
-	}{
-		{"uuid", true, "uuid.UUID"},
-		{"uuid", false, "*uuid.UUID"},
-		{"numeric(10,2)", true, "decimal.Decimal"},
-		{"UUID[]", false, "[]uuid.UUID"},
-		{"bigint", true, "int64"}, // unmapped types keep defaults
-	}
-	for _, tt := range tests {
-		if got := mapper.SQLTypeToGoType(tt.sqlType, tt.notNull); got != tt.want {
-			t.Errorf("SQLTypeToGoType(%q, %v) = %q, want %q", tt.sqlType, tt.notNull, got, tt.want)
-		}
-	}
-}

pkg/writers/gorm/writer.go

@@ -28,8 +28,6 @@ func NewWriter(options *writers.WriterOptions) *Writer {
 		config:     LoadMethodConfigFromMetadata(options.Metadata),
 	}
 
-	w.typeMapper.SetTypeMappings(options.TypeMappings)
-
 	// Initialize templates
 	tmpl, err := NewTemplates()
 	if err != nil {

pkg/writers/typemap.go

@@ -1,46 +0,0 @@
-package writers
-
-import (
-	"fmt"
-	"strings"
-
-	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
-)
-
-// ParseTypeMappings parses "sqltype=gotype" entries (as given to --type-map)
-// into a map keyed by the canonical lower-case SQL base type, so that
-// "VARCHAR", "character varying" and "varchar(50)" all address one entry.
-// It returns nil for empty input.
-func ParseTypeMappings(entries []string) (map[string]string, error) {
-	if len(entries) == 0 {
-		return nil, nil
-	}
-	out := make(map[string]string, len(entries))
-	for _, entry := range entries {
-		sqlType, goType, ok := strings.Cut(entry, "=")
-		sqlType, goType = strings.TrimSpace(sqlType), strings.TrimSpace(goType)
-		if !ok || sqlType == "" || goType == "" {
-			return nil, fmt.Errorf("invalid type mapping %q: expected sqltype=gotype", entry)
-		}
-		out[pgsql.CanonicalizeBaseType(pgsql.ExtractBaseTypeLower(sqlType))] = goType
-	}
-	return out, nil
-}
-
-// LookupTypeMapping returns the user-configured override for baseType, which
-// the caller must already have canonicalized.
-func LookupTypeMapping(mappings map[string]string, baseType string) (string, bool) {
-	goType, ok := mappings[baseType]
-	return goType, ok
-}
-
-// ApplyTypeMapping wraps an overridden Go type for nullability: NOT NULL uses
-// the type verbatim; nullable columns get a pointer prefix unless the type is
-// already a pointer, slice, map or interface.
-func ApplyTypeMapping(goType string, notNull bool) string {
-	if notNull || strings.HasPrefix(goType, "*") || strings.HasPrefix(goType, "[]") ||
-		strings.HasPrefix(goType, "map[") || goType == "any" || goType == "interface{}" {
-		return goType
-	}
-	return "*" + goType
-}

pkg/writers/typemap_test.go

@@ -1,46 +0,0 @@
-package writers
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestParseTypeMappings(t *testing.T) {
-	got, err := ParseTypeMappings([]string{"UUID=uuid.UUID", " varchar(50) = MyString ", "INT4=MyInt"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := map[string]string{"uuid": "uuid.UUID", "varchar": "MyString", "integer": "MyInt"}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("got %v, want %v", got, want)
-	}
-
-	if m, err := ParseTypeMappings(nil); m != nil || err != nil {
-		t.Errorf("empty input: got %v, %v", m, err)
-	}
-	for _, bad := range []string{"uuid", "=string", "uuid="} {
-		if _, err := ParseTypeMappings([]string{bad}); err == nil {
-			t.Errorf("expected error for %q", bad)
-		}
-	}
-}
-
-func TestApplyTypeMapping(t *testing.T) {
-	tests := []struct {
-		goType  string
-		notNull bool
-		want    string
-	}{
-		{"uuid.UUID", true, "uuid.UUID"},
-		{"uuid.UUID", false, "*uuid.UUID"},
-		{"*uuid.UUID", false, "*uuid.UUID"},
-		{"[]byte", false, "[]byte"},
-		{"map[string]any", false, "map[string]any"},
-		{"any", false, "any"},
-	}
-	for _, tt := range tests {
-		if got := ApplyTypeMapping(tt.goType, tt.notNull); got != tt.want {
-			t.Errorf("ApplyTypeMapping(%q, %v) = %q, want %q", tt.goType, tt.notNull, got, tt.want)
-		}
-	}
-}

pkg/writers/writer.go

@@ -83,13 +83,6 @@ type WriterOptions struct {
 	// SqlXxxArray wrapper types.
 	NullableArrays string
 
-	// TypeMappings overrides the SQL-to-Go type mapping of the code-generation
-	// writers (bun, gorm). Keys are SQL base types (aliases are canonicalized,
-	// see ParseTypeMappings), values are Go type expressions. Array columns
-	// use the override for their element type. Unmapped types keep the
-	// built-in defaults.
-	TypeMappings map[string]string
-
 	// Prisma7 enables Prisma 7-specific output for Prisma writers.
 	Prisma7 bool
 

tests/_plans/README.md

@@ -1,50 +0,0 @@
-# Test Coverage Plans
-
-Baseline: 51.0% total statements (2026-10-03, after PRs #41-#43).
-Scope: pgsql, sqlexec, template, plus non-reader/writer packages. Other readers/writers deferred.
-
-## Order
-
-| # | Plan | Package(s) | Now |
-|---|------|-----------|-----|
-| 1 | [pgsql.md](pgsql.md) | readers/pgsql, writers/pgsql, pkg/pgsql | 16.0 / 74.0 / 87.8 |
-| 2 | [sqlexec.md](sqlexec.md) | writers/sqlexec | 19.4 |
-| 3 | [template.md](template.md) | writers/template | 8.5 |
-| 4 | [models.md](models.md) | pkg/models | 20.4 |
-| 5 | [cmd.md](cmd.md) | cmd/relspec, pkg/jobs | 49.3 / 72.0 |
-| 6 | [ui.md](ui.md) | pkg/ui | 3.8 |
-| 7 | [diff-merge.md](diff-merge.md) | pkg/diff, pkg/merge | 65.5 / 75.1 |
-| 8 | [sqltypes.md](sqltypes.md) | pkg/sqltypes | 67.0 |
-
-## Conventions
-
-- Same package as code under test; table-driven; must pass `-race`.
-- Existing data first: `tests/assets/*`, `examples/*.dbml`, `tests/postgres/init.sql`, `tests/postgres/issue21`. Generate new data only where listed under "Data needed".
-- New fixtures go in `tests/assets/<format>/` or package `testdata/`.
-- Live-DB tests: skip unless the env var is set (pattern in `pkg/readers/pgsql/reader_test.go`). Use `tests/dbtest/dbtest.sh` (podman/docker; see `tests/dbtest/README.md`):
-  - `dbtest.sh up|down <postgres|mssql|mysql|all>`
-  - `eval "$(dbtest.sh env postgres)"` sets `RELSPEC_TEST_PG_CONN` (mssql: `RELSPEC_TEST_MSSQL_CONN`, mysql: `RELSPEC_TEST_MYSQL_CONN`)
-  - `dbtest.sh test <db> [pkgs]` runs up, `go test`, down
-- Fixtures for live DBs: postgres `tests/postgres/init.sql`, mssql `test_data/mssql/test_schema.sql`, mysql `tests/dbtest/init/mysql.sql`.
-- Prerequisite: working container networking (currently blocked until reboot into matching kernel; `tun` module).
-- Prefer pure-function tests over DB tests wherever the logic can be isolated.
-- Output assertions must not depend on map order (see memory: map iteration determinism).
-
-## Targets
-
-| Package | Target |
-|---------|--------|
-| pgsql (all three) | >= 85 |
-| sqlexec | >= 80 |
-| template | >= 85 |
-| models | >= 80 |
-| cmd/relspec | >= 65 |
-| jobs | >= 85 |
-| ui | >= 40 (data ops/pure helpers; screens via smoke tests) |
-| diff, merge | >= 85 |
-| sqltypes | >= 85 |
-
-## Verify
-
-- `go test -race -coverprofile=c.out ./pkg/<pkg>/` then `go tool cover -func=c.out`
-- `make test` before commit

tests/_plans/cmd.md

@@ -1,29 +0,0 @@
-# Plan: cmd/relspec (49.3%) and pkg/jobs (72.0%)
-
-## Existing
-- cmd tests: convert_from_list, diff_sqldir, dry_run (#41), job, merge_from_list, templ_from_list
-- jobs: `jobs_test.go`
-
-## cmd/relspec
-
-| Area | Gap | Approach |
-|------|-----|----------|
-| convert | `readDatabaseForConvert` 22%, `writeDatabase` 36%, `validateWriteTarget` 44%, `loadExtraFields`, `getSchemaNames`, `stderrWarn` | Table-driven per format using `tests/assets`; unsupported format, missing package, bad extra-fields JSON/empty/non-bun, schema filter not found, dctx multi-schema |
-| merge | `readDatabaseForMerge` 18%, `writeDatabaseForMerge` 14%, `expandPath`, `parseSkipTables`, `isMergeOutputFormat` | Table-driven formats; globs; skip-list parsing |
-| diff | `runDiff`, `readDatabase`, `maskPasswordInDiff` | File-based inputs; password masking cases |
-| inspect | `runInspect`, `readDatabaseForInspect`, `filterDatabaseBySchema` | File-based input; schema filter |
-| scripts | `runScriptsList` | Use `pkg/readers/sqldir` fixtures; execute path live via dbtest postgres |
-| assets | `runAssetsList`, `runAssetsExecute` | List against temp dir; execute live via dbtest postgres |
-| edit | `runEdit`, `readDatabaseForEdit`, `writeDatabaseForEdit` | Test read/write helpers only; skip TUI loop |
-| report | state dir, load/save state, token, machine id, `submitReport` | Temp HOME; submit against `httptest` server; never hit real endpoint |
-| root/main | `printVersionHeader`, `hasSilentFlag` | Pure |
-| dry-run | merge/split paths | Add merge dry-run and split dry-run tests (convert covered) |
-
-## pkg/jobs
-- `ResolvedLogPolicy`, `Dir`, `validateTemplInput` (0%), `validateOutput` (44%): table-driven valid/invalid job definitions.
-- Existing job files: `examples/jobs`.
-
-## Live DB cases (dbtest)
-- `runScriptsExecute`, `runAssetsExecute`, job script-exec, `readDatabaseForConvert/Merge/Inspect` for pgsql, and pgsql merge/convert output: `tests/dbtest/dbtest.sh test postgres ./cmd/relspec/`.
-- mssql source reads (convert/inspect): `dbtest.sh up mssql`, env `RELSPEC_TEST_MSSQL_CONN`; fixture `test_data/mssql/test_schema.sql`.
-- Skip when env var unset.

tests/_plans/diff-merge.md

@@ -1,29 +0,0 @@
-# Plan: pkg/diff (65.5%) and pkg/merge (75.1%)
-
-## Existing
-- diff: `diff_test.go`, `formatters_test.go`
-- merge: `merge_test.go`
-
-## pkg/diff
-
-| Func | Now | Cases |
-|------|-----|-------|
-| `compareSchemaDetails` | 0% | Description/owner/options changed |
-| `compareConstraintDetails`, `normalizeConstraintAction` | 0% | Columns, referenced table, on-update/on-delete variants and case/default normalisation |
-| `compareRelationshipDetails` | 0% | Changed endpoints/type |
-| `compareViews`, `compareViewDetails` | 0% | Added/removed/changed definition |
-| `compareSequences`, `compareSequenceDetails` | 0% | Added/removed/changed increment/min/max/start |
-
-Data: pair `examples/test_schema.dbml` and `test_schema_modified.dbml`; add view/sequence changes in code-built fixtures.
-
-## pkg/merge
-
-| Func | Now | Cases |
-|------|-----|-------|
-| `mergeSequences`, `cloneSequence` | 33% / 0% | New, existing, conflicting; clone is deep |
-| `cloneSchema` | 48% | Views, sequences, scripts, indexes cloned independently |
-| `extractTypeParts` | 48% | Precision/scale, arrays, schema-qualified, no modifiers |
-| `GetColumnTypeConflictSummary`, `min` | 0% | Limit truncation, zero conflicts |
-
-## Live DB cases (dbtest)
-- pgsql live diff/merge against a real DB: `dbtest.sh test postgres`; reuse `tests/postgres/init.sql` as the live side and `examples/test_schema*.dbml` as the desired side.

tests/_plans/models.md

@@ -1,18 +0,0 @@
-# Plan: pkg/models (20.4%)
-
-## Existing
-- `directives_test.go`
-
-## Gaps
-
-| File | Funcs | Cases |
-|------|-------|-------|
-| `models.go` | All `SQLName` methods, `UpdateDate`, `GetPrimaryKey`, `columnLess`, `GetForeignKeys` | Case handling, empty/nil maps, composite PK ordering, FK filtering |
-| `models.go` | `Init*` constructors (Database, Schema, Table, Column, Index, Relation, Relationship, Constraint, Script, View, Sequence, Domain, DomainTable, Enum) | Maps/slices non-nil, name set, defaults |
-| `sorting.go` | 20 Sort* funcs | By name and by sequence; ties; map variants return sorted slice; input not mutated where documented |
-| `flatview.go` | ToFlatColumns, ToFlatTables, ToFlatConstraints, ToFlatRelationships | Multi-schema, empty db, deterministic order |
-| `summaryview.go` | ToSummary | Counts across object types |
-| `directives.go` | `directiveFromAny` (22%) | Each input type branch, invalid type |
-
-## Data needed
-- One shared in-test builder for a multi-schema Database (reuse `tests/assets/dbml/complex.dbml` via reader only if no import cycle; otherwise build in code).

tests/_plans/pgsql.md

@@ -1,38 +0,0 @@
-# Plan: PostgreSQL
-
-## Tooling
-- Live tests: `tests/dbtest/dbtest.sh test postgres` (defaults to readers/pgsql, writers/pgsql, writers/sqlexec) or `up postgres` + `eval "$(tests/dbtest/dbtest.sh env postgres)"`.
-- Isolation: each live test creates and drops its own schema; shared fixture DB comes from `init.sql`.
-
-## Existing
-- Reader tests: `pkg/readers/pgsql/reader_test.go` (live tests skipped without `RELSPEC_TEST_PG_CONN`; pure tests: MapDataType, ParseIndexDefinition, DeriveRelationship, composite FK)
-- Writer tests: diff_statements, directives, extensions, generated_column, migration_writer, serial_sequence
-- Data: `tests/postgres/init.sql`, `tests/postgres/issue21`, `tests/assets/dbml/*`, `examples/test_schema*.dbml`
-
-## readers/pgsql (16.0%)
-
-| Item | Gap | Approach |
-|------|-----|----------|
-| `normalizePostgresDefault` (queries.go) | 0% | Pure; table-driven: casts, nextval, functions, quoted literals, NULL |
-| `countColumns/Constraints/Indexes` | 0% | Pure; build Database fixtures |
-| `ReadDatabase/ReadSchema/ReadTable` | ~0% | Live; run against `init.sql` DB; assert counts, PK/FK/unique/check/index, views, sequences, extensions |
-| `query*` (11 funcs) | 0% | Covered via live ReadDatabase; add one live case per object type |
-| `close` | 0% | Live; connection released after read and on error |
-
-Data needed: extend `tests/postgres/init.sql` (loaded by dbtest on `up`; apply changes with `dbtest.sh restart postgres`) with a view, sequence, check constraint, partial index, extension, composite FK (verify what already exists first).
-
-## writers/pgsql (74.0%)
-
-| Item | Gap | Approach |
-|------|-----|----------|
-| `extractTableNameFromCreate`, `extractStatementContext`, `extractSQLStringValue`, `parseQualifiedIdent`, `firstBareIdent`, `firstIdentAfterKeyword`, `stripQuotes`, `buildStmtContext`, `detectStatementType`, `truncateStatement` | 0% | Pure; table-driven; quoted/qualified/unquoted idents, each statement type, long statements |
-| `getCurrentTimestamp`, `finishReport`, `writeReport` | 0% | Report written to temp file; JSON shape, counts, failed statements |
-| `executeStatements`, `executeDatabaseSQL` | 0% | Live; success, failure with continue-on-error, failure stop, report output |
-| `generateLiveDiffStatements` | 28.6% | Live; empty DB, drifted DB, identical DB |
-| `currentColumnHasDescription`, `ExecuteCommentColumn` | 0% | Migration writer fixtures with comments added/removed/changed |
-| `template_functions.go` `filter`, `mapFunc` | 0% | Pure |
-
-Reuse `tests/integration/failed_statements_example.txt` for failed-statement report cases. Ad-hoc SQL setup: `dbtest.sh exec postgres <file>`.
-
-## pkg/pgsql (87.8%)
-- Spot-check uncovered funcs after the above; add keyword/datatype edge cases only.

tests/_plans/sqlexec.md

@@ -1,20 +0,0 @@
-# Plan: writers/sqlexec (19.4%)
-
-## Existing
-- `writer_test.go`: constructor, nil DB, missing conn string, empty scripts, script sorting, embed directives
-
-## Gaps
-
-| Item | Now | Approach |
-|------|-----|----------|
-| `Options` | 0% | Trivial getter |
-| `WriteDatabase` | 31.2% | Multi-schema; error from one schema aborts; context/connect failure |
-| `executeScripts` | 0% | Live via dbtest postgres (`RELSPEC_TEST_PG_CONN`); ordering by priority/sequence, failing script reports script name, empty SQL skipped, transaction/partial-apply behaviour as implemented |
-| `WriteSchema` | partial | Connection error path, success path live |
-
-## Data needed
-- Small script set (3-4 scripts, mixed priority, one failing) as fixtures; check `tests/assets` and `pkg/readers/sqldir` testdata first.
-- Cleanup: each live test uses a throwaway schema and drops it.
-
-## Decision
-- Live-only via `tests/dbtest/dbtest.sh test postgres ./pkg/writers/sqlexec/`; no connection interface or mock.

tests/_plans/sqltypes.md

@@ -1,14 +0,0 @@
-# Plan: pkg/sqltypes (67.0%)
-
-## Existing
-- array types, fromstring, sql types, yaml/xml, struct json, uuid integration tests
-
-## Gaps
-
-| Area | Funcs | Approach |
-|------|-------|----------|
-| Array types | MarshalYAML/UnmarshalYAML/MarshalXML/UnmarshalXML across each array type; some `UnmarshalJSON/MarshalJSON` | One round-trip test per array type (reuse helper from `sql_types_yaml_xml_test.go`) |
-| Scalar types | `Value` (3 types), `MarshalJSON/UnmarshalJSON` for date, `Int64` (31%), `Float64` (40%) | Valid, null, invalid string, overflow |
-| Constructors | `SqlTimeStampNow`, `SqlDateNow`, `SqlTimeNow`, `NewSql`, `NewSqlFloat32`, `ToJSONDT` | Assert non-zero/valid and approximately now |
-
-No data needed.

tests/_plans/template.md

@@ -1,23 +0,0 @@
-# Plan: writers/template (8.5%)
-
-## Existing
-- `writer_test.go`: deterministic table index values only
-
-## Approach
-Pure helper functions; one test file per source file, table-driven. Then render tests through the writer.
-
-| File | Funcs | Cases |
-|------|-------|-------|
-| `filters.go` | FilterTables, FilterTablesByPattern, FilterColumns, FilterColumnsByType, FilterPrimaryKeys, FilterForeignKeys, FilterUniqueConstraints, FilterCheckConstraints, FilterNullable, FilterNotNull, matchPattern | Empty input, no match, glob patterns, nil maps |
-| `formatters.go` | ToJSON, ToJSONPretty, ToYAML, Indent, IndentWith, Escape, EscapeQuotes, Comment, QuoteString, UnquoteString | Empty string, multiline, special chars, marshal failure |
-| `loop_helpers.go` | Enumerate, Batch, Chunk, Reverse, First, Last, Skip, Take, Concat, Unique, SortBy, GroupBy, CountIf, getFieldValue, compareValues | Empty, n > len, n <= 0, non-slice input, missing field |
-| `safe_access.go` | Get, GetOr, GetPath, GetPathOr, SafeIndex, SafeIndexOr, Has, HasPath, Keys, Merge, Pick, Omit, SliceContains, IndexOf, Pluck | nil, missing key, nested path, out-of-range |
-| `string_helpers.go` | ToUpper, ToLower, ToCamelCase, and rest | Empty, snake/kebab/space input, unicode |
-| `errors.go` | Error, Unwrap, NewTemplate{Load,Parse,Execute}Error | errors.Is/As, message contents |
-| `funcmap.go` | BuildFuncMap | Every registered name resolves and is callable |
-| `type_mappers.go`, `template_data.go` | check after above | |
-| `writer.go` | WriteDatabase/Schema/Table, modes | Template load/parse/execute error paths; per-table, per-schema, whole-db modes; output to file vs stdout |
-
-## Data needed
-- 2-3 small template fixtures in `pkg/writers/template/testdata/` (valid, parse error, execute error).
-- Schema input: reuse `tests/assets/dbml/simple.dbml` / `complex.dbml`.

tests/_plans/ui.md

@@ -1,27 +0,0 @@
-# Plan: pkg/ui (3.8%)
-
-## Existing
-- `object_dataops_test.go` (indexes, views, sequences, scripts, domain assignment)
-- Rules: `pkg/ui/ui_rules.md`
-
-## Layers
-
-| Layer | Files | Testable? | Approach |
-|-------|-------|-----------|----------|
-| Data ops | column_, relation_, domain_, schema_, table_, database_dataops.go | Yes, pure | CRUD tests per file: create, duplicate, update/rename, delete, not-found, bounds, UpdateDate side effects |
-| Pure helpers | `sortedKeys`, `schemaLocations`, `tableLocations`, `getColumnNames`, `parseSkipTablesUI`, help-text getters | Yes | Table-driven |
-| Kind definitions | `indexKind/viewKind/sequenceKind/scriptKind` | Yes | Assert row builders and form-to-model mapping without rendering |
-| Load/save | `loadDatabase`, `saveDatabase`, `createNewDatabase`, `importAndMergeDatabase`, `performMerge` | Partly | Temp files from `tests/assets`; verify format dispatch and error paths; avoid UI dialogs |
-| Screens | *_screens.go, dialogs.go, main_menu.go | Yes, via simulation | tview app on tcell SimulationScreen; inject key events; assert navigation, form submit mutates model, cancel leaves it unchanged, delete confirm paths |
-
-## Order
-1. Data ops (largest gain, no tview)
-2. Pure helpers and kinds
-3. Load/save logic
-4. Screen tests on simulation screen (menu, lists, forms, confirm dialogs, load/save)
-
-## Decision
-- Screen smoke tests via tview simulation screen are in scope (tcell `SimulationScreen`); drive keys/events, assert no panic and expected state.
-
-## Live DB cases (dbtest)
-- Load/save and import-merge from a live pgsql source: `dbtest.sh up postgres`; skip when `RELSPEC_TEST_PG_CONN` unset.

tests/dbtest/README.md

@@ -1,45 +0,0 @@
-# dbtest: container test databases
-
-Podman (preferred) or Docker. One tool for postgres, mssql, mysql.
-
-## Commands
-
-| Command | Action |
-|---|---|
-| `./tests/dbtest/dbtest.sh up <db\|all>` | Start, wait for ready, run init |
-| `down <db\|all>` | Stop and remove |
-| `restart <db>` | Fresh container |
-| `status <db\|all>` | State and connection string |
-| `env <db\|all>` | Print `export` line for the test env var |
-| `test <db> [pkgs]` | up, `go test`, down |
-| `shell <db>` | Interactive client |
-| `exec <db> <file>` | Run SQL file |
-| `logs <db>` | Container logs |
-
-## Databases
-
-| db | Port | Env var | Init | Default test pkgs |
-|---|---|---|---|---|
-| postgres | 5439 | `RELSPEC_TEST_PG_CONN` | `tests/postgres/init.sql` | readers/pgsql, writers/pgsql, writers/sqlexec |
-| mssql | 1439 | `RELSPEC_TEST_MSSQL_CONN` | `test_data/mssql/test_schema.sql` (creates `RelSpecTest`) | readers/mssql, writers/mssql |
-| mysql | 3309 | `RELSPEC_TEST_MYSQL_CONN` | `tests/dbtest/init/mysql.sql` | none (no Go driver/reader yet) |
-
-## Env
-
-| Var | Effect |
-|---|---|
-| `DBTEST_RUNTIME` | Force `podman` or `docker` |
-| `DBTEST_TIMEOUT` | Ready wait, seconds (default 120) |
-| `DBTEST_KEEP=1` | Keep container after `test` |
-| `DBTEST_GOFLAGS` | Extra `go test` flags |
-
-## Add a database
-
-1. Add `dbs/<name>.sh` defining: `DB_NAME DB_IMAGE DB_CONTAINER DB_PORT DB_INTERNAL_PORT DB_ENV DB_INIT_MOUNT DB_CONN_VAR DB_CONN DB_DEFAULT_PKGS` and functions `db_ready db_post_init db_shell db_exec_file`.
-2. Add the name to `ALL_DBS` in `dbtest.sh`.
-
-## Notes
-
-- Containers are named `relspec-test-<db>`; existing `tests/postgres/*.sh` and `make docker-*` use the same postgres name/port 5439 and remain independent.
-- mssql needs ~2GB RAM and takes longer to become ready.
-- Tests skip when the env var is unset.

tests/dbtest/dbs/mssql.sh

@@ -1,17 +0,0 @@
-# SQL Server container definition (sourced by dbtest.sh)
-DB_NAME=mssql
-DB_IMAGE=mcr.microsoft.com/mssql/server:2022-latest
-DB_CONTAINER=relspec-test-mssql
-DB_PORT=1439
-DB_INTERNAL_PORT=1433
-DB_ENV=(-e ACCEPT_EULA=Y -e "MSSQL_SA_PASSWORD=StrongPassword123!" -e MSSQL_PID=Express)
-DB_INIT_MOUNT="$ROOT/test_data/mssql/test_schema.sql:/init/test_schema.sql"
-DB_CONN_VAR=RELSPEC_TEST_MSSQL_CONN
-DB_CONN="sqlserver://sa:StrongPassword123!@localhost:1439?database=RelSpecTest"
-DB_DEFAULT_PKGS="./pkg/readers/mssql/ ./pkg/writers/mssql/"
-
-_sqlcmd() { rt exec -i "$DB_CONTAINER" /opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P 'StrongPassword123!' "$@"; }
-db_ready()  { _sqlcmd -Q "SELECT 1" >/dev/null 2>&1; }
-db_post_init() { _sqlcmd -b -i /init/test_schema.sql >/dev/null; }
-db_shell()  { rt exec -it "$DB_CONTAINER" /opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P 'StrongPassword123!' -d RelSpecTest "$@"; }
-db_exec_file() { _sqlcmd -b -d RelSpecTest < "$1"; }

tests/dbtest/dbs/mysql.sh

@@ -1,16 +0,0 @@
-# MySQL container definition (sourced by dbtest.sh)
-DB_NAME=mysql
-DB_IMAGE=docker.io/library/mysql:8.4
-DB_CONTAINER=relspec-test-mysql
-DB_PORT=3309
-DB_INTERNAL_PORT=3306
-DB_ENV=(-e MYSQL_ROOT_PASSWORD=relspec_root_password -e MYSQL_DATABASE=relspec_test -e MYSQL_USER=relspec -e MYSQL_PASSWORD=relspec_test_password)
-DB_INIT_MOUNT="$ROOT/tests/dbtest/init/mysql.sql:/docker-entrypoint-initdb.d/init.sql"
-DB_CONN_VAR=RELSPEC_TEST_MYSQL_CONN
-DB_CONN="relspec:relspec_test_password@tcp(localhost:3309)/relspec_test"
-DB_DEFAULT_PKGS=""
-
-db_ready()  { rt exec "$DB_CONTAINER" mysqladmin ping -h 127.0.0.1 -urelspec -prelspec_test_password --silent >/dev/null 2>&1; }
-db_post_init() { :; }
-db_shell()  { rt exec -it "$DB_CONTAINER" mysql -urelspec -prelspec_test_password relspec_test "$@"; }
-db_exec_file() { rt exec -i "$DB_CONTAINER" mysql -urelspec -prelspec_test_password relspec_test < "$1"; }

tests/dbtest/dbs/postgres.sh

@@ -1,16 +0,0 @@
-# Postgres container definition (sourced by dbtest.sh)
-DB_NAME=postgres
-DB_IMAGE=docker.io/library/postgres:16-alpine
-DB_CONTAINER=relspec-test-postgres
-DB_PORT=5439
-DB_INTERNAL_PORT=5432
-DB_ENV=(-e POSTGRES_USER=relspec -e POSTGRES_PASSWORD=relspec_test_password -e POSTGRES_DB=relspec_test)
-DB_INIT_MOUNT="$ROOT/tests/postgres/init.sql:/docker-entrypoint-initdb.d/init.sql"
-DB_CONN_VAR=RELSPEC_TEST_PG_CONN
-DB_CONN="postgres://relspec:relspec_test_password@localhost:5439/relspec_test"
-DB_DEFAULT_PKGS="./pkg/readers/pgsql/ ./pkg/writers/pgsql/ ./pkg/writers/sqlexec/"
-
-db_ready()  { rt exec "$DB_CONTAINER" pg_isready -U relspec -d relspec_test >/dev/null 2>&1; }
-db_post_init() { :; }
-db_shell()  { rt exec -it "$DB_CONTAINER" psql -U relspec -d relspec_test "$@"; }
-db_exec_file() { rt exec -i "$DB_CONTAINER" psql -v ON_ERROR_STOP=1 -U relspec -d relspec_test < "$1"; }

tests/dbtest/dbtest.sh

@@ -1,130 +0,0 @@
-#!/usr/bin/env bash
-# Reusable podman/docker test database tool for postgres, mssql and mysql.
-# Usage: dbtest.sh <command> <db> [args]
-set -euo pipefail
-
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-ROOT="$(cd "$HERE/../.." && pwd)"
-TIMEOUT="${DBTEST_TIMEOUT:-120}"
-ALL_DBS=(postgres mssql mysql)
-
-usage() {
-	cat <<USAGE
-dbtest.sh <command> <db|all> [args]
-
-commands:
-  up <db>            start container, wait until ready, run init
-  down <db>          stop and remove container
-  restart <db>       down + up
-  status <db>        running state and connection string
-  env <db>           print 'export VAR=conn' (use: eval "\$(dbtest.sh env postgres)")
-  logs <db>          container logs
-  shell <db>         interactive client
-  exec <db> <file>   run a SQL file against the database
-  test <db> [pkgs]   up, run go tests with conn env set, down (keep with DBTEST_KEEP=1)
-  list               supported databases
-
-dbs: ${ALL_DBS[*]}
-env: DBTEST_RUNTIME=podman|docker  DBTEST_TIMEOUT=secs  DBTEST_KEEP=1  DBTEST_GOFLAGS=...
-USAGE
-}
-
-die() { echo "error: $*" >&2; exit 1; }
-log() { echo "[dbtest] $*" >&2; }
-
-detect_runtime() {
-	if [ -n "${DBTEST_RUNTIME:-}" ]; then echo "$DBTEST_RUNTIME"; return; fi
-	if command -v podman >/dev/null 2>&1; then echo podman
-	elif command -v docker >/dev/null 2>&1; then echo docker
-	else die "neither podman nor docker is installed"; fi
-}
-RUNTIME="$(detect_runtime)"
-rt() { "$RUNTIME" "$@"; }
-
-load_db() {
-	local f="$HERE/dbs/${1:-}.sh"
-	[ -f "$f" ] || die "unknown db '${1:-}' (supported: ${ALL_DBS[*]})"
-	# shellcheck disable=SC1090
-	source "$f"
-}
-
-is_running() { [ "$(rt inspect -f '{{.State.Running}}' "$DB_CONTAINER" 2>/dev/null || true)" = "true" ]; }
-
-cmd_up() {
-	if is_running; then
-		log "$DB_NAME already running"
-	else
-		rt rm -f "$DB_CONTAINER" >/dev/null 2>&1 || true
-		log "starting $DB_NAME ($DB_IMAGE) on port $DB_PORT using $RUNTIME"
-		rt run -d --name "$DB_CONTAINER" "${DB_ENV[@]}" \
-			-p "$DB_PORT:$DB_INTERNAL_PORT" \
-			-v "$DB_INIT_MOUNT:ro,Z" "$DB_IMAGE" >/dev/null
-	fi
-	log "waiting for $DB_NAME (max ${TIMEOUT}s)"
-	local i=0
-	until db_ready; do
-		i=$((i + 1))
-		if [ "$i" -ge "$TIMEOUT" ]; then
-			rt logs --tail 50 "$DB_CONTAINER" >&2 || true
-			die "$DB_NAME did not become ready"
-		fi
-		sleep 1
-	done
-	db_post_init
-	log "$DB_NAME ready: $DB_CONN_VAR=$DB_CONN"
-}
-
-cmd_down() {
-	rt rm -f "$DB_CONTAINER" >/dev/null 2>&1 || true
-	log "$DB_NAME removed"
-}
-
-cmd_status() {
-	if is_running; then echo "$DB_NAME: running ($DB_CONTAINER, port $DB_PORT)"; else echo "$DB_NAME: stopped"; fi
-	echo "$DB_CONN_VAR=$DB_CONN"
-}
-
-cmd_test() {
-	local pkgs="${*:-$DB_DEFAULT_PKGS}"
-	[ -n "$pkgs" ] || die "no test packages for $DB_NAME; pass packages as arguments"
-	cmd_up
-	[ -n "${DBTEST_KEEP:-}" ] || trap cmd_down EXIT
-	export "$DB_CONN_VAR=$DB_CONN"
-	cd "$ROOT"
-	# shellcheck disable=SC2086
-	go test -count=1 ${DBTEST_GOFLAGS:-} $pkgs
-}
-
-cmd="${1:-}"
-case "$cmd" in
-	""|-h|--help|help) usage; exit 0 ;;
-	list) printf '%s\n' "${ALL_DBS[@]}"; exit 0 ;;
-esac
-shift
-target="${1:-}"
-[ -n "$target" ] || die "missing <db>"
-shift || true
-
-run_one() {
-	load_db "$1"
-	shift
-	case "$cmd" in
-		up) cmd_up ;;
-		down) cmd_down ;;
-		restart) cmd_down; cmd_up ;;
-		status) cmd_status ;;
-		env) echo "export $DB_CONN_VAR='$DB_CONN'" ;;
-		logs) rt logs "$DB_CONTAINER" ;;
-		shell) db_shell "$@" ;;
-		exec) [ -f "${1:-}" ] || die "usage: exec <db> <file>"; db_exec_file "$1" ;;
-		test) cmd_test "$@" ;;
-		*) usage; die "unknown command '$cmd'" ;;
-	esac
-}
-
-if [ "$target" = "all" ]; then
-	case "$cmd" in up|down|restart|status|env) ;; *) die "'all' is only valid for up/down/restart/status/env" ;; esac
-	for d in "${ALL_DBS[@]}"; do (run_one "$d"); done
-else
-	run_one "$target" "$@"
-fi

tests/dbtest/init/mysql.sql

@@ -1,21 +0,0 @@
--- Minimal MySQL fixture for relspec container tests.
--- Extend when a MySQL reader/writer is added.
-CREATE TABLE users (
-    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
-    email VARCHAR(255) NOT NULL,
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE KEY uq_users_email (email)
-) ENGINE=InnoDB;
-
-CREATE TABLE posts (
-    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
-    user_id BIGINT UNSIGNED NOT NULL,
-    title VARCHAR(255) NOT NULL,
-    body TEXT NULL,
-    KEY idx_posts_user (user_id),
-    CONSTRAINT fk_posts_user FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
-) ENGINE=InnoDB;
-
-CREATE VIEW v_user_posts AS
-    SELECT u.id AS user_id, u.email, p.id AS post_id, p.title
-    FROM users u JOIN posts p ON p.user_id = u.id;