fix(cli/migrate): skip view recreate when DB body matches metadata

computeProjectionMigrations always emitted DROP+CREATE for every
projection view because it never compared against the live DB. Result:
every migration churned all projection views even when nothing about
them had changed.

Read existing view CREATE SQL from sqlite_master.sql (or pg_views.
definition synthesized as "CREATE VIEW <n> AS <def>") and compare
against the emitted CREATE SQL after whitespace normalization. Skip
the view's migration entry when they match.

Introspection failure is non-fatal — we fall back to the prior over-
eager behavior so a borked introspect can't break migrate.

mikes-website verification:
- Converged DB → "No schema changes."
- workout_events-only drift → one table recreate, zero view migrations,
  zero pre-drops (no view depends on workout_events).
- programs-only drift → table recreate + v_program_summary +
  v_purchase_summary recreates (both depend on programs).

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

Author: dmealing

typescript/packages/cli/src/commands/migrate.ts

@@ -219,12 +219,17 @@ export async function migrateCommand(args: string[], cwd: string): Promise<numbe
       // metaobjects.config.ts absent or invalid — use default snake_case
     }
 
+    // Pull existing view CREATE SQL from the DB so unchanged views can be
+    // skipped (no DROP+CREATE noise when the body hasn't changed).
+    const existingViewSql = await readExistingViewSql(kysely.db, kysely.dialect);
+
     // Compute view migrations (projections) independently of table changes.
     const viewResult = computeProjectionMigrations({
       metadata,
       dialect: kysely.dialect,
       allowBreaking: false,
       columnNamingStrategy,
+      existingViewSql,
     });
     if (viewResult.errors.length > 0) {
       for (const err of viewResult.errors) log.error(err);
@@ -343,3 +348,43 @@ export async function migrateCommand(args: string[], cwd: string): Promise<numbe
   log.info(output);
   return exitCode;
 }
+
+/**
+ * Read existing view CREATE SQL from the DB. Returns an empty map on any
+ * introspection failure — the worst case is over-eager DROP+CREATE
+ * (the original behaviour), not data loss.
+ */
+async function readExistingViewSql(
+  // biome-ignore lint/suspicious/noExplicitAny: kysely raw query, dialect-dispatched
+  db: any,
+  dialect: "sqlite" | "postgres",
+): Promise<ReadonlyMap<string, string>> {
+  const result = new Map<string, string>();
+  try {
+    if (dialect === "sqlite") {
+      const { sql } = await import("kysely");
+      const rows = await sql<{ name: string; sql: string }>`
+        SELECT name, sql FROM sqlite_master WHERE type='view' AND name NOT LIKE 'sqlite_%'
+      `.execute(db);
+      for (const r of rows.rows) {
+        if (r.name && r.sql) result.set(r.name, r.sql);
+      }
+    } else {
+      const { sql } = await import("kysely");
+      const rows = await sql<{ name: string; def: string }>`
+        SELECT viewname AS name, definition AS def
+        FROM pg_views
+        WHERE schemaname = 'public'
+      `.execute(db);
+      for (const r of rows.rows) {
+        // Postgres pg_views.definition returns only the SELECT body, not the
+        // full "CREATE VIEW ... AS ...". Synthesize so comparison is apples-
+        // to-apples with what emitViewDdl produces.
+        if (r.name && r.def) result.set(r.name, `CREATE VIEW ${r.name} AS ${r.def}`);
+      }
+    }
+  } catch {
+    // ignore — empty map means over-eager recreate, same as before this fix
+  }
+  return result;
+}

typescript/packages/cli/src/lib/projection-migrations.ts

@@ -23,6 +23,18 @@ export interface ProjectionMigrationsOpts {
   readonly allowBreaking?: boolean;
   /** Column naming strategy forwarded to extractViewSpec. Defaults to "snake_case". */
   readonly columnNamingStrategy?: "snake_case" | "literal" | "kebab-case";
+  /**
+   * Existing view SQL keyed by view name (from sqlite_master.sql or
+   * pg_views.definition). When provided, projections whose emitted CREATE
+   * SQL matches the existing definition (whitespace-normalized) are skipped
+   * — no DROP+CREATE noise for unchanged views.
+   */
+  readonly existingViewSql?: ReadonlyMap<string, string>;
+}
+
+/** Collapse whitespace + strip trailing ";" for textual view-SQL comparison. */
+function normalizeViewSql(sql: string): string {
+  return sql.replace(/\s+/g, " ").replace(/;\s*$/, "").trim();
 }
 
 /**
@@ -77,13 +89,20 @@ export function computeProjectionMigrations(
       joinTables,
     });
 
+    // Skip if the existing DB view's CREATE SQL matches what we'd emit.
+    // Avoids the "every migration re-creates every view" noise when nothing
+    // about the view's body actually changed.
+    const existing = opts.existingViewSql?.get(spec.viewName);
+    if (existing !== undefined && normalizeViewSql(existing) === normalizeViewSql(createSql)) {
+      continue;
+    }
+
     views.push({
       viewName: spec.viewName,
       // prevShape intentionally absent — treated as "safe-append" by
       // computeViewMigrations (source-aware-diff.ts line 32). On Postgres
       // this rewrites the emitted "CREATE VIEW" to "CREATE OR REPLACE VIEW",
-      // so re-running migrate is idempotent. Future: introspect existing views
-      // via pg_views / sqlite_master for true safe-replace/breaking detection.
+      // so re-running migrate is idempotent.
       nextShape: {
         columns: spec.selectSpec.columns.map((c) => c.dbColAlias),
       },