@supabase/pg-delta 1.0.0-alpha.20 → 1.0.0-alpha.22

package/src/core/objects/sequence/sequence.diff.test.ts

@@ -109,15 +109,20 @@ describe.concurrent("sequence.diff", () => {
   });
 
   test("replacing an owned sequence re-emits the owning column default", () => {
+    // Use `persistence` (UNLOGGED → LOGGED) to trigger the
+    // non-alterable replace path: it's the only field still in
+    // NON_ALTERABLE_FIELDS. `data_type` was previously in that list
+    // but is now alterable in place via ALTER SEQUENCE ... AS <type>.
     const main = new Sequence({
       ...base,
-      data_type: "integer",
+      persistence: "u",
       owned_by_schema: "public",
       owned_by_table: "users",
       owned_by_column: "id",
     });
     const branch = new Sequence({
       ...base,
+      persistence: "p",
       owned_by_schema: "public",
       owned_by_table: "users",
       owned_by_column: "id",
@@ -322,6 +327,93 @@ describe.concurrent("sequence.diff", () => {
     expect(changes).toHaveLength(0);
   });
 
+  test("recreate same-name sequence when owning table is renamed away", () => {
+    // Reproduces issue #228 case 1: a SERIAL column's table is renamed
+    // (`old_table` → `new_table`). The sequence keeps the same name
+    // (`old_table_id_seq`) but its OWNED BY now points at `new_table.id`.
+    // PostgreSQL cascade-drops the sequence with the old table, so a later
+    // CREATE TABLE that references `old_table_id_seq` fails. The diff must
+    // emit CreateSequence (and skip the explicit DropSequence to avoid an
+    // unbreakable cycle with the DropTable).
+    const tableColumn = {
+      name: "id",
+      position: 1,
+      data_type: "integer",
+      data_type_str: "integer",
+      is_custom_type: false,
+      custom_type_type: null,
+      custom_type_category: null,
+      custom_type_schema: null,
+      custom_type_name: null,
+      not_null: true,
+      is_identity: false,
+      is_identity_always: false,
+      is_generated: false,
+      collation: null,
+      default: "nextval('public.old_table_id_seq'::regclass)",
+      comment: null,
+    };
+    const tableBaseProps = {
+      schema: "public",
+      persistence: "p" as const,
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: true,
+      replica_identity: "d" as const,
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "test",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      privileges: [],
+    };
+    const oldTable = new Table({
+      ...tableBaseProps,
+      name: "old_table",
+      columns: [tableColumn],
+    });
+    const newTable = new Table({
+      ...tableBaseProps,
+      name: "new_table",
+      columns: [tableColumn],
+    });
+    const mainSequence = new Sequence({
+      ...base,
+      name: "old_table_id_seq",
+      owned_by_schema: "public",
+      owned_by_table: "old_table",
+      owned_by_column: "id",
+    });
+    const branchSequence = new Sequence({
+      ...base,
+      name: "old_table_id_seq",
+      owned_by_schema: "public",
+      owned_by_table: "new_table",
+      owned_by_column: "id",
+    });
+
+    const changes = diffSequences(
+      testContext,
+      { [mainSequence.stableId]: mainSequence },
+      { [branchSequence.stableId]: branchSequence },
+      { [newTable.stableId]: newTable },
+      { [oldTable.stableId]: oldTable },
+    );
+
+    expect(changes.some((c) => c instanceof DropSequence)).toBe(false);
+    expect(changes.some((c) => c instanceof CreateSequence)).toBe(true);
+    expect(changes.some((c) => c instanceof AlterSequenceSetOwnedBy)).toBe(
+      true,
+    );
+  });
+
   test("create with comment emits CreateCommentOnSequence", () => {
     const s = new Sequence({ ...base, comment: "my seq" });
     const changes = diffSequences(testContext, {}, { [s.stableId]: s });

package/src/core/objects/sequence/sequence.diff.ts

@@ -36,6 +36,7 @@ type SequenceOrColumnSetDefaultChange =
  * @param main - The sequences in the main catalog.
  * @param branch - The sequences in the branch catalog.
  * @param branchTables - The tables in the branch catalog (used to check if owning tables are being dropped).
+ * @param mainTables - The tables in the main catalog (used to detect when a same-name sequence will be cascade-dropped because its main-side owning table is going away).
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffSequences(
@@ -46,6 +47,7 @@ export function diffSequences(
   main: Record<string, Sequence>,
   branch: Record<string, Sequence>,
   branchTables: Record<string, Table> = {},
+  mainTables: Record<string, Table> = {},
 ): SequenceOrColumnSetDefaultChange[] {
   const { created, dropped, altered } = diffObjects(main, branch);
 
@@ -150,22 +152,42 @@ export function diffSequences(
 
     // Check if non-alterable properties have changed
     // These require dropping and recreating the sequence
-    const NON_ALTERABLE_FIELDS: Array<keyof Sequence> = [
-      "data_type",
-      "persistence",
-    ];
+    const NON_ALTERABLE_FIELDS: Array<keyof Sequence> = ["persistence"];
     const nonAlterablePropsChanged = hasNonAlterableChanges(
       mainSequence,
       branchSequence,
       NON_ALTERABLE_FIELDS,
     );
 
-    if (nonAlterablePropsChanged) {
-      // Replace the entire sequence (drop + create)
-      changes.push(
-        new DropSequence({ sequence: mainSequence }),
-        new CreateSequence({ sequence: branchSequence }),
-      );
+    // A sequence kept the same name (so it's "altered" in catalog terms),
+    // but its main-side owning table is going away from the plan (renamed
+    // away or simply dropped). PostgreSQL will cascade-drop the sequence
+    // alongside the table, leaving any later CREATE TABLE / column-default
+    // that depends on the sequence name pointing at nothing. Treat this
+    // like a non-alterable change so we recreate the sequence after the
+    // owning table is dropped.
+    const mainOwnedByTableId =
+      mainSequence.owned_by_schema && mainSequence.owned_by_table
+        ? `table:${mainSequence.owned_by_schema}.${mainSequence.owned_by_table}`
+        : null;
+    const cascadeOrphanedByOwningTable =
+      mainOwnedByTableId !== null &&
+      mainTables[mainOwnedByTableId] !== undefined &&
+      branchTables[mainOwnedByTableId] === undefined;
+
+    if (nonAlterablePropsChanged || cascadeOrphanedByOwningTable) {
+      // When the owning table is going away in this plan, PostgreSQL will
+      // cascade-drop the sequence as part of the DROP TABLE. Emitting an
+      // explicit DROP SEQUENCE here would (a) introduce an unbreakable
+      // DropSequence ↔ DropTable cycle on the catalog edges between the
+      // sequence and the dropped column, and (b) be redundant with the
+      // cascade. The CreateSequence below restores the sequence under its
+      // original name so any same-name reference in a later CREATE TABLE
+      // resolves correctly.
+      if (!cascadeOrphanedByOwningTable) {
+        changes.push(new DropSequence({ sequence: mainSequence }));
+      }
+      changes.push(new CreateSequence({ sequence: branchSequence }));
       // Re-apply OWNED BY if present on branch
       if (
         branchSequence.owned_by_schema !== null &&
@@ -215,6 +237,7 @@ export function diffSequences(
     } else {
       // Only alterable properties changed - emit ALTER for options/owner
       const optionsChanged =
+        mainSequence.data_type !== branchSequence.data_type ||
         mainSequence.increment !== branchSequence.increment ||
         mainSequence.minimum_value !== branchSequence.minimum_value ||
         mainSequence.maximum_value !== branchSequence.maximum_value ||
@@ -224,6 +247,16 @@ export function diffSequences(
 
       if (optionsChanged) {
         const options: string[] = [];
+        // `AS <type>` must come before any MIN/MAX/RESTART clauses per the
+        // PG ALTER SEQUENCE grammar. Valid types are smallint, integer,
+        // bigint — the same set CREATE SEQUENCE accepts — so the universe
+        // of legal transitions is closed. PG enforces last_value range at
+        // apply time when shrinking; that's the desired behavior because
+        // the previous Drop+Create path silently reset last_value to 1
+        // (data-loss bug, see Sentry SUPABASE-API-7RS).
+        if (mainSequence.data_type !== branchSequence.data_type) {
+          options.push("AS", branchSequence.data_type);
+        }
         if (mainSequence.increment !== branchSequence.increment) {
           options.push("INCREMENT BY", String(branchSequence.increment));
         }

package/src/core/objects/table/changes/table.alter.test.ts

@@ -343,7 +343,7 @@ describe.concurrent("table", () => {
       ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY FULL");
     });
 
-    test("replica identity DEFAULT and INDEX fallback", async () => {
+    test("replica identity DEFAULT and USING INDEX", async () => {
       const baseProps: Omit<
         TableProps,
         "owner" | "options" | "replica_identity"
@@ -372,31 +372,23 @@ describe.concurrent("table", () => {
         options: null,
         replica_identity: "n",
       });
-      const toDefault = new Table({
-        ...baseProps,
-        owner: "o1",
-        options: null,
-        replica_identity: "d",
-      });
-      const toIndex = new Table({
-        ...baseProps,
-        owner: "o1",
-        options: null,
-        replica_identity: "i",
-      });
-      expect(
-        new AlterTableSetReplicaIdentity({
-          table,
-          mode: toDefault.replica_identity,
-        }).serialize(),
-      ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY DEFAULT");
-      // AlterTableSetReplicaIdentity of type "i" will not be emitted in diff, it is handled by index changes, we fallback to DEFAULT here
       expect(
         new AlterTableSetReplicaIdentity({
           table,
-          mode: toIndex.replica_identity,
+          mode: "d",
         }).serialize(),
       ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY DEFAULT");
+      const usingIndex = new AlterTableSetReplicaIdentity({
+        table,
+        mode: "i",
+        indexName: "test_table_pkey",
+      });
+      expect(usingIndex.serialize()).toBe(
+        "ALTER TABLE public.test_table REPLICA IDENTITY USING INDEX test_table_pkey",
+      );
+      expect(usingIndex.requires).toContain(
+        "index:public.test_table.test_table_pkey",
+      );
     });
 
     test("columns add/drop/alter", async () => {
@@ -444,6 +436,11 @@ describe.concurrent("table", () => {
         data_type: "text",
         data_type_str: "text",
       };
+      const colTextBefore: ColumnProps = {
+        ...colText,
+        data_type: "integer",
+        data_type_str: "integer",
+      };
       const withCols = new Table({
         ...tableProps,
         owner: "o1",
@@ -477,10 +474,11 @@ describe.concurrent("table", () => {
       const changeType = new AlterTableAlterColumnType({
         table: withCols,
         column: colText,
+        previousColumn: colTextBefore,
       });
       await assertValidSql(changeType.serialize());
       expect(changeType.serialize()).toBe(
-        "ALTER TABLE public.test_table ALTER COLUMN b TYPE text",
+        "ALTER TABLE public.test_table ALTER COLUMN b TYPE text USING b::text",
       );
 
       const changeSetDefault = new AlterTableAlterColumnSetDefault({
@@ -659,10 +657,15 @@ describe.concurrent("table", () => {
       const change = new AlterTableAlterColumnType({
         table: withCols,
         column: col,
+        previousColumn: {
+          ...col,
+          data_type: "integer",
+          data_type_str: "integer",
+        },
       });
       await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
-        "ALTER TABLE public.test_table ALTER COLUMN b TYPE text COLLATE mycoll",
+        "ALTER TABLE public.test_table ALTER COLUMN b TYPE text COLLATE mycoll USING b::text",
       );
     });
 

package/src/core/objects/table/changes/table.alter.ts

@@ -462,20 +462,46 @@ export class AlterTableValidateConstraint extends AlterTableChange {
 
 /**
  * ALTER TABLE ... REPLICA IDENTITY ...
+ *
+ * When `mode === "i"` (USING INDEX), `indexName` is the name of the index to
+ * use. The extractor populates `Table.replica_identity_index` from
+ * `pg_index.indisreplident` whenever `Table.replica_identity` is `'i'`, so
+ * callers that source their props from a `Table` instance can rely on the
+ * pair being consistent. The non-null assertions in `requires` / `serialize`
+ * below are justified by that data invariant — the same pattern the FK
+ * branch of `AlterTableAddConstraint` uses for `foreign_key_columns!` /
+ * `foreign_key_table!` / `foreign_key_schema!`.
  */
 export class AlterTableSetReplicaIdentity extends AlterTableChange {
   public readonly table: Table;
   public readonly mode: "d" | "n" | "f" | "i";
+  public readonly indexName: string | null;
   public readonly scope = "object" as const;
 
-  constructor(props: { table: Table; mode: "d" | "n" | "f" | "i" }) {
+  constructor(props: {
+    table: Table;
+    mode: "d" | "n" | "f" | "i";
+    indexName?: string | null;
+  }) {
     super();
     this.table = props.table;
     this.mode = props.mode;
+    this.indexName = props.indexName ?? null;
   }
 
   get requires() {
-    return [this.table.stableId];
+    const reqs: string[] = [this.table.stableId];
+    if (this.mode === "i") {
+      reqs.push(
+        stableId.index(
+          this.table.schema,
+          this.table.name,
+          // biome-ignore lint/style/noNonNullAssertion: mode 'i' implies the extractor populated replica_identity_index
+          this.indexName!,
+        ),
+      );
+    }
+    return reqs;
   }
 
   serialize(_options?: SerializeOptions): string {
@@ -486,7 +512,8 @@ export class AlterTableSetReplicaIdentity extends AlterTableChange {
           ? "NOTHING"
           : this.mode === "f"
             ? "FULL"
-            : "DEFAULT"; // 'i' (USING INDEX) is handled via index changes; fallback to DEFAULT
+            : // biome-ignore lint/style/noNonNullAssertion: mode 'i' implies the extractor populated replica_identity_index
+              `USING INDEX ${this.indexName!}`;
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -556,11 +583,21 @@ export class AlterTableDropColumn extends AlterTableChange {
   public readonly table: Table;
   public readonly column: ColumnProps;
   public readonly scope = "object" as const;
-
-  constructor(props: { table: Table; column: ColumnProps }) {
+  // Drop the implicit `requires(table)` edge. Only set by the lazy
+  // cycle-breaker for the publication↔column case, where the table survives
+  // the migration and the edge is therefore artificial. See
+  // `sort/cycle-breakers.ts` for the full justification.
+  public readonly omitTableRequirement: boolean;
+
+  constructor(props: {
+    table: Table;
+    column: ColumnProps;
+    omitTableRequirement?: boolean;
+  }) {
     super();
     this.table = props.table;
     this.column = props.column;
+    this.omitTableRequirement = props.omitTableRequirement ?? false;
   }
 
   get drops() {
@@ -570,10 +607,12 @@ export class AlterTableDropColumn extends AlterTableChange {
   }
 
   get requires() {
-    return [
-      this.table.stableId,
-      stableId.column(this.table.schema, this.table.name, this.column.name),
-    ];
+    const colId = stableId.column(
+      this.table.schema,
+      this.table.name,
+      this.column.name,
+    );
+    return this.omitTableRequirement ? [colId] : [this.table.stableId, colId];
   }
 
   serialize(_options?: SerializeOptions): string {
@@ -592,12 +631,18 @@ export class AlterTableDropColumn extends AlterTableChange {
 export class AlterTableAlterColumnType extends AlterTableChange {
   public readonly table: Table;
   public readonly column: ColumnProps;
+  public readonly previousColumn?: ColumnProps;
   public readonly scope = "object" as const;
 
-  constructor(props: { table: Table; column: ColumnProps }) {
+  constructor(props: {
+    table: Table;
+    column: ColumnProps;
+    previousColumn?: ColumnProps;
+  }) {
     super();
     this.table = props.table;
     this.column = props.column;
+    this.previousColumn = props.previousColumn;
   }
 
   get requires() {
@@ -607,6 +652,14 @@ export class AlterTableAlterColumnType extends AlterTableChange {
   }
 
   serialize(_options?: SerializeOptions): string {
+    // previousColumn is optional so direct serializer tests/fixtures can keep
+    // emitting canonical ALTER TYPE SQL without forcing a USING expression.
+    // When provided, we can detect true type changes and add USING for casts
+    // PostgreSQL cannot perform automatically.
+    const hasTypeChangedWithPreviousDefinition =
+      this.previousColumn?.data_type_str !== undefined &&
+      this.previousColumn.data_type_str !== this.column.data_type_str;
+
     const parts: string[] = [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -618,6 +671,9 @@ export class AlterTableAlterColumnType extends AlterTableChange {
     if (this.column.collation) {
       parts.push("COLLATE", this.column.collation);
     }
+    if (hasTypeChangedWithPreviousDefinition) {
+      parts.push("USING", `${this.column.name}::${this.column.data_type_str}`);
+    }
     return parts.join(" ");
   }
 }

package/src/core/objects/table/table.diff.test.ts

@@ -767,6 +767,9 @@ describe.concurrent("table.diff", () => {
     expect(
       typeChanges.some((c) => c instanceof AlterTableAlterColumnType),
     ).toBe(true);
+    expect(typeChanges.map((c) => c.serialize())).toContain(
+      "ALTER TABLE public.t2 ALTER COLUMN a TYPE text USING a::text",
+    );
 
     const defaultAdded = new Table({
       ...base,
@@ -817,6 +820,46 @@ describe.concurrent("table.diff", () => {
     expect(
       notNullDropped.some((c) => c instanceof AlterTableAlterColumnDropNotNull),
     ).toBe(true);
+
+    const withDefault = new Table({
+      ...base,
+      name: "t2",
+      columns: [
+        {
+          ...withCol.columns[0],
+          data_type: "text",
+          data_type_str: "text",
+          default: "'active'",
+        },
+      ],
+    });
+    const typeChangedWithDefault = new Table({
+      ...base,
+      name: "t2",
+      columns: [
+        {
+          ...withDefault.columns[0],
+          data_type: "USER-DEFINED",
+          data_type_str: "test_schema.status",
+          is_custom_type: true,
+          custom_type_type: "e",
+          custom_type_category: "E",
+          custom_type_schema: "test_schema",
+          custom_type_name: "status",
+          default: "'active'::test_schema.status",
+        },
+      ],
+    });
+    const typeChangesWithDefault = diffTables(
+      testContext,
+      { [withDefault.stableId]: withDefault },
+      { [typeChangedWithDefault.stableId]: typeChangedWithDefault },
+    );
+    expect(typeChangesWithDefault.map((c) => c.serialize())).toEqual([
+      "ALTER TABLE public.t2 ALTER COLUMN a DROP DEFAULT",
+      "ALTER TABLE public.t2 ALTER COLUMN a TYPE test_schema.status USING a::test_schema.status",
+      "ALTER TABLE public.t2 ALTER COLUMN a SET DEFAULT 'active'::test_schema.status",
+    ]);
   });
 
   test("identity transitions emit drop/add/set-generated changes", () => {

package/src/core/objects/table/table.diff.ts

@@ -245,15 +245,13 @@ export function diffTables(
 
     // REPLICA IDENTITY: If non-default, emit ALTER TABLE ... REPLICA IDENTITY
     if (branchTable.replica_identity !== "d") {
-      // Skip 'i' (USING INDEX) — handled by index changes
-      if (branchTable.replica_identity !== "i") {
-        changes.push(
-          new AlterTableSetReplicaIdentity({
-            table: branchTable,
-            mode: branchTable.replica_identity,
-          }),
-        );
-      }
+      changes.push(
+        new AlterTableSetReplicaIdentity({
+          table: branchTable,
+          mode: branchTable.replica_identity,
+          indexName: branchTable.replica_identity_index,
+        }),
+      );
     }
 
     changes.push(
@@ -404,16 +402,23 @@ export function diffTables(
     }
 
     // REPLICA IDENTITY
-    if (mainTable.replica_identity !== branchTable.replica_identity) {
-      // Skip when target is 'i' (USING INDEX) — handled by index changes
-      if (branchTable.replica_identity !== "i") {
-        changes.push(
-          new AlterTableSetReplicaIdentity({
-            table: mainTable,
-            mode: branchTable.replica_identity,
-          }),
-        );
-      }
+    // Re-emit when the mode changes, or when staying in 'i' mode but pointing
+    // at a different index. The index named on the branch must already exist
+    // before this ALTER runs; AlterTableSetReplicaIdentity declares that
+    // dependency in its `requires`.
+    const replicaIdentityChanged =
+      mainTable.replica_identity !== branchTable.replica_identity ||
+      (branchTable.replica_identity === "i" &&
+        mainTable.replica_identity_index !==
+          branchTable.replica_identity_index);
+    if (replicaIdentityChanged) {
+      changes.push(
+        new AlterTableSetReplicaIdentity({
+          table: mainTable,
+          mode: branchTable.replica_identity,
+          indexName: branchTable.replica_identity_index,
+        }),
+      );
     }
 
     // OWNER
@@ -701,19 +706,39 @@ export function diffTables(
       const branchCol = branchCols.get(name);
       if (!branchCol) continue;
 
+      const columnTypeChanged =
+        mainCol.data_type_str !== branchCol.data_type_str;
+      const columnCollationChanged = mainCol.collation !== branchCol.collation;
+      const needsDefaultSafeFlow =
+        columnTypeChanged && mainCol.default !== null;
+
       // TYPE or COLLATION change
-      if (
-        mainCol.data_type_str !== branchCol.data_type_str ||
-        mainCol.collation !== branchCol.collation
-      ) {
+      if (columnTypeChanged || columnCollationChanged) {
         // Skip if parent has the same type/collation change
         if (!parentHasSameColumnPropertyChange(name, "type")) {
+          if (needsDefaultSafeFlow) {
+            changes.push(
+              new AlterTableAlterColumnDropDefault({
+                table: branchTable,
+                column: branchCol,
+              }),
+            );
+          }
           changes.push(
             new AlterTableAlterColumnType({
               table: branchTable,
               column: branchCol,
+              previousColumn: mainCol,
             }),
           );
+          if (needsDefaultSafeFlow && branchCol.default !== null) {
+            changes.push(
+              new AlterTableAlterColumnSetDefault({
+                table: branchTable,
+                column: branchCol,
+              }),
+            );
+          }
         }
       }
 
@@ -734,6 +759,10 @@ export function diffTables(
       if (mainCol.default !== branchCol.default) {
         // Skip if parent has the same default change
         if (!parentHasSameColumnPropertyChange(name, "default")) {
+          if (needsDefaultSafeFlow) {
+            // Defaults were already dropped/re-set in the type-change flow above.
+            continue;
+          }
           if (branchCol.default === null) {
             // Drop default value
             changes.push(