feat: add custom seed path to config

cmd/db.go

@@ -276,7 +276,7 @@ func init() {
 	pushFlags := dbPushCmd.Flags()
 	pushFlags.BoolVar(&includeAll, "include-all", false, "Include all migrations not found on remote history table.")
 	pushFlags.BoolVar(&includeRoles, "include-roles", false, "Include custom roles from "+utils.CustomRolesPath+".")
-	pushFlags.BoolVar(&includeSeed, "include-seed", false, "Include seed data from "+utils.SeedDataPath+".")
+	pushFlags.BoolVar(&includeSeed, "include-seed", false, "Include seed data from your config.")
 	pushFlags.BoolVar(&dryRun, "dry-run", false, "Print the migrations that would be applied, but don't actually apply them.")
 	pushFlags.String("db-url", "", "Pushes to the database specified by the connection string (must be percent-encoded).")
 	pushFlags.Bool("linked", true, "Pushes to the linked project.")

internal/db/push/push.go

@@ -41,7 +41,7 @@ func Run(ctx context.Context, dryRun, ignoreVersionMismatch bool, includeRoles,
 		fmt.Fprintln(os.Stderr, "Would push these migrations:")
 		fmt.Fprint(os.Stderr, utils.Bold(confirmPushAll(pending)))
 		if includeSeed {
-			fmt.Fprintln(os.Stderr, "Would seed data "+utils.Bold(utils.SeedDataPath)+"...")
+			fmt.Fprintln(os.Stderr, "Would seed data "+utils.Bold(utils.GetSeedsFilepaths())+"...")
 		}
 	} else {
 		msg := fmt.Sprintf("Do you want to push these migrations to the remote database?\n%s\n", confirmPushAll(pending))

internal/db/push/push_test.go

@@ -162,7 +162,8 @@ func TestPushAll(t *testing.T) {
 
 	t.Run("throws error on seed failure", func(t *testing.T) {
 		// Setup in-memory fs
-		fsys := &fstest.OpenErrorFs{DenyPath: utils.SeedDataPath}
+		fsys := &fstest.OpenErrorFs{DenyPath: utils.DefaultSeedDataPath}
+		_, _ = fsys.Create(utils.DefaultSeedDataPath)
 		path := filepath.Join(utils.MigrationsDir, "0_test.sql")
 		require.NoError(t, afero.WriteFile(fsys, path, []byte{}, 0644))
 		// Setup mock postgres

internal/db/reset/reset_test.go

@@ -362,7 +362,7 @@ func TestResetRemote(t *testing.T) {
 		fsys := afero.NewMemMapFs()
 		path := filepath.Join(utils.MigrationsDir, "0_schema.sql")
 		require.NoError(t, afero.WriteFile(fsys, path, nil, 0644))
-		seedPath := filepath.Join(utils.SeedDataPath)
+		seedPath := filepath.Join(utils.DefaultSeedDataPath)
 		// Will raise an error when seeding
 		require.NoError(t, afero.WriteFile(fsys, seedPath, []byte("INSERT INTO test_table;"), 0644))
 		// Setup mock postgres

internal/db/start/start_test.go

@@ -60,7 +60,7 @@ func TestStartDatabase(t *testing.T) {
 		roles := "create role test"
 		require.NoError(t, afero.WriteFile(fsys, utils.CustomRolesPath, []byte(roles), 0644))
 		seed := "INSERT INTO employees(name) VALUES ('Alice')"
-		require.NoError(t, afero.WriteFile(fsys, utils.SeedDataPath, []byte(seed), 0644))
+		require.NoError(t, afero.WriteFile(fsys, utils.DefaultSeedDataPath, []byte(seed), 0644))
 		// Setup mock docker
 		require.NoError(t, apitest.MockDocker(utils.Docker))
 		defer gock.OffAll()

internal/init/init.go

@@ -78,7 +78,7 @@ func Run(ctx context.Context, fsys afero.Fs, createVscodeSettings, createIntelli
 }
 
 func initSeed(fsys afero.Fs) error {
-	f, err := fsys.OpenFile(utils.SeedDataPath, os.O_WRONLY|os.O_CREATE, 0644)
+	f, err := fsys.OpenFile(utils.DefaultSeedDataPath, os.O_WRONLY|os.O_CREATE, 0644)
 	if err != nil {
 		return errors.Errorf("failed to create seed file: %w", err)
 	}

internal/init/init_test.go

@@ -29,7 +29,7 @@ func TestInitCommand(t *testing.T) {
 		assert.NoError(t, err)
 		assert.True(t, exists)
 		// Validate generated seed.sql
-		exists, err = afero.Exists(fsys, utils.SeedDataPath)
+		exists, err = afero.Exists(fsys, utils.DefaultSeedDataPath)
 		assert.NoError(t, err)
 		assert.True(t, exists)
 		// Validate vscode settings file isn't generated
@@ -72,7 +72,8 @@ func TestInitCommand(t *testing.T) {
 
 	t.Run("throws error on seed failure", func(t *testing.T) {
 		// Setup in-memory fs
-		fsys := &fstest.OpenErrorFs{DenyPath: utils.SeedDataPath}
+		fsys := &fstest.OpenErrorFs{DenyPath: utils.DefaultSeedDataPath}
+		_, _ = fsys.Create(utils.DefaultSeedDataPath)
 		// Run test
 		err := Run(context.Background(), fsys, nil, nil, utils.InitParams{})
 		// Check error

internal/migration/apply/apply.go

@@ -27,11 +27,15 @@ func MigrateAndSeed(ctx context.Context, version string, conn *pgx.Conn, fsys af
 }
 
 func SeedDatabase(ctx context.Context, conn *pgx.Conn, fsys afero.Fs) error {
-	err := migration.SeedData(ctx, []string{utils.SeedDataPath}, conn, afero.NewIOFS(fsys))
-	if errors.Is(err, os.ErrNotExist) {
-		return nil
+	if seedPaths, err := utils.GetSeedFiles(fsys); err != nil {
+		return err
+	} else {
+		err := migration.SeedData(ctx, seedPaths, conn, afero.NewIOFS(fsys))
+		if errors.Is(err, os.ErrNotExist) {
+			return nil
+		}
+		return err
 	}
-	return err
 }
 
 func CreateCustomRoles(ctx context.Context, conn *pgx.Conn, fsys afero.Fs) error {

internal/migration/apply/apply_test.go

@@ -44,7 +44,7 @@ func TestMigrateDatabase(t *testing.T) {
 		path := filepath.Join(utils.MigrationsDir, "0_test.sql")
 		sql := "create schema public"
 		require.NoError(t, afero.WriteFile(fsys, path, []byte(sql), 0644))
-		seedPath := filepath.Join(utils.SeedDataPath)
+		seedPath := filepath.Join(utils.DefaultSeedDataPath)
 		// This will raise an error when seeding
 		require.NoError(t, afero.WriteFile(fsys, seedPath, []byte("INSERT INTO test_table;"), 0644))
 		// Setup mock postgres
@@ -82,7 +82,7 @@ func TestSeedDatabase(t *testing.T) {
 		fsys := afero.NewMemMapFs()
 		// Setup seed file
 		sql := "INSERT INTO employees(name) VALUES ('Alice')"
-		require.NoError(t, afero.WriteFile(fsys, utils.SeedDataPath, []byte(sql), 0644))
+		require.NoError(t, afero.WriteFile(fsys, utils.DefaultSeedDataPath, []byte(sql), 0644))
 		// Setup mock postgres
 		conn := pgtest.NewConn()
 		defer conn.Close(t)
@@ -99,10 +99,15 @@ func TestSeedDatabase(t *testing.T) {
 	})
 
 	t.Run("throws error on read failure", func(t *testing.T) {
-		// Setup in-memory fs
-		fsys := &fstest.OpenErrorFs{DenyPath: utils.SeedDataPath}
+		// Wrap the fs with OpenErrorFs
+		errorFs := &fstest.OpenErrorFs{
+			DenyPath: utils.DefaultSeedDataPath,
+		}
+		_, _ = errorFs.Create(utils.DefaultSeedDataPath)
+
 		// Run test
-		err := SeedDatabase(context.Background(), nil, fsys)
+		err := SeedDatabase(context.Background(), nil, errorFs)
+
 		// Check error
 		assert.ErrorIs(t, err, os.ErrPermission)
 	})
@@ -112,7 +117,7 @@ func TestSeedDatabase(t *testing.T) {
 		fsys := afero.NewMemMapFs()
 		// Setup seed file
 		sql := "INSERT INTO employees(name) VALUES ('Alice')"
-		require.NoError(t, afero.WriteFile(fsys, utils.SeedDataPath, []byte(sql), 0644))
+		require.NoError(t, afero.WriteFile(fsys, utils.DefaultSeedDataPath, []byte(sql), 0644))
 		// Setup mock postgres
 		conn := pgtest.NewConn()
 		defer conn.Close(t)

internal/utils/misc.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"time"
 
 	"github.com/docker/docker/client"
@@ -148,7 +149,7 @@ var (
 	FallbackImportMapPath = filepath.Join(FunctionsDir, "import_map.json")
 	FallbackEnvFilePath   = filepath.Join(FunctionsDir, ".env")
 	DbTestsDir            = filepath.Join(SupabaseDirPath, "tests")
-	SeedDataPath          = filepath.Join(SupabaseDirPath, "seed.sql")
+	DefaultSeedDataPath   = filepath.Join(SupabaseDirPath, "seed.sql")
 	CustomRolesPath       = filepath.Join(SupabaseDirPath, "roles.sql")
 
 	ErrNotLinked   = errors.Errorf("Cannot find project ref. Have you run %s?", Aqua("supabase link"))
@@ -157,6 +158,43 @@ var (
 	ErrNotRunning  = errors.Errorf("%s is not running.", Aqua("supabase start"))
 )
 
+func GetSeedsFilepaths() string {
+	if seedPaths, _ := GetSeedFiles(afero.NewOsFs()); seedPaths != nil {
+		return fmt.Sprintf("%v", seedPaths)
+	}
+	return DefaultSeedDataPath
+}
+
+/*
+** Match the glob patterns from the config to get
+** a deduplicated array of all migrations files to apply
+** in the declared order
+ */
+func GetSeedFiles(fsys afero.Fs) ([]string, error) {
+	seedPaths := Config.Db.Seed.Path
+	fileSet := make(map[string]struct{})
+	var files []string
+	for _, pattern := range seedPaths {
+		fullPattern := filepath.Join(SupabaseDirPath, pattern)
+		matches, err := afero.Glob(fsys, fullPattern)
+		if err != nil {
+			return nil, errors.Errorf("failed to apply glob pattern for %w", err)
+		}
+		sort.Strings(matches)
+		// Dedup the new matches with previously matched seeds to avoid duplication
+		// between matching patterns
+		for _, match := range matches {
+			if _, exists := fileSet[match]; !exists {
+				fileSet[match] = struct{}{}
+				files = append(files, match)
+			} else {
+				fmt.Fprintf(GetDebugLogger(), "Duplicate seed file found skipping: %s\n", match)
+			}
+		}
+	}
+	return files, nil
+}
+
 func GetCurrentTimestamp() string {
 	// Magic number: https://stackoverflow.com/q/45160822.
 	return time.Now().UTC().Format("20060102150405")

internal/utils/misc_test.go

@@ -75,3 +75,76 @@ func TestProjectRoot(t *testing.T) {
 		assert.Equal(t, cwd, path)
 	})
 }
+
+func TestGetSeedFiles(t *testing.T) {
+	t.Run("returns seed files matching patterns", func(t *testing.T) {
+		// Setup in-memory fs
+		fsys := afero.NewMemMapFs()
+		// Create seed files
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/seed1.sql", []byte("INSERT INTO table1 VALUES (1);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/seed2.sql", []byte("INSERT INTO table2 VALUES (2);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/seed3.sql", []byte("INSERT INTO table2 VALUES (2);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/another.sql", []byte("INSERT INTO table2 VALUES (2);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/ignore.sql", []byte("INSERT INTO table3 VALUES (3);"), 0644))
+		// Mock config patterns
+		Config.Db.Seed.Path = []string{"seeds/seed[12].sql", "seeds/ano*.sql"}
+
+		// Run test
+		files, err := GetSeedFiles(fsys)
+
+		// Check error
+		assert.NoError(t, err)
+		// Validate files
+		assert.ElementsMatch(t, []string{"supabase/seeds/seed1.sql", "supabase/seeds/seed2.sql", "supabase/seeds/another.sql"}, files)
+	})
+	t.Run("returns seed files matching patterns skip duplicates", func(t *testing.T) {
+		// Setup in-memory fs
+		fsys := afero.NewMemMapFs()
+		// Create seed files
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/seed1.sql", []byte("INSERT INTO table1 VALUES (1);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/seed2.sql", []byte("INSERT INTO table2 VALUES (2);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/seed3.sql", []byte("INSERT INTO table2 VALUES (2);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/another.sql", []byte("INSERT INTO table2 VALUES (2);"), 0644))
+		require.NoError(t, afero.WriteFile(fsys, "supabase/seeds/ignore.sql", []byte("INSERT INTO table3 VALUES (3);"), 0644))
+		// Mock config patterns
+		Config.Db.Seed.Path = []string{"seeds/seed[12].sql", "seeds/ano*.sql", "seeds/seed*.sql"}
+
+		// Run test
+		files, err := GetSeedFiles(fsys)
+
+		// Check error
+		assert.NoError(t, err)
+		// Validate files
+		assert.ElementsMatch(t, []string{"supabase/seeds/seed1.sql", "supabase/seeds/seed2.sql", "supabase/seeds/another.sql", "supabase/seeds/seed3.sql"}, files)
+	})
+
+	t.Run("returns error on invalid pattern", func(t *testing.T) {
+		// Setup in-memory fs
+		fsys := afero.NewMemMapFs()
+		// Mock config patterns
+		Config.Db.Seed.Path = []string{"[*!#@D#"}
+
+		// Run test
+		files, err := GetSeedFiles(fsys)
+
+		// Check error
+		assert.Nil(t, err)
+		// The resuling seed list should be empty
+		assert.ElementsMatch(t, []string{}, files)
+	})
+
+	t.Run("returns empty list if no files match", func(t *testing.T) {
+		// Setup in-memory fs
+		fsys := afero.NewMemMapFs()
+		// Mock config patterns
+		Config.Db.Seed.Path = []string{"seeds/*.sql"}
+
+		// Run test
+		files, err := GetSeedFiles(fsys)
+
+		// Check error
+		assert.NoError(t, err)
+		// Validate files
+		assert.Empty(t, files)
+	})
+}

pkg/config/config.go

@@ -164,7 +164,8 @@ type (
 	}
 
 	seed struct {
-		Enabled bool `toml:"enabled"`
+		Enabled bool     `toml:"enabled"`
+		Path    []string `toml:"path"`
 	}
 
 	pooler struct {
@@ -465,6 +466,7 @@ func NewConfig(editors ...ConfigEditor) config {
 			},
 			Seed: seed{
 				Enabled: true,
+				Path:    []string{"./seed.sql"},
 			},
 		},
 		Realtime: realtime{

pkg/config/templates/config.toml

@@ -39,6 +39,14 @@ default_pool_size = 20
 # Maximum number of client connections allowed.
 max_client_conn = 100
 
+[db.seed]
+# Determines whether to seed the database after migrations during a db reset
+enabled = true
+# Specifies seed files to load during db reset using glob patterns
+# Base path is the Supabase project folder
+# Example: path = ['./seeds/*.sql', '../project-src/seeds/*-load-testing.sql']
+path = ['./seed.sql']
+
 [realtime]
 enabled = true
 # Bind realtime via either IPv4 or IPv6. (default: IPv4)

pkg/config/testdata/config.toml

@@ -39,6 +39,14 @@ default_pool_size = 20
 # Maximum number of client connections allowed.
 max_client_conn = 100
 
+[db.seed]
+# Determines whether to seed the database after migrations during a db reset
+enabled = true
+# Specifies seed files to load during db reset using glob patterns
+# Base path is the Supabase project folder
+# Example: path = ['./seeds/*.sql', '../project-src/seeds/*-load-testing.sql']
+path = ['./seed.sql']
+
 [realtime]
 enabled = true
 # Bind realtime via either IPv4 or IPv6. (default: IPv6)

pkg/config/utils.go

@@ -29,7 +29,7 @@ type pathBuilder struct {
 	FallbackImportMapPath string
 	FallbackEnvFilePath   string
 	DbTestsDir            string
-	SeedDataPath          string
+	DefaultSeedDataPath   string
 	CustomRolesPath       string
 }
 
@@ -63,7 +63,7 @@ func NewPathBuilder(configPath string) pathBuilder {
 		FallbackImportMapPath: filepath.Join(base, "functions", "import_map.json"),
 		FallbackEnvFilePath:   filepath.Join(base, "functions", ".env"),
 		DbTestsDir:            filepath.Join(base, "tests"),
-		SeedDataPath:          filepath.Join(base, "seed.sql"),
+		DefaultSeedDataPath:   filepath.Join(base, "seed.sql"),
 		CustomRolesPath:       filepath.Join(base, "roles.sql"),
 	}
 }

pkg/migration/seed.go

@@ -12,8 +12,7 @@ import (
 
 func SeedData(ctx context.Context, pending []string, conn *pgx.Conn, fsys fs.FS) error {
 	for _, path := range pending {
-		filename := filepath.Base(path)
-		fmt.Fprintf(os.Stderr, "Seeding data from %s...\n", filename)
+		fmt.Fprintf(os.Stderr, "Seeding data from %s...\n", path)
 		// Batch seed commands, safe to use statement cache
 		if seed, err := NewMigrationFromFile(path, fsys); err != nil {
 			return err