fix(cli): print declarative-schema-written line in sync bootstrap (CLI-1980)

apps/cli/src/legacy/commands/db/schema/declarative/sync/SIDE_EFFECTS.md

@@ -60,7 +60,10 @@ surfaces before an `--apply`/`--no-apply` conflict is ever checked.
 ## Output
 
 Text mode only. The generated SQL, the created-migration path, drop-statement
-warnings, and apply status are written to stderr.
+warnings, and apply status are written to stderr. The no-files bootstrap also
+prints `Declarative schema written to <dir>` (the relative declarative dir, Go's
+`GetDeclarativeDir()`) to stderr after generating, writing, and warming the
+catalog cache — on both the interactive-accept and `--yes` paths.
 `--no-apply` writes the migration only (never prompts/applies); `--apply` applies
 without prompting; both override the global `--yes`. `--no-apply` and `--apply`
 are mutually exclusive.

apps/cli/src/legacy/commands/db/schema/declarative/sync/sync.handler.ts

@@ -127,13 +127,15 @@ export const legacyDbSchemaDeclarativeSync = Effect.fn("legacy.db.schema.declara
         );
       }
 
+      // Go's `utils.GetDeclarativeDir()` — the config value verbatim (already
+      // `supabase/`-prefixed when relative) or the relative `supabase/database`
+      // default. Printed verbatim in the bootstrap's written-to line below, exactly
+      // as Go prints it (Go chdirs into the workdir, so its paths stay relative).
+      const declarativeDirRel = legacyResolveDeclarativeDir(path, toml.pgDelta);
       // `path.resolve` (not `path.join`) so an absolute `declarative_schema_path` is
       // used as-is, matching Go's `config.resolve` (which only prefixes the workdir onto
       // a relative path). `path.join(workdir, abs)` would mangle the absolute path.
-      const declarativeDir = path.resolve(
-        cliConfig.workdir,
-        legacyResolveDeclarativeDir(path, toml.pgDelta),
-      );
+      const declarativeDir = path.resolve(cliConfig.workdir, declarativeDirRel);
       const migrationsDir = path.join(cliConfig.workdir, "supabase", "migrations");
       const tempDir = legacyPgDeltaTempPath(path, cliConfig.workdir);
       const run: LegacyDeclarativeRunContext = {
@@ -249,6 +251,19 @@ export const legacyDbSchemaDeclarativeSync = Effect.fn("legacy.db.schema.declara
         if (!run.noCache) {
           yield* seam.exportCatalog({ mode: "declarative", noCache: run.noCache });
         }
+        // Go's delegated `declarative.Generate` prints the written-to line to stderr
+        // after the write and the catalog warm (`declarative.go:133→138-155→156`), on
+        // both the interactive-accept and --yes/SUPABASE_YES bootstrap paths, and
+        // regardless of --no-cache (the warm is skipped, the line is not). It prints
+        // `utils.GetDeclarativeDir()` — the relative dir above, never a resolved
+        // absolute path, because Go chdirs into the workdir (CLI-1980). NOTE: the
+        // generate and db pull ports of this same Go line still print the absolute
+        // dir today — pull's is moving to relative under CLI-1978; this rendering
+        // is the Go-faithful one.
+        yield* output.raw(
+          `Declarative schema written to ${legacyBold(declarativeDirRel)}\n`,
+          "stderr",
+        );
       }
 
       // Step 2: diff migrations state vs declarative; on error, save a debug bundle.

apps/cli/src/legacy/commands/db/schema/declarative/sync/sync.integration.test.ts

@@ -4,6 +4,7 @@ import { BunServices } from "@effect/platform-bun";
 import { describe, expect, it } from "@effect/vitest";
 import { Cause, Effect, Exit, Layer, Option } from "effect";
 
+import { stripAnsi } from "../../../../../../../tests/helpers/ansi.ts";
 import { mockOutput, mockStdin, mockTty } from "../../../../../../../tests/helpers/mocks.ts";
 import {
   mockLegacyCliConfig,
@@ -70,8 +71,16 @@ function setup(workdir: string, opts: SetupOpts = {}) {
   const cache = mockLegacyLinkedProjectCacheTracked();
   const execInheritCalls: ReadonlyArray<string>[] = [];
   const localPostgresImageChecks: Array<true> = [];
+  // Each catalog export records how many raw chunks had been emitted when it fired,
+  // so tests can assert output ordering relative to the exports (e.g. the bootstrap's
+  // written-to line lands after the declarative warm, before the diff's exports).
+  const exportCatalogCalls: Array<{ mode: string; rawChunksAt: number }> = [];
   const seam = Layer.succeed(LegacyDeclarativeSeam, {
-    exportCatalog: ({ mode }) => Effect.succeed(`supabase/.temp/pgdelta/${mode}.json`),
+    exportCatalog: ({ mode }) =>
+      Effect.sync(() => {
+        exportCatalogCalls.push({ mode, rawChunksAt: out.rawChunks.length });
+        return `supabase/.temp/pgdelta/${mode}.json`;
+      }),
     execInherit: (args) =>
       Effect.sync(() => {
         execInheritCalls.push(args);
@@ -186,7 +195,15 @@ function setup(workdir: string, opts: SetupOpts = {}) {
     }),
     BunServices.layer,
   );
-  return { layer, out, execInheritCalls, dbExec, cache, localPostgresImageChecks };
+  return {
+    layer,
+    out,
+    execInheritCalls,
+    dbExec,
+    cache,
+    localPostgresImageChecks,
+    exportCatalogCalls,
+  };
 }
 
 const flags = (
@@ -448,6 +465,92 @@ describe("legacy db schema declarative sync integration", () => {
     }).pipe(Effect.provide(s.layer));
   });
 
+  it.effect("bootstrap prints the declarative-schema-written line after the catalog warm", () => {
+    // Go's bootstrap delegates to `declarative.Generate`, which prints
+    // `Declarative schema written to <dir>` to stderr AFTER WriteDeclarativeSchemas
+    // and the catalog warm (`declarative.go:133→138-155→156`), before sync's own
+    // diff (step 2). It prints `utils.GetDeclarativeDir()` — the relative
+    // `supabase/database` default — never the absolute resolved dir (CLI-1980).
+    const s = setup(tmp.current, {
+      experimental: true,
+      stdinIsTty: true,
+      diffSql: "",
+      exportJson: EXPORT_JSON,
+      promptConfirmResponses: [true], // generate a new one? yes (no migrations → no reset prompt)
+    });
+    return Effect.gen(function* () {
+      yield* legacyDbSchemaDeclarativeSync(flags({ noApply: Option.some(true) }));
+      const line = `Declarative schema written to ${join("supabase", "database")}\n`;
+      const written = s.out.rawChunks
+        .map((c, index) => ({ text: stripAnsi(c.text), stream: c.stream, index }))
+        .filter((c) => c.text === line);
+      expect(written).toHaveLength(1);
+      expect(written[0]?.stream).toBe("stderr");
+      const lineAt = written[0]?.index ?? -1;
+      // The warm (first declarative-mode export) fires before the line is printed…
+      const warm = s.exportCatalogCalls.find((c) => c.mode === "declarative");
+      expect(warm?.rawChunksAt).toBeLessThanOrEqual(lineAt);
+      // …and the diff's first export (migrations catalog) fires after it, so the
+      // line sits at the end of the bootstrap, matching Go's ordering.
+      const diffStart = s.exportCatalogCalls.find((c) => c.mode === "migrations");
+      expect(diffStart?.rawChunksAt).toBeGreaterThan(lineAt);
+      // The generated files actually landed in the printed (resolved) dir.
+      expect(
+        existsSync(
+          join(tmp.current, "supabase", "database", "schemas", "public", "tables", "players.sql"),
+        ),
+      ).toBe(true);
+    }).pipe(Effect.provide(s.layer));
+  });
+
+  it.effect("--yes bootstrap prints the declarative-schema-written line too", () => {
+    // Go reaches the same delegated `declarative.Generate` print on the
+    // auto-confirmed (--yes / SUPABASE_YES) bootstrap as on the interactive accept.
+    const s = setup(tmp.current, {
+      experimental: true,
+      stdinIsTty: false,
+      yes: true,
+      diffSql: "",
+      exportJson: EXPORT_JSON,
+    });
+    return Effect.gen(function* () {
+      yield* legacyDbSchemaDeclarativeSync(flags({ noApply: Option.some(true) }));
+      expect(
+        s.out.rawChunks.map((c) => ({ text: stripAnsi(c.text), stream: c.stream })),
+      ).toContainEqual({
+        text: `Declarative schema written to ${join("supabase", "database")}\n`,
+        stream: "stderr",
+      });
+    }).pipe(Effect.provide(s.layer));
+  });
+
+  it.effect("--no-cache bootstrap still prints the declarative-schema-written line", () => {
+    // Go's print sits OUTSIDE the `if !noCache` warm gate (`declarative.go:138-156`):
+    // skipping the catalog warm must not skip the line.
+    const s = setup(tmp.current, {
+      experimental: true,
+      stdinIsTty: false,
+      yes: true,
+      diffSql: "",
+      exportJson: EXPORT_JSON,
+    });
+    return Effect.gen(function* () {
+      yield* legacyDbSchemaDeclarativeSync(flags({ noCache: true, noApply: Option.some(true) }));
+      const line = `Declarative schema written to ${join("supabase", "database")}\n`;
+      const written = s.out.rawChunks
+        .map((c, index) => ({ text: stripAnsi(c.text), stream: c.stream, index }))
+        .filter((c) => c.text === line);
+      expect(written).toHaveLength(1);
+      expect(written[0]?.stream).toBe("stderr");
+      // The warm really was skipped: the only declarative-mode export is the diff's,
+      // which fires after the line — yet the line still printed.
+      const lineAt = written[0]?.index ?? -1;
+      const declarativeExports = s.exportCatalogCalls.filter((c) => c.mode === "declarative");
+      expect(declarativeExports).toHaveLength(1);
+      expect(declarativeExports[0]?.rawChunksAt).toBeGreaterThan(lineAt);
+    }).pipe(Effect.provide(s.layer));
+  });
+
   it.effect("bootstrap with migrations offers the smart target choice (not local-only)", () => {
     // Go delegates the no-files bootstrap to runDeclarativeGenerate; with migrations
     // present it offers local/linked/custom rather than silently generating from