feat: added support for local SQL migration

- only .sql files detected (with exception of .down.sql)
- WARNING: it will apply full sql files (i.e. does not differentiate
  between up/down sections)
- support for external migration command coming soon

Author: radim

cmd/snapshot.go

@@ -20,9 +20,10 @@ var (
 	snapshotSections      bool
 	snapshotInput         string
 	snapshotClean         bool
-	snapshotBuildFixtures []string
-	snapshotBuildSchema   string
-	snapshotBuildVerbose  bool
+	snapshotBuildFixtures   []string
+	snapshotBuildSchema     string
+	snapshotBuildMigrations string
+	snapshotBuildVerbose    bool
 
 	snapshotCmd = &cobra.Command{
 		Use:   "snapshot",
@@ -147,7 +148,8 @@ 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().StringVar(&snapshotBuildSchema, "schema", "", "Schema file to apply before migrations")
+	snapshotBuildCmd.Flags().StringVar(&snapshotBuildMigrations, "migrations", "", "Directory of SQL migrations to apply")
 	snapshotBuildCmd.Flags().StringSliceVar(&snapshotBuildFixtures, "fixtures", nil, "Fixture names to apply")
 	snapshotBuildCmd.Flags().BoolVarP(&snapshotBuildVerbose, "verbose", "v", false, "Print detailed progress")
 }
@@ -393,14 +395,27 @@ func runSnapshotBuild() error {
 		}
 	}
 
+	migrationsDir := snapshotBuildMigrations
+	if migrationsDir == "" {
+		migrationsDir = regresql.GetSnapshotMigrations(cfg.Snapshot)
+	}
+	if migrationsDir != "" {
+		if !filepath.IsAbs(migrationsDir) {
+			migrationsDir = filepath.Join(snapshotCwd, migrationsDir)
+		}
+		if stat, err := os.Stat(migrationsDir); err != nil || !stat.IsDir() {
+			return fmt.Errorf("migrations directory not found: %s", migrationsDir)
+		}
+	}
+
 	fixtures := snapshotBuildFixtures
 	if len(fixtures) == 0 {
 		fixtures = regresql.GetSnapshotFixtures(cfg.Snapshot)
 	}
 
-	// Require at least schema or fixtures
-	if len(fixtures) == 0 && schemaPath == "" {
-		return fmt.Errorf("no schema or fixtures specified. Use --schema/--fixtures flags or configure snapshot.schema/snapshot.fixtures in regress.yaml")
+	// Require at least schema, migrations, or fixtures
+	if len(fixtures) == 0 && schemaPath == "" && migrationsDir == "" {
+		return fmt.Errorf("no schema, migrations, or fixtures specified. Use flags or configure in regress.yaml")
 	}
 
 	if len(fixtures) > 0 {
@@ -423,24 +438,28 @@ func runSnapshotBuild() error {
 		format = regresql.GetSnapshotFormat(cfg.Snapshot)
 	}
 
-	fmt.Printf("Building snapshot from fixtures...\n")
+	fmt.Printf("Building snapshot...\n")
 	fmt.Printf("  Database: %s\n", maskConnectionString(cfg.PgUri))
 	fmt.Printf("  Output:   %s\n", outputPath)
 	fmt.Printf("  Format:   %s\n", format)
 	if schemaPath != "" {
 		fmt.Printf("  Schema:   %s\n", schemaPath)
 	}
+	if migrationsDir != "" {
+		fmt.Printf("  Migrations: %s\n", migrationsDir)
+	}
 	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,
+		OutputPath:    outputPath,
+		Format:        format,
+		SchemaPath:    schemaPath,
+		MigrationsDir: migrationsDir,
+		Fixtures:      fixtures,
+		Verbose:       snapshotBuildVerbose,
 	})
 	if err != nil {
 		return err
@@ -458,6 +477,9 @@ func runSnapshotBuild() error {
 	if result.Info.SchemaHash != "" {
 		fmt.Printf("  Schema:   %s\n", result.Info.SchemaHash[:20]+"...")
 	}
+	if len(result.Info.MigrationsApplied) > 0 {
+		fmt.Printf("  Migrations: %d applied\n", len(result.Info.MigrationsApplied))
+	}
 	if len(result.FixturesUsed) > 0 {
 		fmt.Printf("  Fixtures: %d applied\n", len(result.FixturesUsed))
 	}
@@ -492,6 +514,19 @@ func runSnapshotInfo() error {
 		fmt.Printf("  Hash: %s\n", info.SchemaHash)
 	}
 
+	if info.MigrationsDir != "" {
+		fmt.Println()
+		fmt.Println("Migrations:")
+		fmt.Printf("  Dir:  %s\n", info.MigrationsDir)
+		fmt.Printf("  Hash: %s\n", info.MigrationsHash)
+		if len(info.MigrationsApplied) > 0 {
+			fmt.Println("  Applied:")
+			for _, m := range info.MigrationsApplied {
+				fmt.Printf("    - %s\n", m)
+			}
+		}
+	}
+
 	if len(info.FixturesUsed) > 0 {
 		fmt.Println()
 		fmt.Println("Fixtures used:")

regresql/config.go

@@ -28,10 +28,11 @@ type (
 	}
 
 	SnapshotConfig struct {
-		Path     string   `yaml:"path,omitempty"`     // snapshot dump file path (default: snapshots/default.dump)
-		Format   string   `yaml:"format,omitempty"`   // pg_dump format: custom, plain, or directory
-		Schema   string   `yaml:"schema,omitempty"`   // external schema file (SQL, dump, or directory)
-		Fixtures []string `yaml:"fixtures,omitempty"` // SQL/YAML fixture files for snapshot build
+		Path       string   `yaml:"path,omitempty"`       // snapshot dump file path (default: snapshots/default.dump)
+		Format     string   `yaml:"format,omitempty"`     // pg_dump format: custom, plain, or directory
+		Schema     string   `yaml:"schema,omitempty"`     // external schema file (SQL, dump, or directory)
+		Migrations string   `yaml:"migrations,omitempty"` // directory of SQL migrations to apply
+		Fixtures   []string `yaml:"fixtures,omitempty"`   // SQL/YAML fixture files for snapshot build
 	}
 )
 

regresql/snapshot.go

@@ -20,14 +20,17 @@ type (
 	}
 
 	SnapshotInfo struct {
-		Path         string    `yaml:"path"`
-		Hash         string    `yaml:"hash"`
-		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"`
+		Path              string    `yaml:"path"`
+		Hash              string    `yaml:"hash"`
+		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"`
+		MigrationsDir     string    `yaml:"migrations_dir,omitempty"`
+		MigrationsHash    string    `yaml:"migrations_hash,omitempty"`
+		MigrationsApplied []string  `yaml:"migrations_applied,omitempty"`
+		FixturesUsed      []string  `yaml:"fixtures_used,omitempty"`
 	}
 
 	SnapshotFormat string

regresql/snapshot_build.go

@@ -1,22 +1,26 @@
 package regresql
 
 import (
+	"crypto/sha256"
 	"database/sql"
+	"encoding/hex"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 )
 
 type (
 	SnapshotBuildOptions struct {
-		OutputPath string
-		Format     SnapshotFormat
-		SchemaPath string
-		Fixtures   []string
-		Verbose    bool
+		OutputPath    string
+		Format        SnapshotFormat
+		SchemaPath    string
+		MigrationsDir string
+		Fixtures      []string
+		Verbose       bool
 	}
 
 	snapshotBuildResult struct {
@@ -87,6 +91,34 @@ func BuildSnapshot(basePgUri string, root string, opts SnapshotBuildOptions) (*s
 		}
 	}
 
+	// Apply migrations if provided
+	var migrationsApplied []string
+	var migrationsHash string
+	if opts.MigrationsDir != "" {
+		migrationFiles, err := discoverMigrations(opts.MigrationsDir)
+		if err != nil {
+			return nil, fmt.Errorf("failed to discover migrations: %w", err)
+		}
+
+		if len(migrationFiles) > 0 {
+			if opts.Verbose {
+				fmt.Printf("Applying %d migration(s)...\n", len(migrationFiles))
+			}
+			if err := applyMigrations(db, migrationFiles, opts.Verbose); err != nil {
+				return nil, err
+			}
+
+			for _, f := range migrationFiles {
+				migrationsApplied = append(migrationsApplied, filepath.Base(f))
+			}
+
+			migrationsHash, err = computeMigrationsHash(migrationFiles)
+			if err != nil {
+				return nil, fmt.Errorf("failed to compute migrations hash: %w", err)
+			}
+		}
+	}
+
 	var fixturesUsed []string
 	if len(opts.Fixtures) > 0 {
 		if opts.Verbose {
@@ -112,6 +144,9 @@ func BuildSnapshot(basePgUri string, root string, opts SnapshotBuildOptions) (*s
 
 	info.SchemaPath = opts.SchemaPath
 	info.SchemaHash = schemaHash
+	info.MigrationsDir = opts.MigrationsDir
+	info.MigrationsHash = migrationsHash
+	info.MigrationsApplied = migrationsApplied
 	info.FixturesUsed = fixturesUsed
 
 	return &snapshotBuildResult{
@@ -237,6 +272,69 @@ func GetSnapshotSchema(cfg *SnapshotConfig) string {
 	return cfg.Schema
 }
 
+func GetSnapshotMigrations(cfg *SnapshotConfig) string {
+	if cfg == nil {
+		return ""
+	}
+	return cfg.Migrations
+}
+
+// discoverMigrations finds *.sql files in directory (skips *.down.sql), sorted by name
+func discoverMigrations(dir string) ([]string, error) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	var files []string
+	for _, e := range entries {
+		if e.IsDir() {
+			continue
+		}
+		name := e.Name()
+		lower := strings.ToLower(name)
+		if !strings.HasSuffix(lower, ".sql") {
+			continue
+		}
+		// Skip .down.sql files (reverse migrations)
+		if strings.HasSuffix(lower, ".down.sql") {
+			continue
+		}
+		files = append(files, filepath.Join(dir, name))
+	}
+	sort.Strings(files) // Lexical sort: 001_init.sql, 002_users.sql, etc.
+	return files, nil
+}
+
+// applyMigrations executes migration files in order
+func applyMigrations(db *sql.DB, files []string, verbose bool) error {
+	for _, f := range files {
+		if verbose {
+			fmt.Printf("  Migration: %s\n", filepath.Base(f))
+		}
+		if err := execSQLFile(db, f); err != nil {
+			return fmt.Errorf("migration %q: %w", filepath.Base(f), err)
+		}
+	}
+	return nil
+}
+
+// computeMigrationsHash computes combined hash of all migration files
+func computeMigrationsHash(files []string) (string, error) {
+	h := sha256.New()
+	for _, f := range files {
+		// Include filename in hash for ordering sensitivity
+		h.Write([]byte(filepath.Base(f)))
+
+		content, err := os.ReadFile(f)
+		if err != nil {
+			return "", err
+		}
+		h.Write(content)
+	}
+	return "sha256:" + hex.EncodeToString(h.Sum(nil)), nil
+}
+
 // FixturesExist validates that all fixture files exist before build.
 func FixturesExist(root string, fixtures []string) error {
 	for _, f := range fixtures {