feat: --schema flag & auto-format detection

Author: radim

cmd/snapshot.go

@@ -21,6 +21,7 @@ var (
 	snapshotInput         string
 	snapshotClean         bool
 	snapshotBuildFixtures []string
+	snapshotBuildSchema   string
 	snapshotBuildVerbose  bool
 
 	snapshotCmd = &cobra.Command{
@@ -88,6 +89,7 @@ Examples:
 Examples:
   regresql snapshot build
   regresql snapshot build --fixtures users,products,orders
+  regresql snapshot build --schema schema.sql --fixtures seed_data
   regresql snapshot build --output snapshots/test_data.dump --verbose`,
 		Run: func(cmd *cobra.Command, args []string) {
 			if err := checkDirectory(snapshotCwd); err != nil {
@@ -145,6 +147,7 @@ func init() {
 
 	snapshotBuildCmd.Flags().StringVarP(&snapshotOutput, "output", "o", "", "Output file path")
 	snapshotBuildCmd.Flags().StringVarP(&snapshotFormat, "format", "f", "", "Dump format: custom, plain, or directory")
+	snapshotBuildCmd.Flags().StringVar(&snapshotBuildSchema, "schema", "", "Schema SQL file to apply before fixtures")
 	snapshotBuildCmd.Flags().StringSliceVar(&snapshotBuildFixtures, "fixtures", nil, "Fixture names to apply")
 	snapshotBuildCmd.Flags().BoolVarP(&snapshotBuildVerbose, "verbose", "v", false, "Print detailed progress")
 }
@@ -376,17 +379,32 @@ func runSnapshotBuild() error {
 		return fmt.Errorf("pguri not configured in regress.yaml")
 	}
 
+	// Resolve and validate schema path
+	var schemaPath string
+	if snapshotBuildSchema != "" {
+		schemaPath = snapshotBuildSchema
+		if !filepath.IsAbs(schemaPath) {
+			schemaPath = filepath.Join(snapshotCwd, schemaPath)
+		}
+		if _, err := os.Stat(schemaPath); err != nil {
+			return fmt.Errorf("schema file not found: %s", schemaPath)
+		}
+	}
+
 	fixtures := snapshotBuildFixtures
 	if len(fixtures) == 0 {
 		fixtures = regresql.GetSnapshotFixtures(cfg.Snapshot)
 	}
 
-	if len(fixtures) == 0 {
+	// Allow build with just schema (no fixtures)
+	if len(fixtures) == 0 && schemaPath == "" {
 		return fmt.Errorf("no fixtures specified. Use --fixtures flag or configure snapshot.fixtures in regress.yaml")
 	}
 
-	if err := regresql.FixturesExist(snapshotCwd, fixtures); err != nil {
-		return err
+	if len(fixtures) > 0 {
+		if err := regresql.FixturesExist(snapshotCwd, fixtures); err != nil {
+			return err
+		}
 	}
 
 	outputPath := snapshotOutput
@@ -407,12 +425,18 @@ func runSnapshotBuild() error {
 	fmt.Printf("  Database: %s\n", maskConnectionString(cfg.PgUri))
 	fmt.Printf("  Output:   %s\n", outputPath)
 	fmt.Printf("  Format:   %s\n", format)
-	fmt.Printf("  Fixtures: %v\n", fixtures)
+	if schemaPath != "" {
+		fmt.Printf("  Schema:   %s\n", schemaPath)
+	}
+	if len(fixtures) > 0 {
+		fmt.Printf("  Fixtures: %v\n", fixtures)
+	}
 	fmt.Println()
 
 	result, err := regresql.BuildSnapshot(cfg.PgUri, snapshotCwd, regresql.SnapshotBuildOptions{
 		OutputPath: outputPath,
 		Format:     format,
+		SchemaPath: schemaPath,
 		Fixtures:   fixtures,
 		Verbose:    snapshotBuildVerbose,
 	})
@@ -429,7 +453,12 @@ func runSnapshotBuild() error {
 	fmt.Printf("  Size:     %s\n", regresql.FormatBytes(result.Info.SizeBytes))
 	fmt.Printf("  Hash:     %s\n", result.Info.Hash)
 	fmt.Printf("  Duration: %s\n", result.Duration.Round(time.Millisecond))
-	fmt.Printf("  Fixtures: %d applied\n", len(result.FixturesUsed))
+	if result.Info.SchemaHash != "" {
+		fmt.Printf("  Schema:   %s\n", result.Info.SchemaHash[:20]+"...")
+	}
+	if len(result.FixturesUsed) > 0 {
+		fmt.Printf("  Fixtures: %d applied\n", len(result.FixturesUsed))
+	}
 
 	return nil
 }
@@ -454,6 +483,13 @@ func runSnapshotInfo() error {
 	fmt.Printf("  Created: %s\n", info.Created.Format("2006-01-02 15:04:05 UTC"))
 	fmt.Printf("  Hash:    %s\n", info.Hash)
 
+	if info.SchemaPath != "" {
+		fmt.Println()
+		fmt.Println("Schema:")
+		fmt.Printf("  Path: %s\n", info.SchemaPath)
+		fmt.Printf("  Hash: %s\n", info.SchemaHash)
+	}
+
 	if len(info.FixturesUsed) > 0 {
 		fmt.Println()
 		fmt.Println("Fixtures used:")

regresql/snapshot.go

@@ -25,6 +25,8 @@ type (
 		Created      time.Time `yaml:"created"`
 		SizeBytes    int64     `yaml:"size_bytes"`
 		Format       string    `yaml:"format"`
+		SchemaPath   string    `yaml:"schema_path,omitempty"`
+		SchemaHash   string    `yaml:"schema_hash,omitempty"`
 		FixturesUsed []string  `yaml:"fixtures_used,omitempty"`
 	}
 

regresql/snapshot_build.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
@@ -13,6 +14,7 @@ type (
 	SnapshotBuildOptions struct {
 		OutputPath string
 		Format     SnapshotFormat
+		SchemaPath string
 		Fixtures   []string
 		Verbose    bool
 	}
@@ -31,8 +33,15 @@ func BuildSnapshot(basePgUri string, root string, opts SnapshotBuildOptions) (*s
 		return nil, err
 	}
 
-	if len(opts.Fixtures) == 0 {
-		return nil, fmt.Errorf("no fixtures specified for snapshot build")
+	// Check pg_restore is available for non-plain schema files
+	if opts.SchemaPath != "" && DetectSnapshotFormat(opts.SchemaPath) != FormatPlain {
+		if err := CheckPgTool("pg_restore", root); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(opts.Fixtures) == 0 && opts.SchemaPath == "" {
+		return nil, fmt.Errorf("no schema or fixtures specified for snapshot build")
 	}
 
 	if opts.Verbose {
@@ -62,17 +71,34 @@ func BuildSnapshot(basePgUri string, root string, opts SnapshotBuildOptions) (*s
 	}
 	defer db.Close()
 
-	if opts.Verbose {
-		fmt.Printf("Applying %d fixture(s)...\n", len(opts.Fixtures))
+	// Apply schema first if provided
+	var schemaHash string
+	if opts.SchemaPath != "" {
+		if opts.Verbose {
+			format := DetectSnapshotFormat(opts.SchemaPath)
+			fmt.Printf("Applying schema: %s (format: %s)\n", opts.SchemaPath, format)
+		}
+		if err := applySchemaFile(tempDB.PgUri, opts.SchemaPath); err != nil {
+			return nil, fmt.Errorf("schema %q: %w", opts.SchemaPath, err)
+		}
+		schemaHash, err = computeSchemaHash(opts.SchemaPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to compute schema hash: %w", err)
+		}
 	}
 
-	fixturesUsed, err := applyFixtures(db, root, opts.Fixtures, opts.Verbose)
-	if err != nil {
-		return nil, err
+	var fixturesUsed []string
+	if len(opts.Fixtures) > 0 {
+		if opts.Verbose {
+			fmt.Printf("Applying %d fixture(s)...\n", len(opts.Fixtures))
+		}
+		fixturesUsed, err = applyFixtures(db, root, opts.Fixtures, opts.Verbose)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if opts.Verbose {
-		fmt.Printf("Fixtures applied successfully\n")
 		fmt.Printf("Capturing snapshot with pg_dump...\n")
 	}
 
@@ -84,6 +110,8 @@ func BuildSnapshot(basePgUri string, root string, opts SnapshotBuildOptions) (*s
 		return nil, fmt.Errorf("failed to capture snapshot: %w", err)
 	}
 
+	info.SchemaPath = opts.SchemaPath
+	info.SchemaHash = schemaHash
 	info.FixturesUsed = fixturesUsed
 
 	return &snapshotBuildResult{
@@ -153,6 +181,43 @@ func execSQLFile(db *sql.DB, path string) error {
 	return nil
 }
 
+func computeSchemaHash(schemaPath string) (string, error) {
+	format := DetectSnapshotFormat(schemaPath)
+	return computeFileHash(schemaPath, format)
+}
+
+func applySchemaFile(pguri, schemaPath string) error {
+	format := DetectSnapshotFormat(schemaPath)
+
+	if format == FormatPlain {
+		db, err := OpenDB(pguri)
+		if err != nil {
+			return err
+		}
+		defer db.Close()
+		return execSQLFile(db, schemaPath)
+	}
+
+	// Custom or Directory format - use pg_restore --schema-only
+	args := []string{
+		"--dbname", pguri,
+		"--schema-only",
+		"--no-owner",
+		"--no-acl",
+	}
+	if format == FormatDirectory {
+		args = append(args, "--format=directory")
+	}
+	args = append(args, schemaPath)
+
+	cmd := exec.Command("pg_restore", args...)
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("pg_restore failed: %w", err)
+	}
+	return nil
+}
+
 func isSQLFixture(name string) bool {
 	return strings.HasSuffix(strings.ToLower(name), ".sql")
 }