Sync fork on 2026-06-03 (#7)

* refactor: refactor the release workflow's test job to use a GitHub Actions matrix strategy, running PostgreSQL 14-18 tests in parallel instead of sequentially. (pgplex#432)

* refactor: streamline CI workflows for unit and integration tests with matrix strategy

* fix: ensure integration tests depend on unit tests in CI workflow

* refactor: consolidate unit and integration tests into a single CI job

* revert: undo unnecessary trailing newline change in ci-test.yml

---------

Co-authored-by: William Chen <william_w_chen@trendmicro.com>

* feat: add validation for file extensions in apply command (pgplex#434)

Co-authored-by: William Chen <william_w_chen@trendmicro.com>

* Add support for indexes section in .pgschemaignore (pgplex#441)

Adds a new [indexes] section to .pgschemaignore that lets users
preserve indexes which exist in the database but are not declared
in their .sql files. Without this, manually-added indexes (e.g.
perf hotfixes) are flagged for drop by `pgschema plan`.

Mirrors the existing per-object pattern: `Indexes []string` on
`IgnoreConfig` with `ShouldIgnoreIndex(name)`, an
`IndexIgnoreConfig` struct on `TomlConfig`, and a filter in
`Inspector.buildIndexes` that skips ignored index names before
they enter the IR.

Fixes pgplex#406

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix: preserve length modifier in varchar(n)[] array columns (pgplex#420) (pgplex#438)

Co-authored-by: vytautas.karpavicius <vytautas.karpavicius@cloudkitchens.com>

* chore: bump 1.9.0 to 1.10.0

---------

Co-authored-by: William Chen <william_w_chen@trendmicro.com>
Co-authored-by: Guillaume Lecomte <guillaume86@gmail.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: Vytautas <vycas0@gmail.com>
Co-authored-by: vytautas.karpavicius <vytautas.karpavicius@cloudkitchens.com>
Co-authored-by: Tianzhou <t@bytebase.com>

Author: 7 people

cmd/apply/apply.go

@@ -6,6 +6,7 @@ import (
 	"database/sql"
 	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/pgplex/pgschema/cmd/config"
@@ -268,6 +269,24 @@ func ApplyMigration(config *ApplyConfig, provider postgres.DesiredStateProvider)
 	return nil
 }
 
+// validateFileExtension checks that --file and --plan flags have the expected file extensions.
+// Returns an actionable error if a likely flag mix-up is detected.
+func validateFileExtension(file, planFile string) error {
+	if file != "" {
+		ext := strings.ToLower(filepath.Ext(file))
+		if ext == ".json" {
+			return fmt.Errorf("--file expects a SQL schema file, but got a JSON file (%s). Did you mean to use --plan instead?", filepath.Base(file))
+		}
+	}
+	if planFile != "" {
+		ext := strings.ToLower(filepath.Ext(planFile))
+		if ext == ".sql" {
+			return fmt.Errorf("--plan expects a JSON plan file, but got a SQL file (%s). Did you mean to use --file instead?", filepath.Base(planFile))
+		}
+	}
+	return nil
+}
+
 // RunApply executes the apply command logic. Exported for testing.
 func RunApply(cmd *cobra.Command, args []string) error {
 	cfg := config.Get()
@@ -281,6 +300,11 @@ func RunApply(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("either --file or --plan must be specified")
 	}
 
+	// Validate file extensions to catch flag mix-ups early
+	if err := validateFileExtension(applyFile, applyPlan); err != nil {
+		return err
+	}
+
 	// Derive final password: use provided password or check environment variable
 	finalPassword := applyPassword
 	if finalPassword == "" {

cmd/apply/apply_test.go

@@ -498,6 +498,166 @@ func TestApplyCommandFileError(t *testing.T) {
 	}
 }
 
+func TestApplyFileExtensionValidation(t *testing.T) {
+	// Save original values
+	origDB := applyDB
+	origUser := applyUser
+	origFile := applyFile
+	origPlan := applyPlan
+	defer func() {
+		applyDB = origDB
+		applyUser = origUser
+		applyFile = origFile
+		applyPlan = origPlan
+	}()
+
+	t.Run("file with json extension suggests plan", func(t *testing.T) {
+		applyDB = "testdb"
+		applyUser = "testuser"
+		applyFile = "plan.json"
+		applyPlan = ""
+
+		err := RunApply(nil, []string{})
+		if err == nil {
+			t.Fatal("Expected error when --file has .json extension")
+		}
+		if !strings.Contains(err.Error(), "--file expects a SQL schema file") {
+			t.Errorf("Expected SQL schema file error, got: %v", err)
+		}
+		if !strings.Contains(err.Error(), "--plan instead") {
+			t.Errorf("Expected suggestion to use --plan, got: %v", err)
+		}
+	})
+
+	t.Run("file with JSON extension case insensitive", func(t *testing.T) {
+		applyDB = "testdb"
+		applyUser = "testuser"
+		applyFile = "plan.JSON"
+		applyPlan = ""
+
+		err := RunApply(nil, []string{})
+		if err == nil {
+			t.Fatal("Expected error when --file has .JSON extension")
+		}
+		if !strings.Contains(err.Error(), "--file expects a SQL schema file") {
+			t.Errorf("Expected SQL schema file error, got: %v", err)
+		}
+	})
+
+	t.Run("plan with sql extension suggests file", func(t *testing.T) {
+		applyDB = "testdb"
+		applyUser = "testuser"
+		applyFile = ""
+		applyPlan = "schema.sql"
+
+		err := RunApply(nil, []string{})
+		if err == nil {
+			t.Fatal("Expected error when --plan has .sql extension")
+		}
+		if !strings.Contains(err.Error(), "--plan expects a JSON plan file") {
+			t.Errorf("Expected JSON plan file error, got: %v", err)
+		}
+		if !strings.Contains(err.Error(), "--file instead") {
+			t.Errorf("Expected suggestion to use --file, got: %v", err)
+		}
+	})
+
+	t.Run("plan with SQL extension case insensitive", func(t *testing.T) {
+		applyDB = "testdb"
+		applyUser = "testuser"
+		applyFile = ""
+		applyPlan = "schema.SQL"
+
+		err := RunApply(nil, []string{})
+		if err == nil {
+			t.Fatal("Expected error when --plan has .SQL extension")
+		}
+		if !strings.Contains(err.Error(), "--plan expects a JSON plan file") {
+			t.Errorf("Expected JSON plan file error, got: %v", err)
+		}
+	})
+
+	t.Run("file with sql extension no error", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		schemaPath := filepath.Join(tmpDir, "schema.sql")
+		if err := os.WriteFile(schemaPath, []byte("CREATE TABLE test (id INT);"), 0644); err != nil {
+			t.Fatalf("Failed to write schema file: %v", err)
+		}
+
+		applyDB = "testdb"
+		applyUser = "testuser"
+		applyFile = schemaPath
+		applyPlan = ""
+
+		err := RunApply(nil, []string{})
+		// Should fail on something other than extension validation
+		if err != nil && strings.Contains(err.Error(), "expects a") {
+			t.Errorf("Should not get extension validation error for .sql file: %v", err)
+		}
+	})
+
+	t.Run("plan with json extension no error", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		planPath := filepath.Join(tmpDir, "plan.json")
+		planJSON := fmt.Sprintf(`{"version":"1.0.0","pgschema_version":"%s","created_at":"2024-01-01T00:00:00Z","transaction":true,"summary":{"total":0,"add":0,"change":0,"destroy":0,"by_type":{}},"diffs":[]}`, version.App())
+		if err := os.WriteFile(planPath, []byte(planJSON), 0644); err != nil {
+			t.Fatalf("Failed to write plan file: %v", err)
+		}
+
+		applyDB = "testdb"
+		applyUser = "testuser"
+		applyFile = ""
+		applyPlan = planPath
+
+		err := RunApply(nil, []string{})
+		// Should not get extension validation error
+		if err != nil && strings.Contains(err.Error(), "expects a") {
+			t.Errorf("Should not get extension validation error for .json plan: %v", err)
+		}
+	})
+}
+
+func TestValidateFileExtension(t *testing.T) {
+	tests := []struct {
+		name     string
+		file     string
+		plan     string
+		wantErr  bool
+		errMsg   string
+	}{
+		{"file with json", "plan.json", "", true, "--file expects a SQL schema file"},
+		{"file with JSON uppercase", "plan.JSON", "", true, "--file expects a SQL schema file"},
+		{"file with Json mixed case", "plan.Json", "", true, "--file expects a SQL schema file"},
+		{"plan with sql", "", "schema.sql", true, "--plan expects a JSON plan file"},
+		{"plan with SQL uppercase", "", "schema.SQL", true, "--plan expects a JSON plan file"},
+		{"file with sql is ok", "schema.sql", "", false, ""},
+		{"plan with json is ok", "", "plan.json", false, ""},
+		{"both empty is ok", "", "", false, ""},
+		{"file with no extension is ok", "schema", "", false, ""},
+		{"plan with no extension is ok", "", "plan", false, ""},
+		{"file with path and json", "/tmp/plans/plan.json", "", true, "--file expects a SQL schema file"},
+		{"plan with path and sql", "", "/tmp/schemas/schema.sql", true, "--plan expects a JSON plan file"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateFileExtension(tt.file, tt.plan)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("Expected error but got nil")
+				}
+				if !strings.Contains(err.Error(), tt.errMsg) {
+					t.Errorf("Expected error containing %q, got: %v", tt.errMsg, err)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Expected no error, got: %v", err)
+				}
+			}
+		})
+	}
+}
+
 func TestApplyCommand_PlanDatabaseFlags(t *testing.T) {
 	flags := ApplyCmd.Flags()
 

cmd/dump/dump_integration_test.go

@@ -151,6 +151,13 @@ func TestDumpCommand_Issue191FunctionProcedureOverload(t *testing.T) {
 	runExactMatchTest(t, "issue_191_function_procedure_overload")
 }
 
+func TestDumpCommand_Issue420VarcharArrayLengthModifier(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+	runExactMatchTest(t, "issue_420_varchar_array_length_modifier")
+}
+
 // Reproduces a bug where a column declared as `name` is dumped as `char[]`.
 // The inspector classifies any base type with pg_type.typelem <> 0 as an array,
 // but the `name` type has typelem = 18 (the OID of "char") despite not being an array.

cmd/ignore_integration_test.go

@@ -1334,6 +1334,117 @@ GRANT SELECT ON users TO app_user;
 	}
 }
 
+// TestIgnoreIndexes tests that indexes matching .pgschemaignore [indexes] patterns
+// are excluded from dump and plan output.
+// Reproduces https://github.com/pgplex/pgschema/issues/406
+func TestIgnoreIndexes(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	embeddedPG := testutil.SetupPostgres(t)
+	defer embeddedPG.Stop()
+	conn, host, port, dbname, user, password := testutil.ConnectToPostgres(t, embeddedPG)
+	defer conn.Close()
+
+	containerInfo := &struct {
+		Conn     *sql.DB
+		Host     string
+		Port     int
+		DBName   string
+		User     string
+		Password string
+	}{
+		Conn:     conn,
+		Host:     host,
+		Port:     port,
+		DBName:   dbname,
+		User:     user,
+		Password: password,
+	}
+
+	// Create a table with a managed index plus a manually-added index that
+	// is not part of the declared schema (simulates a perf hotfix index
+	// added directly to a production database).
+	setupSQL := `
+CREATE TABLE products (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL,
+    category TEXT
+);
+
+CREATE INDEX products_name_idx ON products(name);
+CREATE INDEX manual_perf_idx ON products(category);
+`
+	_, err := conn.Exec(setupSQL)
+	if err != nil {
+		t.Fatalf("Failed to create test schema: %v", err)
+	}
+
+	originalWd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Failed to get current working directory: %v", err)
+	}
+	defer func() {
+		if err := os.Chdir(originalWd); err != nil {
+			t.Fatalf("Failed to restore working directory: %v", err)
+		}
+	}()
+
+	tmpDir := t.TempDir()
+	if err := os.Chdir(tmpDir); err != nil {
+		t.Fatalf("Failed to change to temp directory: %v", err)
+	}
+
+	// Ignore any index whose name starts with "manual_"
+	ignoreContent := `[indexes]
+patterns = ["manual_*"]
+`
+	err = os.WriteFile(".pgschemaignore", []byte(ignoreContent), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create .pgschemaignore: %v", err)
+	}
+
+	t.Run("dump", func(t *testing.T) {
+		output := executeIgnoreDumpCommand(t, containerInfo)
+
+		if !strings.Contains(output, "products_name_idx") {
+			t.Error("Dump should include products_name_idx (not ignored)")
+		}
+
+		if strings.Contains(output, "manual_perf_idx") {
+			t.Error("Dump should not include manual_perf_idx (ignored by [indexes] patterns)")
+		}
+	})
+
+	t.Run("plan", func(t *testing.T) {
+		// Desired schema declares products_name_idx but not manual_perf_idx.
+		// Without the ignore the plan would emit DROP INDEX manual_perf_idx;
+		// with the ignore the plan should not reference manual_perf_idx at all.
+		schemaSQL := `
+CREATE TABLE products (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL,
+    category TEXT
+);
+
+CREATE INDEX products_name_idx ON products(name);
+`
+		schemaFile := "schema.sql"
+		err := os.WriteFile(schemaFile, []byte(schemaSQL), 0644)
+		if err != nil {
+			t.Fatalf("Failed to create schema file: %v", err)
+		}
+		defer os.Remove(schemaFile)
+
+		output := executeIgnorePlanCommand(t, containerInfo, schemaFile)
+
+		if strings.Contains(output, "manual_perf_idx") {
+			t.Errorf("Plan should not reference manual_perf_idx (ignored); got: %s", output)
+		}
+	})
+}
+
 // verifyPlanOutput checks that plan output excludes ignored objects
 func verifyPlanOutput(t *testing.T, output string) {
 	// Changes that should appear in plan (regular objects)

cmd/util/ignoreloader.go

@@ -34,6 +34,7 @@ type TomlConfig struct {
 	Procedures        ProcedureIgnoreConfig        `toml:"procedures,omitempty"`
 	Types             TypeIgnoreConfig             `toml:"types,omitempty"`
 	Sequences         SequenceIgnoreConfig         `toml:"sequences,omitempty"`
+	Indexes           IndexIgnoreConfig            `toml:"indexes,omitempty"`
 	Privileges        PrivilegeIgnoreConfig        `toml:"privileges,omitempty"`
 	DefaultPrivileges DefaultPrivilegeIgnoreConfig `toml:"default_privileges,omitempty"`
 }
@@ -68,6 +69,11 @@ type SequenceIgnoreConfig struct {
 	Patterns []string `toml:"patterns,omitempty"`
 }
 
+// IndexIgnoreConfig represents index-specific ignore configuration
+type IndexIgnoreConfig struct {
+	Patterns []string `toml:"patterns,omitempty"`
+}
+
 // PrivilegeIgnoreConfig represents privilege-specific ignore configuration
 // Patterns match on grantee role names
 type PrivilegeIgnoreConfig struct {
@@ -111,6 +117,7 @@ func LoadIgnoreFileWithStructureFromPath(filePath string) (*ir.IgnoreConfig, err
 		Procedures:        tomlConfig.Procedures.Patterns,
 		Types:             tomlConfig.Types.Patterns,
 		Sequences:         tomlConfig.Sequences.Patterns,
+		Indexes:           tomlConfig.Indexes.Patterns,
 		Privileges:        tomlConfig.Privileges.Patterns,
 		DefaultPrivileges: tomlConfig.DefaultPrivileges.Patterns,
 	}

cmd/util/ignoreloader_test.go

@@ -41,6 +41,9 @@ patterns = ["type_test_*"]
 
 [sequences]
 patterns = ["seq_temp_*"]
+
+[indexes]
+patterns = ["idx_temp_*"]
 `
 
 	err := os.WriteFile(testFile, []byte(tomlContent), 0644)
@@ -79,6 +82,10 @@ patterns = ["seq_temp_*"]
 	if len(config.Procedures) != 1 || config.Procedures[0] != "sp_temp_*" {
 		t.Errorf("Expected procedure patterns [\"sp_temp_*\"], got %v", config.Procedures)
 	}
+
+	if len(config.Indexes) != 1 || config.Indexes[0] != "idx_temp_*" {
+		t.Errorf("Expected indexes patterns [\"idx_temp_*\"], got %v", config.Indexes)
+	}
 }
 
 func TestLoadIgnoreFileWithStructure_ValidTOML(t *testing.T) {