From ee5c009234a778bfdd1e5e6fd15f79b81f5bc8db Mon Sep 17 00:00:00 2001 From: Hein Date: Wed, 9 Sep 2026 21:30:15 +0200 Subject: [PATCH] feat(main): add silent mode to suppress output messages * implement --silent flag to control output verbosity * update error handling to restore stderr after silent mode * enhance progress reporting in PostgreSQL reader --- cmd/relspec/diff.go | 16 +++++----- cmd/relspec/main.go | 35 +++++++++++++++++++-- cmd/relspec/merge.go | 9 ++++-- cmd/relspec/prisma_options.go | 6 ++++ cmd/relspec/root.go | 2 ++ pkg/readers/pgsql/reader.go | 59 +++++++++++++++++++++++++++++++++-- pkg/readers/reader.go | 4 +++ pkg/writers/pgsql/writer.go | 5 ++- 8 files changed, 120 insertions(+), 16 deletions(-) diff --git a/cmd/relspec/diff.go b/cmd/relspec/diff.go index ed9b1e6..a7e8c12 100644 --- a/cmd/relspec/diff.go +++ b/cmd/relspec/diff.go @@ -229,43 +229,43 @@ func readDatabase(dbType, filePath, connString, label string) (*models.Database, if filePath == "" { return nil, fmt.Errorf("%s: file path is required for DBML format", label) } - reader = dbml.NewReader(&readers.ReaderOptions{FilePath: filePath}) + reader = dbml.NewReader(newReaderOptions(filePath, "")) case "dctx": if filePath == "" { return nil, fmt.Errorf("%s: file path is required for DCTX format", label) } - reader = dctx.NewReader(&readers.ReaderOptions{FilePath: filePath}) + reader = dctx.NewReader(newReaderOptions(filePath, "")) case "drawdb": if filePath == "" { return nil, fmt.Errorf("%s: file path is required for DrawDB format", label) } - reader = drawdb.NewReader(&readers.ReaderOptions{FilePath: filePath}) + reader = drawdb.NewReader(newReaderOptions(filePath, "")) case "json": if filePath == "" { return nil, fmt.Errorf("%s: file path is required for JSON format", label) } - reader = json.NewReader(&readers.ReaderOptions{FilePath: filePath}) + reader = json.NewReader(newReaderOptions(filePath, "")) case "yaml": if filePath == "" { return nil, fmt.Errorf("%s: file path is required for YAML format", label) } - reader = yaml.NewReader(&readers.ReaderOptions{FilePath: filePath}) + reader = yaml.NewReader(newReaderOptions(filePath, "")) case "sqldir", "scripts", "scriptdir": if filePath == "" { return nil, fmt.Errorf("%s: file path is required for SQL directory format", label) } - reader = sqldir.NewReader(&readers.ReaderOptions{FilePath: filePath}) + reader = sqldir.NewReader(newReaderOptions(filePath, "")) case "pgsql", "postgres", "postgresql": if connString == "" { return nil, fmt.Errorf("%s: connection string is required for PostgreSQL format", label) } - reader = pgsql.NewReader(&readers.ReaderOptions{ConnectionString: connString}) + reader = pgsql.NewReader(newReaderOptions("", connString)) case "sqlite", "sqlite3": // SQLite can use either file path or connection string @@ -276,7 +276,7 @@ func readDatabase(dbType, filePath, connString, label string) (*models.Database, if dbPath == "" { return nil, fmt.Errorf("%s: file path or connection string is required for SQLite format", label) } - reader = sqlite.NewReader(&readers.ReaderOptions{FilePath: dbPath}) + reader = sqlite.NewReader(newReaderOptions(dbPath, "")) default: return nil, fmt.Errorf("%s: unsupported database format: %s", label, dbType) diff --git a/cmd/relspec/main.go b/cmd/relspec/main.go index 87b12a7..92b0cac 100644 --- a/cmd/relspec/main.go +++ b/cmd/relspec/main.go @@ -6,9 +6,40 @@ import ( ) func main() { - printVersionHeader(os.Args[1:]) - if err := rootCmd.Execute(); err != nil { + args := os.Args[1:] + isSilent := hasSilentFlag(args) + if !isSilent { + printVersionHeader(args) + } + + previousStderr := os.Stderr + var nullOutput *os.File + if isSilent { + var err error + nullOutput, err = os.OpenFile(os.DevNull, os.O_WRONLY, 0) + if err != nil { + fmt.Fprintln(previousStderr, err) + os.Exit(1) + } + os.Stderr = nullOutput + } + + err := rootCmd.Execute() + if nullOutput != nil { + os.Stderr = previousStderr + nullOutput.Close() + } + if err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } + +func hasSilentFlag(args []string) bool { + for _, arg := range args { + if arg == "--silent" || arg == "--silent=true" { + return true + } + } + return false +} diff --git a/cmd/relspec/merge.go b/cmd/relspec/merge.go index 7e7ff56..653f338 100644 --- a/cmd/relspec/merge.go +++ b/cmd/relspec/merge.go @@ -178,7 +178,7 @@ func runMerge(cmd *cobra.Command, args []string) error { } // Step 1: Read target database - fmt.Fprintf(os.Stderr, "[1/3] Reading target database...\n") + fmt.Fprintf(os.Stderr, "[1/4] Reading target database...\n") fmt.Fprintf(os.Stderr, " Format: %s\n", mergeTargetType) if mergeTargetPath != "" { fmt.Fprintf(os.Stderr, " Path: %s\n", mergeTargetPath) @@ -195,7 +195,7 @@ func runMerge(cmd *cobra.Command, args []string) error { printDatabaseStats(targetDB) // Step 2: Read source database(s) - fmt.Fprintf(os.Stderr, "\n[2/3] Reading source database...\n") + fmt.Fprintf(os.Stderr, "\n[2/4] Reading source database...\n") fmt.Fprintf(os.Stderr, " Format: %s\n", mergeSourceType) var sourceDB *models.Database @@ -229,7 +229,7 @@ func runMerge(cmd *cobra.Command, args []string) error { printDatabaseStats(sourceDB) // Step 3: Merge databases - fmt.Fprintf(os.Stderr, "\n[3/3] Merging databases...\n") + fmt.Fprintf(os.Stderr, "\n[3/4] Merging databases...\n") opts := &merge.MergeOptions{ SkipDomains: mergeSkipDomains, @@ -267,6 +267,9 @@ func runMerge(cmd *cobra.Command, args []string) error { if mergeOutputPath != "" { fmt.Fprintf(os.Stderr, " Path: %s\n", mergeOutputPath) } + if mergeOutputConn != "" { + fmt.Fprintf(os.Stderr, " Conn: %s\n", maskPassword(mergeOutputConn)) + } err = writeDatabaseForMerge(mergeOutputType, mergeOutputPath, mergeOutputConn, targetDB, "Output", mergeFlattenSchema) if err != nil { diff --git a/cmd/relspec/prisma_options.go b/cmd/relspec/prisma_options.go index 44d37d1..2c762a1 100644 --- a/cmd/relspec/prisma_options.go +++ b/cmd/relspec/prisma_options.go @@ -1,6 +1,9 @@ package main import ( + "fmt" + "os" + "git.warky.dev/wdevs/relspecgo/pkg/readers" "git.warky.dev/wdevs/relspecgo/pkg/writers" ) @@ -11,6 +14,9 @@ func newReaderOptions(filePath, connString string) *readers.ReaderOptions { ConnectionString: connString, Prisma7: prisma7, StrictDirectives: strictDirectives, + Progress: func(message string) { + fmt.Fprintf(os.Stderr, " → %s\n", message) + }, } } diff --git a/cmd/relspec/root.go b/cmd/relspec/root.go index 039b7e2..2aded30 100644 --- a/cmd/relspec/root.go +++ b/cmd/relspec/root.go @@ -14,6 +14,7 @@ var ( buildDate = "unknown" prisma7 bool noVersion bool + silent bool strictDirectives bool ) @@ -73,6 +74,7 @@ func init() { rootCmd.AddCommand(reportCmd) rootCmd.PersistentFlags().BoolVar(&prisma7, "prisma7", false, "Use Prisma 7 generator conventions when reading/writing Prisma schemas") 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:, …)") } diff --git a/pkg/readers/pgsql/reader.go b/pkg/readers/pgsql/reader.go index 44f029e..bc96c49 100644 --- a/pkg/readers/pgsql/reader.go +++ b/pkg/readers/pgsql/reader.go @@ -34,11 +34,14 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { return nil, fmt.Errorf("connection string is required") } - // Connect to the database + // Connect to the database. This can take noticeable time across a slow network, + // so report it before the driver starts the connection attempt. + r.progress("Connecting to PostgreSQL...") if err := r.connect(); err != nil { return nil, fmt.Errorf("failed to connect: %w", err) } defer r.close() + r.progress("Connected. Reading database metadata...") // Get database name from connection var dbName string @@ -60,34 +63,42 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } // Query all schemas + r.progress("Discovering schemas...") schemas, err := r.querySchemas() if err != nil { return nil, fmt.Errorf("failed to query schemas: %w", err) } // Process each schema - for _, schema := range schemas { + for schemaIndex, schema := range schemas { + r.progress(fmt.Sprintf("Reading schema %q (%d/%d): tables...", schema.Name, schemaIndex+1, len(schemas))) // Query tables for this schema tables, err := r.queryTables(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query tables for schema %s: %w", schema.Name, err) } schema.Tables = tables + r.progress(fmt.Sprintf("Reading schema %q: found %d table(s).", schema.Name, len(tables))) + r.progress(fmt.Sprintf("Reading schema %q: views...", schema.Name)) // Query views for this schema views, err := r.queryViews(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query views for schema %s: %w", schema.Name, err) } schema.Views = views + r.progress(fmt.Sprintf("Reading schema %q: found %d view(s).", schema.Name, len(views))) + r.progress(fmt.Sprintf("Reading schema %q: sequences...", schema.Name)) // Query sequences for this schema sequences, err := r.querySequences(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query sequences for schema %s: %w", schema.Name, err) } schema.Sequences = sequences + r.progress(fmt.Sprintf("Reading schema %q: found %d sequence(s).", schema.Name, len(sequences))) + r.progress(fmt.Sprintf("Reading schema %q: extensions...", schema.Name)) // Query extensions installed into this schema extensions, err := r.queryExtensions(schema.Name) if err != nil { @@ -99,12 +110,15 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } schema.Metadata["extensions"] = extensions } + r.progress(fmt.Sprintf("Reading schema %q: found %d extension(s).", schema.Name, len(extensions))) + r.progress(fmt.Sprintf("Reading schema %q: columns...", schema.Name)) // Query columns for tables and views columnsMap, err := r.queryColumns(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query columns for schema %s: %w", schema.Name, err) } + r.progress(fmt.Sprintf("Reading schema %q: found %d column(s).", schema.Name, countColumns(columnsMap))) // Populate table columns for _, table := range schema.Tables { @@ -122,11 +136,13 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } } + r.progress(fmt.Sprintf("Reading schema %q: primary keys...", schema.Name)) // Query primary keys primaryKeys, err := r.queryPrimaryKeys(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query primary keys for schema %s: %w", schema.Name, err) } + r.progress(fmt.Sprintf("Reading schema %q: found %d primary key(s).", schema.Name, len(primaryKeys))) // Apply primary keys to tables for _, table := range schema.Tables { @@ -143,11 +159,13 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } } + r.progress(fmt.Sprintf("Reading schema %q: foreign keys...", schema.Name)) // Query foreign keys foreignKeys, err := r.queryForeignKeys(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query foreign keys for schema %s: %w", schema.Name, err) } + r.progress(fmt.Sprintf("Reading schema %q: found %d foreign key(s).", schema.Name, countConstraints(foreignKeys))) // Apply foreign keys to tables for _, table := range schema.Tables { @@ -161,11 +179,13 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } } + r.progress(fmt.Sprintf("Reading schema %q: unique constraints...", schema.Name)) // Query unique constraints uniqueConstraints, err := r.queryUniqueConstraints(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query unique constraints for schema %s: %w", schema.Name, err) } + r.progress(fmt.Sprintf("Reading schema %q: found %d unique constraint(s).", schema.Name, countConstraints(uniqueConstraints))) // Apply unique constraints to tables for _, table := range schema.Tables { @@ -177,11 +197,13 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } } + r.progress(fmt.Sprintf("Reading schema %q: check constraints...", schema.Name)) // Query check constraints checkConstraints, err := r.queryCheckConstraints(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query check constraints for schema %s: %w", schema.Name, err) } + r.progress(fmt.Sprintf("Reading schema %q: found %d check constraint(s).", schema.Name, countConstraints(checkConstraints))) // Apply check constraints to tables for _, table := range schema.Tables { @@ -193,11 +215,13 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { } } + r.progress(fmt.Sprintf("Reading schema %q: indexes...", schema.Name)) // Query indexes indexes, err := r.queryIndexes(schema.Name) if err != nil { return nil, fmt.Errorf("failed to query indexes for schema %s: %w", schema.Name, err) } + r.progress(fmt.Sprintf("Reading schema %q: found %d index(es).", schema.Name, countIndexes(indexes))) // Apply indexes to tables for _, table := range schema.Tables { @@ -226,10 +250,41 @@ func (r *Reader) ReadDatabase() (*models.Database, error) { // Add schema to database db.Schemas = append(db.Schemas, schema) } + r.progress("PostgreSQL schema read complete.") return db, nil } +func (r *Reader) progress(message string) { + if r.options.Progress != nil { + r.options.Progress(message) + } +} + +func countColumns(columns map[string]map[string]*models.Column) int { + total := 0 + for _, tableColumns := range columns { + total += len(tableColumns) + } + return total +} + +func countConstraints(constraints map[string][]*models.Constraint) int { + total := 0 + for _, tableConstraints := range constraints { + total += len(tableConstraints) + } + return total +} + +func countIndexes(indexes map[string][]*models.Index) int { + total := 0 + for _, tableIndexes := range indexes { + total += len(tableIndexes) + } + return total +} + // ReadSchema reads a single schema (returns the first schema from the database) func (r *Reader) ReadSchema() (*models.Schema, error) { db, err := r.ReadDatabase() diff --git a/pkg/readers/reader.go b/pkg/readers/reader.go index 6fff355..9972a88 100644 --- a/pkg/readers/reader.go +++ b/pkg/readers/reader.go @@ -32,6 +32,10 @@ type ReaderOptions struct { // fail on an unknown namespace or key instead of preserving them silently. StrictDirectives bool + // Progress receives human-readable status updates while a reader is working. + // It is optional so library users can opt in without coupling readers to a UI. + Progress func(string) + // Additional options can be added here as needed Metadata map[string]interface{} } diff --git a/pkg/writers/pgsql/writer.go b/pkg/writers/pgsql/writer.go index dc050d7..93b1d9f 100644 --- a/pkg/writers/pgsql/writer.go +++ b/pkg/writers/pgsql/writer.go @@ -1980,7 +1980,8 @@ func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) erro Errors: make([]ExecutionError, 0), } - // Generate SQL statements + // Generating a large schema can take time before any statement is executed. + fmt.Fprintln(os.Stderr, " → Generating PostgreSQL statements...") statements, err := w.GenerateDatabaseStatements(db) if err != nil { return fmt.Errorf("failed to generate SQL statements: %w", err) @@ -1989,12 +1990,14 @@ func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) erro w.executionReport.TotalStatements = len(statements) // Connect to database + fmt.Fprintln(os.Stderr, " → Connecting to PostgreSQL output database...") ctx := context.Background() conn, err := pgsql.Connect(ctx, connString, "writer-pgsql") if err != nil { return fmt.Errorf("failed to connect to database: %w", err) } defer conn.Close(ctx) + fmt.Fprintln(os.Stderr, " → Connected. Executing statements...") // Track schemas and tables schemaMap := make(map[string]*SchemaReport)