@everystack/cli 0.3.19 → 0.3.22

package/src/cli/schema-diff.ts

@@ -65,6 +65,12 @@ export type SchemaChange =
   | { kind: 'renameSourceMissing'; table: string; column: string; from: string }
   /** An unmarked drop+add that *might* be a rename — a hint comment, the SQL still drops+adds. */
   | { kind: 'renameHint'; table: string; from: string; to: string }
+  /** A table-level `renamedFrom` satisfied: old table present, new absent → one RENAME, data preserved. */
+  | { kind: 'renameTable'; from: string; to: string }
+  /** A table marker whose rename is already applied (new name present) — inert, a notice. */
+  | { kind: 'renameTableSatisfied'; table: string; from: string }
+  /** A table marker pointing at a table the database doesn't have — fell back to CREATE, a notice. */
+  | { kind: 'renameTableSourceMissing'; table: string; from: string }
   /** A new enum type → `CREATE TYPE … AS ENUM (…)`, emitted before the tables that use it. */
   | { kind: 'createType'; name: string; values: string[] }
   /** A value appended to an existing enum → `ALTER TYPE … ADD VALUE` (carries a -- WARNING). */
@@ -86,6 +92,14 @@ export type SchemaChange =
  */
 export type RenameMap = Record<string, Record<string, string>>;
 
+/**
+ * Table-level rename intent: qualified new name → qualified old name. Produced
+ * by `compileTableRenames` off the Models' `renamedFrom` option; consumed by
+ * `diffSchema`'s pre-pass, which rewrites the current snapshot (old table seen
+ * as the new name) so every downstream diff lands on the renamed table.
+ */
+export type TableRenameMap = Record<string, string>;
+
 // ---------------------------------------------------------------------------
 // Normalization — so semantically-equal expressions don't read as drift.
 // ---------------------------------------------------------------------------
@@ -232,8 +246,9 @@ export function normalizeCheck(expr: string): string {
  * replaced constraint never clashes with its old self and a column is never dropped out
  * from under a constraint that still references it.
  */
-export function diffSchema(desired: SchemaSnapshot, current: SchemaSnapshot, renames: RenameMap = {}): SchemaChange[] {
+export function diffSchema(desired: SchemaSnapshot, current: SchemaSnapshot, renames: RenameMap = {}, tableRenames: TableRenameMap = {}): SchemaChange[] {
   const creates: SchemaChange[] = [];
+  const renameTables: SchemaChange[] = [];
   const renameColumns: SchemaChange[] = [];
   const addColumns: SchemaChange[] = [];
   const alters: SchemaChange[] = [];
@@ -248,6 +263,28 @@ export function diffSchema(desired: SchemaSnapshot, current: SchemaSnapshot, ren
   const currentByName = new Map(current.tables.map((t) => [t.table, t]));
   const desiredNames = new Set(desired.tables.map((t) => t.table));
 
+  // Table-rename pre-pass: honor the Models' table-level `renamedFrom` before
+  // any matching. A satisfied rename rewrites the current snapshot — the old
+  // table is seen under its new name — so every downstream diff (columns,
+  // constraints, indexes, drops) lands on the renamed table, and the old name
+  // never reaches the dropTables sweep. Mirrors the column-rename semantics:
+  // new-name-present → inert notice; source missing → CREATE path + notice.
+  for (const [to, from] of Object.entries(tableRenames)) {
+    if (!desiredNames.has(to)) continue; // the marker's model isn't in this diff
+    if (currentByName.has(to)) {
+      notices.push({ kind: 'renameTableSatisfied', table: to, from });
+      continue;
+    }
+    const source = currentByName.get(from);
+    if (!source) {
+      notices.push({ kind: 'renameTableSourceMissing', table: to, from });
+      continue;
+    }
+    renameTables.push({ kind: 'renameTable', from, to });
+    currentByName.delete(from);
+    currentByName.set(to, { ...source, table: to });
+  }
+
   for (const d of desired.tables) {
     const c = currentByName.get(d.table);
     if (!c) {
@@ -274,18 +311,21 @@ export function diffSchema(desired: SchemaSnapshot, current: SchemaSnapshot, ren
     diffIndexes(d, c, createIndexes, dropIndexes);
   }
 
-  for (const c of current.tables) {
+  // Sweep the POST-RENAME view: a renamed-away old name is not a drop.
+  for (const c of currentByName.values()) {
     if (!desiredNames.has(c.table)) dropTables.push({ kind: 'dropTable', table: c.table });
   }
 
   const e = diffEnums(desired.enums ?? [], current.enums ?? []);
 
   // Enum types come first (a table or column may reference one); value adds before the
-  // columns that use them. Renames run before adds (a rename frees a name an add may
-  // reuse) and before alters (which target the new name). Enum drops sit with the other
-  // removals; notices are comments — emitted last, after the DDL.
+  // columns that use them. Table renames run before creates (a rename frees a name a
+  // create may reuse) and before every per-table change (which all target the new name).
+  // Column renames run before adds and alters for the same reason. Enum drops sit with
+  // the other removals; notices are comments — emitted last, after the DDL.
   return [
     ...e.creates, ...e.adds,
+    ...renameTables,
     ...creates, ...renameColumns, ...addColumns, ...alters,
     ...dropConstraints, ...addConstraints, ...createIndexes,
     ...dropColumns, ...dropIndexes, ...dropTables,
@@ -613,6 +653,13 @@ function emitOne(change: SchemaChange, opts: EmitOptions): string {
       return `-- NOTICE: primary key on ${change.table} changed (${change.from.join(', ')} → ${change.to.join(', ')}); dropping a primary key needs its constraint name — regenerate this change manually.`;
     case 'renameColumn':
       return `ALTER TABLE ${change.table} RENAME COLUMN ${quote(change.from)} TO ${quote(change.to)};`;
+    case 'renameTable':
+      // RENAME TO takes a bare name — the table stays in its schema.
+      return `ALTER TABLE ${change.from} RENAME TO ${quote(change.to.split('.').pop()!)};`;
+    case 'renameTableSatisfied':
+      return `-- NOTICE: the renamedFrom marker on table ${change.table} is satisfied — the rename from "${change.from}" is applied, the marker is now inert and can be removed.`;
+    case 'renameTableSourceMissing':
+      return `-- NOTICE: table ${change.table} declares renamedFrom "${change.from}", but the database has neither — created fresh; remove the marker once every environment is past it.`;
     case 'renameSatisfied':
       return `-- NOTICE: the renamedFrom marker on column ${quote(change.column)} (${change.table}) is satisfied — the rename from "${change.from}" is applied, the marker is now inert and can be removed.`;
     case 'renameSourceMissing':