feat(writer): enhance type conversion for PostgreSQL compatibility and add tests

- Implemented ExecutionReport to track the execution status of SQL statements.
- Added SchemaReport and TableReport to monitor execution per schema and table.
- Enhanced WriteDatabase to execute SQL directly on a PostgreSQL database if a connection string is provided.
- Included error handling and logging for failed statements during execution.
- Added functionality to write execution reports to a JSON file.
- Introduced utility functions to extract table names from CREATE TABLE statements and truncate long SQL statements for error messages.

cmd/relspec/merge.go

@@ -55,6 +55,7 @@ var (
 	mergeSkipSequences bool
 	mergeSkipTables    string // Comma-separated table names to skip
 	mergeVerbose       bool
+	mergeReportPath    string // Path to write merge report
 )
 
 var mergeCmd = &cobra.Command{
@@ -78,6 +79,12 @@ Examples:
                 --source pgsql --source-conn "postgres://user:pass@localhost/source_db" \
                 --output json --output-path combined.json
 
+  # Merge and execute on PostgreSQL database with report
+  relspec merge --target json --target-path base.json \
+                --source json --source-path additional.json \
+                --output pgsql --output-conn "postgres://user:pass@localhost/target_db" \
+                --merge-report merge-report.json
+
   # Merge DBML and YAML, skip relations
   relspec merge --target dbml --target-path schema.dbml \
                 --source yaml --source-path tables.yaml \
@@ -115,6 +122,7 @@ func init() {
 	mergeCmd.Flags().BoolVar(&mergeSkipSequences, "skip-sequences", false, "Skip sequences during merge")
 	mergeCmd.Flags().StringVar(&mergeSkipTables, "skip-tables", "", "Comma-separated list of table names to skip during merge")
 	mergeCmd.Flags().BoolVar(&mergeVerbose, "verbose", false, "Show verbose output")
+	mergeCmd.Flags().StringVar(&mergeReportPath, "merge-report", "", "Path to write merge report (JSON format)")
 }
 
 func runMerge(cmd *cobra.Command, args []string) error {
@@ -229,7 +237,7 @@ func runMerge(cmd *cobra.Command, args []string) error {
 		fmt.Fprintf(os.Stderr, "      Path:   %s\n", mergeOutputPath)
 	}
 
-	err = writeDatabaseForMerge(mergeOutputType, mergeOutputPath, "", targetDB, "Output")
+	err = writeDatabaseForMerge(mergeOutputType, mergeOutputPath, mergeOutputConn, targetDB, "Output")
 	if err != nil {
 		return fmt.Errorf("failed to write output: %w", err)
 	}
@@ -376,7 +384,17 @@ func writeDatabaseForMerge(dbType, filePath, connString string, db *models.Datab
 		}
 		writer = wtypeorm.NewWriter(&writers.WriterOptions{OutputPath: filePath})
 	case "pgsql":
-		writer = wpgsql.NewWriter(&writers.WriterOptions{OutputPath: filePath})
+		writerOpts := &writers.WriterOptions{OutputPath: filePath}
+		if connString != "" {
+			writerOpts.Metadata = map[string]interface{}{
+				"connection_string": connString,
+			}
+			// Add report path if merge report is enabled
+			if mergeReportPath != "" {
+				writerOpts.Metadata["report_path"] = mergeReportPath
+			}
+		}
+		writer = wpgsql.NewWriter(writerOpts)
 	default:
 		return fmt.Errorf("%s: unsupported format '%s'", label, dbType)
 	}

pkg/pgsql/datatypes.go

@@ -4,31 +4,31 @@ import "strings"
 
 var GoToStdTypes = map[string]string{
 	"bool":            "boolean",
-	"int64":           "integer",
+	"int64":           "bigint",
 	"int":             "integer",
-	"int8":            "integer",
+	"int8":            "smallint",
-	"int16":           "integer",
+	"int16":           "smallint",
 	"int32":           "integer",
 	"uint":            "integer",
-	"uint8":           "integer",
+	"uint8":           "smallint",
-	"uint16":          "integer",
+	"uint16":          "smallint",
 	"uint32":          "integer",
-	"uint64":          "integer",
+	"uint64":          "bigint",
-	"uintptr":         "integer",
+	"uintptr":         "bigint",
-	"znullint64":      "integer",
+	"znullint64":      "bigint",
 	"znullint32":      "integer",
-	"znullbyte":       "integer",
+	"znullbyte":       "smallint",
 	"float64":         "double",
 	"float32":         "double",
 	"complex64":       "double",
 	"complex128":      "double",
 	"customfloat64":   "double",
-	"string":          "string",
+	"string":          "text",
-	"Pointer":         "integer",
+	"Pointer":         "bigint",
 	"[]byte":          "blob",
-	"customdate":      "string",
+	"customdate":      "date",
-	"customtime":      "string",
+	"customtime":      "time",
-	"customtimestamp": "string",
+	"customtimestamp": "timestamp",
 	"sqlfloat64":      "double",
 	"sqlfloat16":      "double",
 	"sqluuid":         "uuid",
@@ -36,9 +36,9 @@ var GoToStdTypes = map[string]string{
 	"sqljson":         "json",
 	"sqlint64":        "bigint",
 	"sqlint32":        "integer",
-	"sqlint16":        "integer",
+	"sqlint16":        "smallint",
 	"sqlbool":         "boolean",
-	"sqlstring":       "string",
+	"sqlstring":       "text",
 	"nullablejsonb":   "jsonb",
 	"nullablejson":    "json",
 	"nullableuuid":    "uuid",
@@ -67,7 +67,7 @@ var GoToPGSQLTypes = map[string]string{
 	"float32":         "real",
 	"complex64":       "double precision",
 	"complex128":      "double precision",
-	"customfloat64":   "double precisio",
+	"customfloat64":   "double precision",
 	"string":          "text",
 	"Pointer":         "bigint",
 	"[]byte":          "bytea",
@@ -81,9 +81,9 @@ var GoToPGSQLTypes = map[string]string{
 	"sqljson":         "json",
 	"sqlint64":        "bigint",
 	"sqlint32":        "integer",
-	"sqlint16":        "integer",
+	"sqlint16":        "smallint",
 	"sqlbool":         "boolean",
-	"sqlstring":       "string",
+	"sqlstring":       "text",
 	"nullablejsonb":   "jsonb",
 	"nullablejson":    "json",
 	"nullableuuid":    "uuid",

pkg/readers/dbml/reader.go

@@ -587,10 +587,10 @@ func (r *Reader) parseColumn(line, tableName, schemaName string) (*models.Column
 					refOp := strings.TrimSpace(refStr)
 					var isReverse bool
 					if strings.HasPrefix(refOp, "<") {
-						isReverse = column.IsPrimaryKey // < on PK means "is referenced by" (reverse)
+						// < means "is referenced by" - only makes sense on PK columns
-					} else if strings.HasPrefix(refOp, ">") {
+						isReverse = column.IsPrimaryKey
-						isReverse = !column.IsPrimaryKey // > on FK means reverse
 					}
+					// > means "references" - always a forward FK, never reverse
 
 					constraint = r.parseRef(refStr)
 					if constraint != nil {

pkg/readers/pgsql/reader.go

@@ -329,10 +329,10 @@ func (r *Reader) deriveRelationship(table *models.Table, fk *models.Constraint)
 	relationshipName := fmt.Sprintf("%s_to_%s", table.Name, fk.ReferencedTable)
 
 	relationship := models.InitRelationship(relationshipName, models.OneToMany)
-	relationship.FromTable = fk.ReferencedTable
+	relationship.FromTable = table.Name
-	relationship.FromSchema = fk.ReferencedSchema
+	relationship.FromSchema = table.Schema
-	relationship.ToTable = table.Name
+	relationship.ToTable = fk.ReferencedTable
-	relationship.ToSchema = table.Schema
+	relationship.ToSchema = fk.ReferencedSchema
 	relationship.ForeignKey = fk.Name
 
 	// Store constraint actions in properties

pkg/readers/pgsql/reader_test.go

@@ -328,12 +328,12 @@ func TestDeriveRelationship(t *testing.T) {
 		t.Errorf("Expected relationship type %s, got %s", models.OneToMany, rel.Type)
 	}
 
-	if rel.FromTable != "users" {
+	if rel.FromTable != "orders" {
-		t.Errorf("Expected FromTable 'users', got '%s'", rel.FromTable)
+		t.Errorf("Expected FromTable 'orders', got '%s'", rel.FromTable)
 	}
 
-	if rel.ToTable != "orders" {
+	if rel.ToTable != "users" {
-		t.Errorf("Expected ToTable 'orders', got '%s'", rel.ToTable)
+		t.Errorf("Expected ToTable 'users', got '%s'", rel.ToTable)
 	}
 
 	if rel.ForeignKey != "fk_orders_user_id" {

pkg/writers/pgsql/migration_writer.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
@@ -335,7 +336,7 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 				SchemaName: schema.Name,
 				TableName:  modelTable.Name,
 				ColumnName: modelCol.Name,
-				ColumnType: modelCol.Type,
+				ColumnType: pgsql.ConvertSQLType(modelCol.Type),
 				Default:    defaultVal,
 				NotNull:    modelCol.NotNull,
 			})
@@ -359,7 +360,7 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 					SchemaName: schema.Name,
 					TableName:  modelTable.Name,
 					ColumnName: modelCol.Name,
-					NewType:    modelCol.Type,
+					NewType:    pgsql.ConvertSQLType(modelCol.Type),
 				})
 				if err != nil {
 					return nil, err
@@ -427,9 +428,11 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 	for _, modelTable := range model.Tables {
 		currentTable := currentTables[strings.ToLower(modelTable.Name)]
 
-		// Process primary keys first
+		// Process primary keys first - check explicit constraints
+		foundExplicitPK := false
 		for constraintName, constraint := range modelTable.Constraints {
 			if constraint.Type == models.PrimaryKeyConstraint {
+				foundExplicitPK = true
 				shouldCreate := true
 
 				if currentTable != nil {
@@ -464,6 +467,53 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 			}
 		}
 
+		// If no explicit PK constraint, check for columns with IsPrimaryKey = true
+		if !foundExplicitPK {
+			pkColumns := []string{}
+			for _, col := range modelTable.Columns {
+				if col.IsPrimaryKey {
+					pkColumns = append(pkColumns, col.SQLName())
+				}
+			}
+			if len(pkColumns) > 0 {
+				sort.Strings(pkColumns)
+				constraintName := fmt.Sprintf("pk_%s_%s", strings.ToLower(model.Name), strings.ToLower(modelTable.Name))
+				shouldCreate := true
+
+				if currentTable != nil {
+					// Check if a PK constraint already exists (by any name)
+					for _, constraint := range currentTable.Constraints {
+						if constraint.Type == models.PrimaryKeyConstraint {
+							shouldCreate = false
+							break
+						}
+					}
+				}
+
+				if shouldCreate {
+					sql, err := w.executor.ExecuteCreatePrimaryKey(CreatePrimaryKeyData{
+						SchemaName:     model.Name,
+						TableName:      modelTable.Name,
+						ConstraintName: constraintName,
+						Columns:        strings.Join(pkColumns, ", "),
+					})
+					if err != nil {
+						return nil, err
+					}
+
+					script := MigrationScript{
+						ObjectName: fmt.Sprintf("%s.%s.%s", model.Name, modelTable.Name, constraintName),
+						ObjectType: "create primary key",
+						Schema:     model.Name,
+						Priority:   160,
+						Sequence:   len(scripts),
+						Body:       sql,
+					}
+					scripts = append(scripts, script)
+				}
+			}
+		}
+
 		// Process indexes
 		for indexName, modelIndex := range modelTable.Indexes {
 			// Skip primary key indexes

pkg/writers/pgsql/writer.go

@@ -1,20 +1,58 @@
 package pgsql
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"sort"
 	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
 // Writer implements the Writer interface for PostgreSQL SQL output
 type Writer struct {
-	options *writers.WriterOptions
+	options         *writers.WriterOptions
-	writer  io.Writer
+	writer          io.Writer
+	executionReport *ExecutionReport
+}
+
+// ExecutionReport tracks the execution status of SQL statements
+type ExecutionReport struct {
+	TotalStatements    int              `json:"total_statements"`
+	ExecutedStatements int              `json:"executed_statements"`
+	FailedStatements   int              `json:"failed_statements"`
+	Schemas            []SchemaReport   `json:"schemas"`
+	Errors             []ExecutionError `json:"errors,omitempty"`
+	StartTime          string           `json:"start_time"`
+	EndTime            string           `json:"end_time"`
+}
+
+// SchemaReport tracks execution per schema
+type SchemaReport struct {
+	Name   string        `json:"name"`
+	Tables []TableReport `json:"tables"`
+}
+
+// TableReport tracks execution per table
+type TableReport struct {
+	Name    string `json:"name"`
+	Created bool   `json:"created"`
+	Error   string `json:"error,omitempty"`
+}
+
+// ExecutionError represents a failed statement
+type ExecutionError struct {
+	StatementNumber int    `json:"statement_number"`
+	Statement       string `json:"statement"`
+	Error           string `json:"error"`
 }
 
 // NewWriter creates a new PostgreSQL SQL writer
@@ -26,6 +64,11 @@ func NewWriter(options *writers.WriterOptions) *Writer {
 
 // WriteDatabase writes the entire database schema as SQL
 func (w *Writer) WriteDatabase(db *models.Database) error {
+	// Check if we should execute SQL directly on a database
+	if connString, ok := w.options.Metadata["connection_string"].(string); ok && connString != "" {
+		return w.executeDatabaseSQL(db, connString)
+	}
+
 	var writer io.Writer
 	var file *os.File
 	var err error
@@ -127,13 +170,35 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 
 	// Phase 4: Primary keys
 	for _, table := range schema.Tables {
+		// First check for explicit PrimaryKeyConstraint
+		var pkConstraint *models.Constraint
 		for _, constraint := range table.Constraints {
-			if constraint.Type != models.PrimaryKeyConstraint {
+			if constraint.Type == models.PrimaryKeyConstraint {
-				continue
+				pkConstraint = constraint
+				break
 			}
+		}
+
+		if pkConstraint != nil {
 			stmt := fmt.Sprintf("ALTER TABLE %s.%s ADD CONSTRAINT %s PRIMARY KEY (%s)",
-				schema.SQLName(), table.SQLName(), constraint.Name, strings.Join(constraint.Columns, ", "))
+				schema.SQLName(), table.SQLName(), pkConstraint.Name, strings.Join(pkConstraint.Columns, ", "))
 			statements = append(statements, stmt)
+		} else {
+			// No explicit constraint, check for columns with IsPrimaryKey = true
+			pkColumns := []string{}
+			for _, col := range table.Columns {
+				if col.IsPrimaryKey {
+					pkColumns = append(pkColumns, col.SQLName())
+				}
+			}
+			if len(pkColumns) > 0 {
+				// Sort for consistent output
+				sort.Strings(pkColumns)
+				pkName := fmt.Sprintf("pk_%s_%s", schema.SQLName(), table.SQLName())
+				stmt := fmt.Sprintf("ALTER TABLE %s.%s ADD CONSTRAINT %s PRIMARY KEY (%s)",
+					schema.SQLName(), table.SQLName(), pkName, strings.Join(pkColumns, ", "))
+				statements = append(statements, stmt)
+			}
 		}
 	}
 
@@ -155,13 +220,30 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 				indexType = "btree"
 			}
 
+			// Build column expressions with operator class support for GIN indexes
+			columnExprs := make([]string, 0, len(index.Columns))
+			for _, colName := range index.Columns {
+				colExpr := colName
+				if col, ok := table.Columns[colName]; ok {
+					// For GIN indexes on text columns, add operator class
+					if strings.EqualFold(indexType, "gin") && isTextType(col.Type) {
+						opClass := extractOperatorClass(index.Comment)
+						if opClass == "" {
+							opClass = "gin_trgm_ops"
+						}
+						colExpr = fmt.Sprintf("%s %s", colName, opClass)
+					}
+				}
+				columnExprs = append(columnExprs, colExpr)
+			}
+
 			whereClause := ""
 			if index.Where != "" {
 				whereClause = fmt.Sprintf(" WHERE %s", index.Where)
 			}
 
 			stmt := fmt.Sprintf("CREATE %sINDEX IF NOT EXISTS %s ON %s.%s USING %s (%s)%s",
-				uniqueStr, index.Name, schema.SQLName(), table.SQLName(), indexType, strings.Join(index.Columns, ", "), whereClause)
+				uniqueStr, index.Name, schema.SQLName(), table.SQLName(), indexType, strings.Join(columnExprs, ", "), whereClause)
 			statements = append(statements, stmt)
 		}
 	}
@@ -251,15 +333,16 @@ func (w *Writer) generateCreateTableStatement(schema *models.Schema, table *mode
 func (w *Writer) generateColumnDefinition(col *models.Column) string {
 	parts := []string{col.SQLName()}
 
-	// Type with length/precision
+	// Type with length/precision - convert to valid PostgreSQL type
-	typeStr := col.Type
+	baseType := pgsql.ConvertSQLType(col.Type)
+	typeStr := baseType
 	if col.Length > 0 && col.Precision == 0 {
-		typeStr = fmt.Sprintf("%s(%d)", col.Type, col.Length)
+		typeStr = fmt.Sprintf("%s(%d)", baseType, col.Length)
 	} else if col.Precision > 0 {
 		if col.Scale > 0 {
-			typeStr = fmt.Sprintf("%s(%d,%d)", col.Type, col.Precision, col.Scale)
+			typeStr = fmt.Sprintf("%s(%d,%d)", baseType, col.Precision, col.Scale)
 		} else {
-			typeStr = fmt.Sprintf("%s(%d)", col.Type, col.Precision)
+			typeStr = fmt.Sprintf("%s(%d)", baseType, col.Precision)
 		}
 	}
 	parts = append(parts, typeStr)
@@ -273,12 +356,14 @@ func (w *Writer) generateColumnDefinition(col *models.Column) string {
 	if col.Default != nil {
 		switch v := col.Default.(type) {
 		case string:
-			if strings.HasPrefix(v, "nextval") || strings.HasPrefix(v, "CURRENT_") || strings.Contains(v, "()") {
+			// Strip backticks - DBML uses them for SQL expressions but PostgreSQL doesn't
-				parts = append(parts, fmt.Sprintf("DEFAULT %s", v))
+			cleanDefault := stripBackticks(v)
-			} else if v == "true" || v == "false" {
+			if strings.HasPrefix(cleanDefault, "nextval") || strings.HasPrefix(cleanDefault, "CURRENT_") || strings.Contains(cleanDefault, "()") {
-				parts = append(parts, fmt.Sprintf("DEFAULT %s", v))
+				parts = append(parts, fmt.Sprintf("DEFAULT %s", cleanDefault))
+			} else if cleanDefault == "true" || cleanDefault == "false" {
+				parts = append(parts, fmt.Sprintf("DEFAULT %s", cleanDefault))
 			} else {
-				parts = append(parts, fmt.Sprintf("DEFAULT '%s'", escapeQuote(v)))
+				parts = append(parts, fmt.Sprintf("DEFAULT '%s'", escapeQuote(cleanDefault)))
 			}
 		case bool:
 			parts = append(parts, fmt.Sprintf("DEFAULT %v", v))
@@ -405,11 +490,13 @@ func (w *Writer) writeCreateTables(schema *models.Schema) error {
 		columnDefs := make([]string, 0, len(columns))
 
 		for _, col := range columns {
-			colDef := fmt.Sprintf("  %s %s", col.SQLName(), col.Type)
+			colDef := fmt.Sprintf("  %s %s", col.SQLName(), pgsql.ConvertSQLType(col.Type))
 
 			// Add default value if present
-			if col.Default != "" {
+			if col.Default != nil && col.Default != "" {
-				colDef += fmt.Sprintf(" DEFAULT %s", col.Default)
+				// Strip backticks - DBML uses them for SQL expressions but PostgreSQL doesn't
+				defaultVal := fmt.Sprintf("%v", col.Default)
+				colDef += fmt.Sprintf(" DEFAULT %s", stripBackticks(defaultVal))
 			}
 
 			columnDefs = append(columnDefs, colDef)
@@ -437,19 +524,26 @@ func (w *Writer) writePrimaryKeys(schema *models.Schema) error {
 			}
 		}
 
-		if pkConstraint == nil {
+		var columnNames []string
-			// No explicit PK constraint, skip
-			continue
-		}
-
 		pkName := fmt.Sprintf("pk_%s_%s", schema.SQLName(), table.SQLName())
 
-		// Build column list
+		if pkConstraint != nil {
-		columnNames := make([]string, 0, len(pkConstraint.Columns))
+			// Build column list from explicit constraint
-		for _, colName := range pkConstraint.Columns {
+			columnNames = make([]string, 0, len(pkConstraint.Columns))
-			if col, ok := table.Columns[colName]; ok {
+			for _, colName := range pkConstraint.Columns {
-				columnNames = append(columnNames, col.SQLName())
+				if col, ok := table.Columns[colName]; ok {
+					columnNames = append(columnNames, col.SQLName())
+				}
 			}
+		} else {
+			// No explicit PK constraint, check for columns with IsPrimaryKey = true
+			for _, col := range table.Columns {
+				if col.IsPrimaryKey {
+					columnNames = append(columnNames, col.SQLName())
+				}
+			}
+			// Sort for consistent output
+			sort.Strings(columnNames)
 		}
 
 		if len(columnNames) == 0 {
@@ -503,15 +597,24 @@ func (w *Writer) writeIndexes(schema *models.Schema) error {
 				indexName = fmt.Sprintf("%s_%s_%s", indexType, schema.SQLName(), table.SQLName())
 			}
 
-			// Build column list
+			// Build column list with operator class support for GIN indexes
-			columnNames := make([]string, 0, len(index.Columns))
+			columnExprs := make([]string, 0, len(index.Columns))
 			for _, colName := range index.Columns {
 				if col, ok := table.Columns[colName]; ok {
-					columnNames = append(columnNames, col.SQLName())
+					colExpr := col.SQLName()
+					// For GIN indexes on text columns, add operator class
+					if strings.EqualFold(index.Type, "gin") && isTextType(col.Type) {
+						opClass := extractOperatorClass(index.Comment)
+						if opClass == "" {
+							opClass = "gin_trgm_ops"
+						}
+						colExpr = fmt.Sprintf("%s %s", col.SQLName(), opClass)
+					}
+					columnExprs = append(columnExprs, colExpr)
 				}
 			}
 
-			if len(columnNames) == 0 {
+			if len(columnExprs) == 0 {
 				continue
 			}
 
@@ -520,10 +623,20 @@ func (w *Writer) writeIndexes(schema *models.Schema) error {
 				unique = "UNIQUE "
 			}
 
+			indexType := index.Type
+			if indexType == "" {
+				indexType = "btree"
+			}
+
+			whereClause := ""
+			if index.Where != "" {
+				whereClause = fmt.Sprintf(" WHERE %s", index.Where)
+			}
+
 			fmt.Fprintf(w.writer, "CREATE %sINDEX IF NOT EXISTS %s\n",
 				unique, indexName)
-			fmt.Fprintf(w.writer, "  ON %s.%s USING btree (%s);\n\n",
+			fmt.Fprintf(w.writer, "  ON %s.%s USING %s (%s)%s;\n\n",
-				schema.SQLName(), table.SQLName(), strings.Join(columnNames, ", "))
+				schema.SQLName(), table.SQLName(), indexType, strings.Join(columnExprs, ", "), whereClause)
 		}
 	}
 
@@ -718,11 +831,46 @@ func isIntegerType(colType string) bool {
 	return false
 }
 
+// isTextType checks if a column type is a text type (for GIN index operator class)
+func isTextType(colType string) bool {
+	textTypes := []string{"text", "varchar", "character varying", "char", "character", "string"}
+	lowerType := strings.ToLower(colType)
+	for _, t := range textTypes {
+		if strings.HasPrefix(lowerType, t) {
+			return true
+		}
+	}
+	return false
+}
+
+// extractOperatorClass extracts operator class from index comment/note
+// Looks for common operator classes like gin_trgm_ops, gist_trgm_ops, etc.
+func extractOperatorClass(comment string) string {
+	if comment == "" {
+		return ""
+	}
+	lowerComment := strings.ToLower(comment)
+	// Common GIN/GiST operator classes
+	opClasses := []string{"gin_trgm_ops", "gist_trgm_ops", "gin_bigm_ops", "jsonb_ops", "jsonb_path_ops", "array_ops"}
+	for _, op := range opClasses {
+		if strings.Contains(lowerComment, op) {
+			return op
+		}
+	}
+	return ""
+}
+
 // escapeQuote escapes single quotes in strings for SQL
 func escapeQuote(s string) string {
 	return strings.ReplaceAll(s, "'", "''")
 }
 
+// stripBackticks removes backticks from SQL expressions
+// DBML uses backticks for SQL expressions like `now()`, but PostgreSQL doesn't use backticks
+func stripBackticks(s string) string {
+	return strings.ReplaceAll(s, "`", "")
+}
+
 // extractSequenceName extracts sequence name from nextval() expression
 // Example: "nextval('public.users_id_seq'::regclass)" returns "users_id_seq"
 func extractSequenceName(defaultExpr string) string {
@@ -745,3 +893,195 @@ func extractSequenceName(defaultExpr string) string {
 	}
 	return fullName
 }
+
+// executeDatabaseSQL executes SQL statements directly on a PostgreSQL database
+func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) error {
+	// Initialize execution report
+	w.executionReport = &ExecutionReport{
+		StartTime: getCurrentTimestamp(),
+		Schemas:   make([]SchemaReport, 0),
+		Errors:    make([]ExecutionError, 0),
+	}
+
+	// Generate SQL statements
+	statements, err := w.GenerateDatabaseStatements(db)
+	if err != nil {
+		return fmt.Errorf("failed to generate SQL statements: %w", err)
+	}
+
+	w.executionReport.TotalStatements = len(statements)
+
+	// Connect to database
+	ctx := context.Background()
+	conn, err := pgx.Connect(ctx, connString)
+	if err != nil {
+		return fmt.Errorf("failed to connect to database: %w", err)
+	}
+	defer conn.Close(ctx)
+
+	// Track schemas and tables
+	schemaMap := make(map[string]*SchemaReport)
+	currentSchema := ""
+
+	// Execute each statement
+	for i, stmt := range statements {
+		stmtTrimmed := strings.TrimSpace(stmt)
+
+		// Skip comments
+		if strings.HasPrefix(stmtTrimmed, "--") {
+			// Check if this is a schema comment to track schema changes
+			if strings.Contains(stmtTrimmed, "Schema:") {
+				parts := strings.Split(stmtTrimmed, "Schema:")
+				if len(parts) > 1 {
+					currentSchema = strings.TrimSpace(parts[1])
+					if _, exists := schemaMap[currentSchema]; !exists {
+						schemaReport := SchemaReport{
+							Name:   currentSchema,
+							Tables: make([]TableReport, 0),
+						}
+						schemaMap[currentSchema] = &schemaReport
+					}
+				}
+			}
+			continue
+		}
+
+		// Skip empty statements
+		if stmtTrimmed == "" {
+			continue
+		}
+
+		fmt.Fprintf(os.Stderr, "Executing statement %d/%d...\n", i+1, len(statements))
+
+		_, execErr := conn.Exec(ctx, stmt)
+		if execErr != nil {
+			w.executionReport.FailedStatements++
+			execError := ExecutionError{
+				StatementNumber: i + 1,
+				Statement:       truncateStatement(stmt),
+				Error:           execErr.Error(),
+			}
+			w.executionReport.Errors = append(w.executionReport.Errors, execError)
+
+			// Track table creation failure
+			if strings.Contains(strings.ToUpper(stmtTrimmed), "CREATE TABLE") && currentSchema != "" {
+				tableName := extractTableNameFromCreate(stmtTrimmed)
+				if tableName != "" && schemaMap[currentSchema] != nil {
+					schemaMap[currentSchema].Tables = append(schemaMap[currentSchema].Tables, TableReport{
+						Name:    tableName,
+						Created: false,
+						Error:   execErr.Error(),
+					})
+				}
+			}
+
+			// Continue with next statement instead of failing completely
+			fmt.Fprintf(os.Stderr, "⚠ Warning: Statement %d failed: %v\n", i+1, execErr)
+			continue
+		}
+
+		w.executionReport.ExecutedStatements++
+
+		// Track successful table creation
+		if strings.Contains(strings.ToUpper(stmtTrimmed), "CREATE TABLE") && currentSchema != "" {
+			tableName := extractTableNameFromCreate(stmtTrimmed)
+			if tableName != "" && schemaMap[currentSchema] != nil {
+				schemaMap[currentSchema].Tables = append(schemaMap[currentSchema].Tables, TableReport{
+					Name:    tableName,
+					Created: true,
+				})
+			}
+		}
+	}
+
+	// Convert schema map to slice
+	for _, schemaReport := range schemaMap {
+		w.executionReport.Schemas = append(w.executionReport.Schemas, *schemaReport)
+	}
+
+	w.executionReport.EndTime = getCurrentTimestamp()
+
+	// Write report if path is specified
+	if reportPath, ok := w.options.Metadata["report_path"].(string); ok && reportPath != "" {
+		if err := w.writeReport(reportPath); err != nil {
+			fmt.Fprintf(os.Stderr, "⚠ Warning: Failed to write report: %v\n", err)
+		} else {
+			fmt.Fprintf(os.Stderr, "✓ Report written to: %s\n", reportPath)
+		}
+	}
+
+	if w.executionReport.FailedStatements > 0 {
+		fmt.Fprintf(os.Stderr, "⚠ Completed with %d errors out of %d statements\n",
+			w.executionReport.FailedStatements, w.executionReport.TotalStatements)
+	} else {
+		fmt.Fprintf(os.Stderr, "✓ Successfully executed %d statements\n", w.executionReport.ExecutedStatements)
+	}
+
+	return nil
+}
+
+// writeReport writes the execution report to a JSON file
+func (w *Writer) writeReport(reportPath string) error {
+	file, err := os.Create(reportPath)
+	if err != nil {
+		return fmt.Errorf("failed to create report file: %w", err)
+	}
+	defer file.Close()
+
+	encoder := json.NewEncoder(file)
+	encoder.SetIndent("", "  ")
+	if err := encoder.Encode(w.executionReport); err != nil {
+		return fmt.Errorf("failed to encode report: %w", err)
+	}
+
+	return nil
+}
+
+// extractTableNameFromCreate extracts table name from CREATE TABLE statement
+func extractTableNameFromCreate(stmt string) string {
+	// Match: CREATE TABLE [IF NOT EXISTS] schema.table_name or table_name
+	upper := strings.ToUpper(stmt)
+	idx := strings.Index(upper, "CREATE TABLE")
+	if idx == -1 {
+		return ""
+	}
+
+	rest := strings.TrimSpace(stmt[idx+12:]) // Skip "CREATE TABLE"
+
+	// Skip "IF NOT EXISTS"
+	if strings.HasPrefix(strings.ToUpper(rest), "IF NOT EXISTS") {
+		rest = strings.TrimSpace(rest[13:])
+	}
+
+	// Get the table name (first token before '(' or whitespace)
+	tokens := strings.FieldsFunc(rest, func(r rune) bool {
+		return r == '(' || r == ' ' || r == '\n' || r == '\t'
+	})
+
+	if len(tokens) == 0 {
+		return ""
+	}
+
+	// Handle schema.table format
+	fullName := tokens[0]
+	parts := strings.Split(fullName, ".")
+	if len(parts) > 1 {
+		return parts[len(parts)-1]
+	}
+
+	return fullName
+}
+
+// truncateStatement truncates long SQL statements for error messages
+func truncateStatement(stmt string) string {
+	const maxLen = 200
+	if len(stmt) <= maxLen {
+		return stmt
+	}
+	return stmt[:maxLen] + "..."
+}
+
+// getCurrentTimestamp returns the current timestamp in a readable format
+func getCurrentTimestamp() string {
+	return time.Now().Format("2006-01-02 15:04:05")
+}

pkg/writers/pgsql/writer_test.go

@@ -241,3 +241,67 @@ func TestIsIntegerType(t *testing.T) {
 		}
 	}
 }
+
+func TestTypeConversion(t *testing.T) {
+	// Test that invalid Go types are converted to valid PostgreSQL types
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	// Create a test table with Go types instead of SQL types
+	table := models.InitTable("test_types", "public")
+
+	// Add columns with Go types (invalid for PostgreSQL)
+	stringCol := models.InitColumn("name", "test_types", "public")
+	stringCol.Type = "string" // Should be converted to "text"
+	table.Columns["name"] = stringCol
+
+	int64Col := models.InitColumn("big_id", "test_types", "public")
+	int64Col.Type = "int64" // Should be converted to "bigint"
+	table.Columns["big_id"] = int64Col
+
+	int16Col := models.InitColumn("small_id", "test_types", "public")
+	int16Col.Type = "int16" // Should be converted to "smallint"
+	table.Columns["small_id"] = int16Col
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	// Create writer with output to buffer
+	var buf bytes.Buffer
+	options := &writers.WriterOptions{}
+	writer := NewWriter(options)
+	writer.writer = &buf
+
+	// Write the database
+	err := writer.WriteDatabase(db)
+	if err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+
+	// Print output for debugging
+	t.Logf("Generated SQL:\n%s", output)
+
+	// Verify that Go types were converted to PostgreSQL types
+	if strings.Contains(output, "string") {
+		t.Errorf("Output contains 'string' type - should be converted to 'text'\nFull output:\n%s", output)
+	}
+	if strings.Contains(output, "int64") {
+		t.Errorf("Output contains 'int64' type - should be converted to 'bigint'\nFull output:\n%s", output)
+	}
+	if strings.Contains(output, "int16") {
+		t.Errorf("Output contains 'int16' type - should be converted to 'smallint'\nFull output:\n%s", output)
+	}
+
+	// Verify correct PostgreSQL types are present
+	if !strings.Contains(output, "text") {
+		t.Errorf("Output missing 'text' type (converted from 'string')\nFull output:\n%s", output)
+	}
+	if !strings.Contains(output, "bigint") {
+		t.Errorf("Output missing 'bigint' type (converted from 'int64')\nFull output:\n%s", output)
+	}
+	if !strings.Contains(output, "smallint") {
+		t.Errorf("Output missing 'smallint' type (converted from 'int16')\nFull output:\n%s", output)
+	}
+}

vendor/modules.txt

@@ -1,6 +1,92 @@
+# 4d63.com/gocheckcompilerdirectives v1.3.0
+## explicit; go 1.22.0
+# 4d63.com/gochecknoglobals v0.2.2
+## explicit; go 1.18
+# github.com/4meepo/tagalign v1.4.2
+## explicit; go 1.22.0
+# github.com/Abirdcfly/dupword v0.1.3
+## explicit; go 1.22.0
+# github.com/Antonboom/errname v1.0.0
+## explicit; go 1.22.1
+# github.com/Antonboom/nilnil v1.0.1
+## explicit; go 1.22.0
+# github.com/Antonboom/testifylint v1.5.2
+## explicit; go 1.22.1
+# github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c
+## explicit; go 1.18
+# github.com/Crocmagnon/fatcontext v0.7.1
+## explicit; go 1.22.0
+# github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24
+## explicit; go 1.13
+# github.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.1
+## explicit; go 1.23.0
+# github.com/Masterminds/semver/v3 v3.3.0
+## explicit; go 1.21
+# github.com/OpenPeeDeeP/depguard/v2 v2.2.1
+## explicit; go 1.23.0
+# github.com/alecthomas/go-check-sumtype v0.3.1
+## explicit; go 1.22.0
+# github.com/alexkohler/nakedret/v2 v2.0.5
+## explicit; go 1.21
+# github.com/alexkohler/prealloc v1.0.0
+## explicit; go 1.15
+# github.com/alingse/asasalint v0.0.11
+## explicit; go 1.18
+# github.com/alingse/nilnesserr v0.1.2
+## explicit; go 1.22.0
+# github.com/ashanbrown/forbidigo v1.6.0
+## explicit; go 1.13
+# github.com/ashanbrown/makezero v1.2.0
+## explicit; go 1.12
+# github.com/beorn7/perks v1.0.1
+## explicit; go 1.11
+# github.com/bkielbasa/cyclop v1.2.3
+## explicit; go 1.22.0
+# github.com/blizzy78/varnamelen v0.8.0
+## explicit; go 1.16
+# github.com/bombsimon/wsl/v4 v4.5.0
+## explicit; go 1.22
+# github.com/breml/bidichk v0.3.2
+## explicit; go 1.22.0
+# github.com/breml/errchkjson v0.4.0
+## explicit; go 1.22.0
+# github.com/butuzov/ireturn v0.3.1
+## explicit; go 1.18
+# github.com/butuzov/mirror v1.3.0
+## explicit; go 1.19
+# github.com/catenacyber/perfsprint v0.8.2
+## explicit; go 1.22.0
+# github.com/ccojocar/zxcvbn-go v1.0.2
+## explicit; go 1.20
+# github.com/cespare/xxhash/v2 v2.3.0
+## explicit; go 1.11
+# github.com/charithe/durationcheck v0.0.10
+## explicit; go 1.14
+# github.com/chavacava/garif v0.1.0
+## explicit; go 1.16
+# github.com/ckaznocha/intrange v0.3.0
+## explicit; go 1.22
+# github.com/curioswitch/go-reassign v0.3.0
+## explicit; go 1.21
+# github.com/daixiang0/gci v0.13.5
+## explicit; go 1.21
 # github.com/davecgh/go-spew v1.1.1
 ## explicit
 github.com/davecgh/go-spew/spew
+# github.com/denis-tingaikin/go-header v0.5.0
+## explicit; go 1.21
+# github.com/ettle/strcase v0.2.0
+## explicit; go 1.12
+# github.com/fatih/color v1.18.0
+## explicit; go 1.17
+# github.com/fatih/structtag v1.2.0
+## explicit; go 1.12
+# github.com/firefart/nonamedreturns v1.0.5
+## explicit; go 1.18
+# github.com/fsnotify/fsnotify v1.5.4
+## explicit; go 1.16
+# github.com/fzipp/gocyclo v0.6.0
+## explicit; go 1.18
 # github.com/gdamore/encoding v1.0.1
 ## explicit; go 1.9
 github.com/gdamore/encoding
@@ -44,9 +130,75 @@ github.com/gdamore/tcell/v2/terminfo/x/xfce
 github.com/gdamore/tcell/v2/terminfo/x/xterm
 github.com/gdamore/tcell/v2/terminfo/x/xterm_ghostty
 github.com/gdamore/tcell/v2/terminfo/x/xterm_kitty
+# github.com/ghostiam/protogetter v0.3.9
+## explicit; go 1.22.0
+# github.com/go-critic/go-critic v0.12.0
+## explicit; go 1.22.0
+# github.com/go-toolsmith/astcast v1.1.0
+## explicit; go 1.16
+# github.com/go-toolsmith/astcopy v1.1.0
+## explicit; go 1.16
+# github.com/go-toolsmith/astequal v1.2.0
+## explicit; go 1.18
+# github.com/go-toolsmith/astfmt v1.1.0
+## explicit; go 1.16
+# github.com/go-toolsmith/astp v1.1.0
+## explicit; go 1.16
+# github.com/go-toolsmith/strparse v1.1.0
+## explicit; go 1.16
+# github.com/go-toolsmith/typep v1.1.0
+## explicit; go 1.16
+# github.com/go-viper/mapstructure/v2 v2.2.1
+## explicit; go 1.18
+# github.com/go-xmlfmt/xmlfmt v1.1.3
+## explicit
+# github.com/gobwas/glob v0.2.3
+## explicit
+# github.com/gofrs/flock v0.12.1
+## explicit; go 1.21.0
+# github.com/golang/protobuf v1.5.3
+## explicit; go 1.9
+# github.com/golangci/dupl v0.0.0-20250308024227-f665c8d69b32
+## explicit; go 1.22.0
+# github.com/golangci/go-printf-func-name v0.1.0
+## explicit; go 1.22.0
+# github.com/golangci/gofmt v0.0.0-20250106114630-d62b90e6713d
+## explicit; go 1.22.0
+# github.com/golangci/golangci-lint v1.64.8
+## explicit; go 1.23.0
+# github.com/golangci/misspell v0.6.0
+## explicit; go 1.21
+# github.com/golangci/plugin-module-register v0.1.1
+## explicit; go 1.21
+# github.com/golangci/revgrep v0.8.0
+## explicit; go 1.21
+# github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed
+## explicit; go 1.20
+# github.com/google/go-cmp v0.7.0
+## explicit; go 1.21
 # github.com/google/uuid v1.6.0
 ## explicit
 github.com/google/uuid
+# github.com/gordonklaus/ineffassign v0.1.0
+## explicit; go 1.14
+# github.com/gostaticanalysis/analysisutil v0.7.1
+## explicit; go 1.16
+# github.com/gostaticanalysis/comment v1.5.0
+## explicit; go 1.22.9
+# github.com/gostaticanalysis/forcetypeassert v0.2.0
+## explicit; go 1.23.0
+# github.com/gostaticanalysis/nilerr v0.1.1
+## explicit; go 1.15
+# github.com/hashicorp/go-immutable-radix/v2 v2.1.0
+## explicit; go 1.18
+# github.com/hashicorp/go-version v1.7.0
+## explicit
+# github.com/hashicorp/golang-lru/v2 v2.0.7
+## explicit; go 1.18
+# github.com/hashicorp/hcl v1.0.0
+## explicit
+# github.com/hexops/gotextdiff v1.0.3
+## explicit; go 1.16
 # github.com/inconshreveable/mousetrap v1.1.0
 ## explicit; go 1.18
 github.com/inconshreveable/mousetrap
@@ -68,23 +220,115 @@ github.com/jackc/pgx/v5/pgconn/ctxwatch
 github.com/jackc/pgx/v5/pgconn/internal/bgreader
 github.com/jackc/pgx/v5/pgproto3
 github.com/jackc/pgx/v5/pgtype
+# github.com/jgautheron/goconst v1.7.1
+## explicit; go 1.13
+# github.com/jingyugao/rowserrcheck v1.1.1
+## explicit; go 1.13
 # github.com/jinzhu/inflection v1.0.0
 ## explicit
 github.com/jinzhu/inflection
+# github.com/jjti/go-spancheck v0.6.4
+## explicit; go 1.22.1
+# github.com/julz/importas v0.2.0
+## explicit; go 1.20
+# github.com/karamaru-alpha/copyloopvar v1.2.1
+## explicit; go 1.21
+# github.com/kisielk/errcheck v1.9.0
+## explicit; go 1.22.0
+# github.com/kkHAIKE/contextcheck v1.1.6
+## explicit; go 1.23.0
 # github.com/kr/pretty v0.3.1
 ## explicit; go 1.12
+# github.com/kulti/thelper v0.6.3
+## explicit; go 1.18
+# github.com/kunwardeep/paralleltest v1.0.10
+## explicit; go 1.17
+# github.com/lasiar/canonicalheader v1.1.2
+## explicit; go 1.22.0
+# github.com/ldez/exptostd v0.4.2
+## explicit; go 1.22.0
+# github.com/ldez/gomoddirectives v0.6.1
+## explicit; go 1.22.0
+# github.com/ldez/grignotin v0.9.0
+## explicit; go 1.22.0
+# github.com/ldez/tagliatelle v0.7.1
+## explicit; go 1.22.0
+# github.com/ldez/usetesting v0.4.2
+## explicit; go 1.22.0
+# github.com/leonklingele/grouper v1.1.2
+## explicit; go 1.18
 # github.com/lucasb-eyer/go-colorful v1.2.0
 ## explicit; go 1.12
 github.com/lucasb-eyer/go-colorful
+# github.com/macabu/inamedparam v0.1.3
+## explicit; go 1.20
+# github.com/magiconair/properties v1.8.6
+## explicit; go 1.13
+# github.com/maratori/testableexamples v1.0.0
+## explicit; go 1.19
+# github.com/maratori/testpackage v1.1.1
+## explicit; go 1.20
+# github.com/matoous/godox v1.1.0
+## explicit; go 1.18
+# github.com/mattn/go-colorable v0.1.14
+## explicit; go 1.18
+# github.com/mattn/go-isatty v0.0.20
+## explicit; go 1.15
 # github.com/mattn/go-runewidth v0.0.16
 ## explicit; go 1.9
 github.com/mattn/go-runewidth
+# github.com/matttproud/golang_protobuf_extensions v1.0.1
+## explicit
+# github.com/mgechev/revive v1.7.0
+## explicit; go 1.22.1
+# github.com/mitchellh/go-homedir v1.1.0
+## explicit
+# github.com/mitchellh/mapstructure v1.5.0
+## explicit; go 1.14
+# github.com/moricho/tparallel v0.3.2
+## explicit; go 1.20
+# github.com/nakabonne/nestif v0.3.1
+## explicit; go 1.15
+# github.com/nishanths/exhaustive v0.12.0
+## explicit; go 1.18
+# github.com/nishanths/predeclared v0.2.2
+## explicit; go 1.14
+# github.com/nunnatsa/ginkgolinter v0.19.1
+## explicit; go 1.23.0
+# github.com/olekukonko/tablewriter v0.0.5
+## explicit; go 1.12
+# github.com/pelletier/go-toml v1.9.5
+## explicit; go 1.12
+# github.com/pelletier/go-toml/v2 v2.2.3
+## explicit; go 1.21.0
 # github.com/pmezard/go-difflib v1.0.0
 ## explicit
 github.com/pmezard/go-difflib/difflib
+# github.com/polyfloyd/go-errorlint v1.7.1
+## explicit; go 1.22.0
+# github.com/prometheus/client_golang v1.12.1
+## explicit; go 1.13
+# github.com/prometheus/client_model v0.2.0
+## explicit; go 1.9
+# github.com/prometheus/common v0.32.1
+## explicit; go 1.13
+# github.com/prometheus/procfs v0.7.3
+## explicit; go 1.13
 # github.com/puzpuzpuz/xsync/v3 v3.5.1
 ## explicit; go 1.18
 github.com/puzpuzpuz/xsync/v3
+# github.com/quasilyte/go-ruleguard v0.4.3-0.20240823090925-0fe6f58b47b1
+## explicit; go 1.19
+# github.com/quasilyte/go-ruleguard/dsl v0.3.22
+## explicit; go 1.15
+# github.com/quasilyte/gogrep v0.5.0
+## explicit; go 1.16
+# github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727
+## explicit; go 1.14
+# github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567
+## explicit; go 1.17
+# github.com/raeperd/recvcheck v0.2.0
+## explicit; go 1.22.0
 # github.com/rivo/tview v0.42.0
 ## explicit; go 1.18
 github.com/rivo/tview
@@ -93,20 +337,76 @@ github.com/rivo/tview
 github.com/rivo/uniseg
 # github.com/rogpeppe/go-internal v1.14.1
 ## explicit; go 1.23
+# github.com/ryancurrah/gomodguard v1.3.5
+## explicit; go 1.22.0
+# github.com/ryanrolds/sqlclosecheck v0.5.1
+## explicit; go 1.20
+# github.com/sanposhiho/wastedassign/v2 v2.1.0
+## explicit; go 1.18
+# github.com/santhosh-tekuri/jsonschema/v6 v6.0.1
+## explicit; go 1.21
+# github.com/sashamelentyev/interfacebloat v1.1.0
+## explicit; go 1.18
+# github.com/sashamelentyev/usestdlibvars v1.28.0
+## explicit; go 1.20
+# github.com/securego/gosec/v2 v2.22.2
+## explicit; go 1.23.0
+# github.com/sirupsen/logrus v1.9.3
+## explicit; go 1.13
+# github.com/sivchari/containedctx v1.0.3
+## explicit; go 1.17
+# github.com/sivchari/tenv v1.12.1
+## explicit; go 1.22.0
+# github.com/sonatard/noctx v0.1.0
+## explicit; go 1.22.0
+# github.com/sourcegraph/go-diff v0.7.0
+## explicit; go 1.14
+# github.com/spf13/afero v1.12.0
+## explicit; go 1.21
+# github.com/spf13/cast v1.5.0
+## explicit; go 1.18
 # github.com/spf13/cobra v1.10.2
 ## explicit; go 1.15
 github.com/spf13/cobra
+# github.com/spf13/jwalterweatherman v1.1.0
+## explicit
 # github.com/spf13/pflag v1.0.10
 ## explicit; go 1.12
 github.com/spf13/pflag
+# github.com/spf13/viper v1.12.0
+## explicit; go 1.17
+# github.com/ssgreg/nlreturn/v2 v2.2.1
+## explicit; go 1.13
+# github.com/stbenjam/no-sprintf-host-port v0.2.0
+## explicit; go 1.18
+# github.com/stretchr/objx v0.5.2
+## explicit; go 1.20
 # github.com/stretchr/testify v1.11.1
 ## explicit; go 1.17
 github.com/stretchr/testify/assert
 github.com/stretchr/testify/assert/yaml
 github.com/stretchr/testify/require
+# github.com/subosito/gotenv v1.4.1
+## explicit; go 1.18
+# github.com/tdakkota/asciicheck v0.4.1
+## explicit; go 1.22.0
+# github.com/tetafro/godot v1.5.0
+## explicit; go 1.20
+# github.com/timakin/bodyclose v0.0.0-20241017074812-ed6a65f985e3
+## explicit; go 1.12
+# github.com/timonwong/loggercheck v0.10.1
+## explicit; go 1.22.0
 # github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc
 ## explicit
 github.com/tmthrgd/go-hex
+# github.com/tomarrell/wrapcheck/v2 v2.10.0
+## explicit; go 1.21
+# github.com/tommy-muehle/go-mnd/v2 v2.5.1
+## explicit; go 1.12
+# github.com/ultraware/funlen v0.2.0
+## explicit; go 1.22.0
+# github.com/ultraware/whitespace v0.2.0
+## explicit; go 1.20
 # github.com/uptrace/bun v1.2.16
 ## explicit; go 1.24.0
 github.com/uptrace/bun
@@ -118,6 +418,10 @@ github.com/uptrace/bun/internal
 github.com/uptrace/bun/internal/parser
 github.com/uptrace/bun/internal/tagparser
 github.com/uptrace/bun/schema
+# github.com/uudashr/gocognit v1.2.0
+## explicit; go 1.19
+# github.com/uudashr/iface v1.3.1
+## explicit; go 1.22.1
 # github.com/vmihailenco/msgpack/v5 v5.4.1
 ## explicit; go 1.19
 github.com/vmihailenco/msgpack/v5
@@ -127,9 +431,37 @@ github.com/vmihailenco/msgpack/v5/msgpcode
 github.com/vmihailenco/tagparser/v2
 github.com/vmihailenco/tagparser/v2/internal
 github.com/vmihailenco/tagparser/v2/internal/parser
+# github.com/xen0n/gosmopolitan v1.2.2
+## explicit; go 1.19
+# github.com/yagipy/maintidx v1.0.0
+## explicit; go 1.17
+# github.com/yeya24/promlinter v0.3.0
+## explicit; go 1.20
+# github.com/ykadowak/zerologlint v0.1.5
+## explicit; go 1.19
+# gitlab.com/bosi/decorder v0.4.2
+## explicit; go 1.20
+# go-simpler.org/musttag v0.13.0
+## explicit; go 1.20
+# go-simpler.org/sloglint v0.9.0
+## explicit; go 1.22.0
+# go.uber.org/atomic v1.7.0
+## explicit; go 1.13
+# go.uber.org/automaxprocs v1.6.0
+## explicit; go 1.20
+# go.uber.org/multierr v1.6.0
+## explicit; go 1.12
+# go.uber.org/zap v1.24.0
+## explicit; go 1.19
 # golang.org/x/crypto v0.41.0
 ## explicit; go 1.23.0
 golang.org/x/crypto/pbkdf2
+# golang.org/x/exp/typeparams v0.0.0-20250210185358-939b2ce775ac
+## explicit; go 1.18
+# golang.org/x/mod v0.26.0
+## explicit; go 1.23.0
+# golang.org/x/sync v0.16.0
+## explicit; go 1.23.0
 # golang.org/x/sys v0.38.0
 ## explicit; go 1.24.0
 golang.org/x/sys/cpu
@@ -156,6 +488,20 @@ golang.org/x/text/transform
 golang.org/x/text/unicode/bidi
 golang.org/x/text/unicode/norm
 golang.org/x/text/width
+# golang.org/x/tools v0.35.0
+## explicit; go 1.23.0
+# google.golang.org/protobuf v1.36.5
+## explicit; go 1.21
+# gopkg.in/ini.v1 v1.67.0
+## explicit
+# gopkg.in/yaml.v2 v2.4.0
+## explicit; go 1.15
 # gopkg.in/yaml.v3 v3.0.1
 ## explicit
 gopkg.in/yaml.v3
+# honnef.co/go/tools v0.6.1
+## explicit; go 1.23
+# mvdan.cc/gofumpt v0.7.0
+## explicit; go 1.22
+# mvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f
+## explicit; go 1.21