feat(cli): Add --no-apply flag for db schema declarative sync command (#5220)

## Summary

This change introduces a new flag called `no-apply` to the `db schema
declarative sync command` , allowing users to generate migration files
without applying them to the local database.

## Current behavior

```
$ supabase db schema declarative sync --name test
...
Created new migration at supabase/migrations/20260428093833_test.sql
Apply this migration to local database? [Y/n]
```

The only escape hatches today:
- `--apply` — force-applies the migration (opposite of what's wanted)
- Closing stdin via piping, e.g. `true | supabase db schema declarative
sync ... 2>&1 | cat`

Closes #5218

## New behavior

- If `--no-apply` is set, the command writes the migration file and
skips the apply step without any prompt
- `--no-apply` overrides global `--yes` and cannot be combined with
`--apply`.
- Parity with legacy TS is maintained

---------

Co-authored-by: Andrew Valleteau <avallete@users.noreply.github.com>

Author: mittal-parth

apps/cli-go/cmd/db_schema_declarative.go

@@ -32,6 +32,7 @@ var (
 	declarativeLocal     bool
 	declarativeReset     bool
 	declarativeApply     bool
+	declarativeNoApply   bool
 	declarativeFile      string
 	declarativeName      string
 
@@ -102,6 +103,26 @@ func resolveDeclarativeMigrationName(name, file string) string {
 	return file
 }
 
+// resolveDeclarativeSyncShouldApply decides whether to apply the generated migration.
+// Precedence: --no-apply > --apply > global --yes > TTY prompt > non-TTY default (skip).
+func resolveDeclarativeSyncShouldApply(
+	applyFlag, noApplyFlag, yesFlag, tty bool,
+	prompt func() (bool, error),
+) (bool, error) {
+	switch {
+	case noApplyFlag:
+		return false, nil
+	case applyFlag:
+		return true, nil
+	case yesFlag:
+		return true, nil
+	case tty:
+		return prompt()
+	default:
+		return false, nil
+	}
+}
+
 func ensureLocalDatabaseStarted(ctx context.Context, local bool, isRunning func() error, startDatabase func(context.Context) error) error {
 	if !local {
 		return nil
@@ -360,14 +381,17 @@ func runDeclarativeSync(cmd *cobra.Command, args []string) error {
 	}
 
 	// Step 6: Prompt to apply migration to local DB
-	shouldApply := declarativeApply
-	if !shouldApply && isTTY() && !viper.GetBool("YES") {
-		shouldApply, err = console.PromptYesNo(ctx, "Apply this migration to local database?", true)
-		if err != nil {
-			return err
-		}
-	} else if viper.GetBool("YES") {
-		shouldApply = true
+	shouldApply, err := resolveDeclarativeSyncShouldApply(
+		declarativeApply,
+		declarativeNoApply,
+		viper.GetBool("YES"),
+		isTTY(),
+		func() (bool, error) {
+			return console.PromptYesNo(ctx, "Apply this migration to local database?", true)
+		},
+	)
+	if err != nil {
+		return err
 	}
 
 	if shouldApply {
@@ -461,6 +485,9 @@ func init() {
 	syncFlags.StringVarP(&declarativeFile, "file", "f", defaultDeclarativeSyncName, "Saves schema diff to a new migration file.")
 	syncFlags.StringVar(&declarativeName, "name", "", "Name for the generated migration file.")
 	syncFlags.BoolVar(&declarativeApply, "apply", false, "Apply the generated migration to the local database without prompting.")
+	syncFlags.BoolVar(&declarativeNoApply, "no-apply", false,
+		"Generate the migration file without prompting or applying it to the local database.")
+	dbDeclarativeSyncCmd.MarkFlagsMutuallyExclusive("apply", "no-apply")
 
 	generateFlags := dbDeclarativeGenerateCmd.Flags()
 	generateFlags.BoolVar(&declarativeOverwrite, "overwrite", false, "Overwrite declarative schema files without confirmation.")

apps/cli-go/cmd/db_schema_declarative_test.go

@@ -31,6 +31,105 @@ func mockFsysWithMigrations() afero.Fs {
 	return fsys
 }
 
+func TestResolveDeclarativeSyncShouldApply(t *testing.T) {
+	t.Run("no-apply alone returns false without prompting", func(t *testing.T) {
+		got, err := resolveDeclarativeSyncShouldApply(
+			false, true, false, true,
+			func() (bool, error) {
+				t.Fatal("prompt should not be called")
+				return false, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("no-apply wins over yes", func(t *testing.T) {
+		got, err := resolveDeclarativeSyncShouldApply(
+			false, true, true, false,
+			func() (bool, error) {
+				t.Fatal("prompt should not be called")
+				return false, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("apply alone returns true without prompting", func(t *testing.T) {
+		got, err := resolveDeclarativeSyncShouldApply(
+			true, false, false, true,
+			func() (bool, error) {
+				t.Fatal("prompt should not be called")
+				return false, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.True(t, got)
+	})
+
+	t.Run("TTY without flags prompts", func(t *testing.T) {
+		prompted := false
+		got, err := resolveDeclarativeSyncShouldApply(
+			false, false, false, true,
+			func() (bool, error) {
+				prompted = true
+				return true, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.True(t, prompted)
+		assert.True(t, got)
+	})
+
+	t.Run("non-TTY without flags skips apply", func(t *testing.T) {
+		got, err := resolveDeclarativeSyncShouldApply(
+			false, false, false, false,
+			func() (bool, error) {
+				t.Fatal("prompt should not be called")
+				return false, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("yes alone on non-TTY applies without prompting", func(t *testing.T) {
+		got, err := resolveDeclarativeSyncShouldApply(
+			false, false, true, false,
+			func() (bool, error) {
+				t.Fatal("prompt should not be called")
+				return false, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.True(t, got)
+	})
+
+	t.Run("yes wins over TTY prompt", func(t *testing.T) {
+		got, err := resolveDeclarativeSyncShouldApply(
+			false, false, true, true,
+			func() (bool, error) {
+				t.Fatal("prompt should not be called")
+				return false, nil
+			},
+		)
+		require.NoError(t, err)
+		assert.True(t, got)
+	})
+
+	t.Run("prompt error propagates", func(t *testing.T) {
+		expected := errors.New("interrupt")
+		_, err := resolveDeclarativeSyncShouldApply(
+			false, false, false, true,
+			func() (bool, error) {
+				return false, expected
+			},
+		)
+		assert.ErrorIs(t, err, expected)
+	})
+}
+
 func TestResolveDeclarativeMigrationName(t *testing.T) {
 	t.Run("prefers explicit name", func(t *testing.T) {
 		name := resolveDeclarativeMigrationName("custom_name", "fallback_file")