@supabase/pg-delta 1.0.0-alpha.10 → 1.0.0-alpha.12

package/src/core/objects/sequence/changes/sequence.drop.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Sequence } from "../sequence.model.ts";
 import { DropSequenceChange } from "./sequence.base.ts";
 
@@ -28,10 +29,22 @@ export class DropSequence extends DropSequenceChange {
     return [this.sequence.stableId];
   }
 
-  serialize(): string {
-    return [
+  serialize(_options?: SerializeOptions): string {
+    const parts = [
       "DROP SEQUENCE",
       `${this.sequence.schema}.${this.sequence.name}`,
-    ].join(" ");
+    ];
+
+    // Owned sequences still need CASCADE here because DROP runs in the earlier
+    // phase and later ALTER TABLE statements will re-establish the desired default.
+    if (
+      this.sequence.owned_by_schema &&
+      this.sequence.owned_by_table &&
+      this.sequence.owned_by_column
+    ) {
+      parts.push("CASCADE");
+    }
+
+    return parts.join(" ");
   }
 }

package/src/core/objects/sequence/changes/sequence.privilege.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import {
   formatObjectPrivilegeList,
   getObjectKindPrefix,
@@ -54,7 +55,7 @@ export class GrantSequencePrivileges extends AlterSequenceChange {
     return [this.sequence.stableId, stableId.role(this.grantee)];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const hasGrantable = this.privileges.some((p) => p.grantable);
     const hasBase = this.privileges.some((p) => !p.grantable);
     if (hasGrantable && hasBase) {
@@ -122,7 +123,7 @@ export class RevokeSequencePrivileges extends AlterSequenceChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const kindPrefix = getObjectKindPrefix("SEQUENCE");
     const list = this.privileges.map((p) => p.privilege);
     const privSql = formatObjectPrivilegeList("SEQUENCE", list, this.version);
@@ -166,7 +167,7 @@ export class RevokeGrantOptionSequencePrivileges extends AlterSequenceChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const kindPrefix = getObjectKindPrefix("SEQUENCE");
     const privSql = formatObjectPrivilegeList(
       "SEQUENCE",

package/src/core/objects/sequence/changes/sequence.types.ts

@@ -4,6 +4,7 @@ import type { CreateSequence } from "./sequence.create.ts";
 import type { DropSequence } from "./sequence.drop.ts";
 import type { SequencePrivilege } from "./sequence.privilege.ts";
 
+/** Union of all sequence-related change variants (`objectType: "sequence"`). @category Change Types */
 export type SequenceChange =
   | AlterSequence
   | CommentSequence

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { DefaultPrivilegeState } from "../base.default-privileges.ts";
-import type { Table } from "../table/table.model.ts";
+import { AlterTableAlterColumnSetDefault } from "../table/changes/table.alter.ts";
+import { Table } from "../table/table.model.ts";
 import {
   AlterSequenceSetOptions,
   AlterSequenceSetOwnedBy,
@@ -107,6 +108,77 @@ describe.concurrent("sequence.diff", () => {
     expect(changes[1]).toBeInstanceOf(CreateSequence);
   });
 
+  test("replacing an owned sequence re-emits the owning column default", () => {
+    const main = new Sequence({
+      ...base,
+      data_type: "integer",
+      owned_by_schema: "public",
+      owned_by_table: "users",
+      owned_by_column: "id",
+    });
+    const branch = new Sequence({
+      ...base,
+      owned_by_schema: "public",
+      owned_by_table: "users",
+      owned_by_column: "id",
+    });
+    const branchTable = new Table({
+      schema: "public",
+      name: "users",
+      persistence: "p",
+      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",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "test",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "bigint",
+          data_type_str: "bigint",
+          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.seq1'::regclass)",
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+
+    const changes = diffSequences(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+      { [branchTable.stableId]: branchTable },
+    );
+
+    expect(changes).toHaveLength(4);
+    expect(changes[0]).toBeInstanceOf(DropSequence);
+    expect(changes[1]).toBeInstanceOf(CreateSequence);
+    expect(changes[2]).toBeInstanceOf(AlterSequenceSetOwnedBy);
+    expect(changes[3]).toBeInstanceOf(AlterTableAlterColumnSetDefault);
+  });
+
   test("skip DROP SEQUENCE when owned by table being dropped", () => {
     const ownedSequence = new Sequence({
       ...base,

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

@@ -4,6 +4,7 @@ import {
   emitObjectPrivilegeChanges,
 } from "../base.privilege-diff.ts";
 import type { ObjectDiffContext } from "../diff-context.ts";
+import { AlterTableAlterColumnSetDefault } from "../table/changes/table.alter.ts";
 import type { Table } from "../table/table.model.ts";
 import { hasNonAlterableChanges } from "../utils.ts";
 import {
@@ -24,6 +25,10 @@ import {
 import type { SequenceChange } from "./changes/sequence.types.ts";
 import type { Sequence } from "./sequence.model.ts";
 
+type SequenceOrColumnSetDefaultChange =
+  | AlterTableAlterColumnSetDefault
+  | SequenceChange;
+
 /**
  * Diff two sets of sequences from main and branch catalogs.
  *
@@ -41,10 +46,10 @@ export function diffSequences(
   main: Record<string, Sequence>,
   branch: Record<string, Sequence>,
   branchTables: Record<string, Table> = {},
-): SequenceChange[] {
+): SequenceOrColumnSetDefaultChange[] {
   const { created, dropped, altered } = diffObjects(main, branch);
 
-  const changes: SequenceChange[] = [];
+  const changes: SequenceOrColumnSetDefaultChange[] = [];
 
   for (const sequenceId of created) {
     const createdSeq = branch[sequenceId];
@@ -157,6 +162,12 @@ export function diffSequences(
         branchSequence.owned_by_table !== null &&
         branchSequence.owned_by_column !== null
       ) {
+        const ownedByTableId = `table:${branchSequence.owned_by_schema}.${branchSequence.owned_by_table}`;
+        const ownedByTable = branchTables[ownedByTableId];
+        const ownedByColumn = ownedByTable?.columns?.find(
+          (column) => column.name === branchSequence.owned_by_column,
+        );
+
         changes.push(
           new AlterSequenceSetOwnedBy({
             sequence: branchSequence,
@@ -167,6 +178,17 @@ export function diffSequences(
             } as { schema: string; table: string; column: string },
           }),
         );
+
+        // Replacing an owned sequence with DROP ... CASCADE removes the column's
+        // existing nextval(...) default, so restore it after ownership is reattached.
+        if (ownedByTable && ownedByColumn && ownedByColumn.default !== null) {
+          changes.push(
+            new AlterTableAlterColumnSetDefault({
+              table: ownedByTable,
+              column: ownedByColumn,
+            }),
+          );
+        }
       } else if (
         mainSequence.owned_by_schema !== null ||
         mainSequence.owned_by_table !== null ||

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import { quoteLiteral } from "../../base.change.ts";
 import { stableId } from "../../utils.ts";
 import type { Subscription } from "../subscription.model.ts";
@@ -16,7 +17,7 @@ export class AlterSubscriptionSetConnection extends AlterSubscriptionChange {
     this.subscription = props.subscription;
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return `ALTER SUBSCRIPTION ${this.subscription.name} CONNECTION ${quoteLiteral(this.subscription.conninfo)}`;
   }
 }
@@ -30,7 +31,7 @@ export class AlterSubscriptionSetPublication extends AlterSubscriptionChange {
     this.subscription = props.subscription;
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const base = `ALTER SUBSCRIPTION ${this.subscription.name} SET PUBLICATION ${this.subscription.publications.join(", ")}`;
     if (!this.subscription.enabled) {
       return `${base} WITH (refresh = false)`;
@@ -48,7 +49,7 @@ export class AlterSubscriptionEnable extends AlterSubscriptionChange {
     this.subscription = props.subscription;
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return `ALTER SUBSCRIPTION ${this.subscription.name} ENABLE`;
   }
 }
@@ -62,7 +63,7 @@ export class AlterSubscriptionDisable extends AlterSubscriptionChange {
     this.subscription = props.subscription;
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return `ALTER SUBSCRIPTION ${this.subscription.name} DISABLE`;
   }
 }
@@ -81,7 +82,7 @@ export class AlterSubscriptionSetOptions extends AlterSubscriptionChange {
     this.options = props.options;
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const assignments = this.options.map((option) =>
       formatSubscriptionOption(this.subscription, option),
     );
@@ -104,7 +105,7 @@ export class AlterSubscriptionSetOwner extends AlterSubscriptionChange {
     return [stableId.role(this.owner)];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return `ALTER SUBSCRIPTION ${this.subscription.name} OWNER TO ${this.owner}`;
   }
 }

package/src/core/objects/subscription/changes/subscription.comment.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import { quoteLiteral } from "../../base.change.ts";
 import { stableId } from "../../utils.ts";
 import type { Subscription } from "../subscription.model.ts";
@@ -27,7 +28,7 @@ export class CreateCommentOnSubscription extends CreateSubscriptionChange {
     return [this.subscription.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON SUBSCRIPTION",
       this.subscription.name,
@@ -58,7 +59,7 @@ export class DropCommentOnSubscription extends DropSubscriptionChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return `COMMENT ON SUBSCRIPTION ${this.subscription.name} IS NULL`;
   }
 }

package/src/core/objects/subscription/changes/subscription.create.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 // src/objects/subscription/changes/subscription.create.ts
 import { quoteLiteral } from "../../base.change.ts";
 import { stableId } from "../../utils.ts";
@@ -22,7 +23,7 @@ export class CreateSubscription extends CreateSubscriptionChange {
     return [stableId.role(this.subscription.owner)];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const parts: string[] = [
       "CREATE SUBSCRIPTION",
       this.subscription.name,

package/src/core/objects/subscription/changes/subscription.drop.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Subscription } from "../subscription.model.ts";
 import { DropSubscriptionChange } from "./subscription.base.ts";
 
@@ -14,7 +15,7 @@ export class DropSubscription extends DropSubscriptionChange {
     return [this.subscription.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return `DROP SUBSCRIPTION ${this.subscription.name}`;
   }
 }

package/src/core/objects/subscription/changes/subscription.types.ts

@@ -10,6 +10,7 @@ import type { CommentSubscription } from "./subscription.comment.ts";
 import type { CreateSubscription } from "./subscription.create.ts";
 import type { DropSubscription } from "./subscription.drop.ts";
 
+/** Union of all subscription-related change variants (`objectType: "subscription"`). @category Change Types */
 export type SubscriptionChange =
   | CreateSubscription
   | DropSubscription

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

@@ -5,9 +5,12 @@ import { Table, type TableProps } from "../table.model.ts";
 import {
   AlterTableAddColumn,
   AlterTableAddConstraint,
+  AlterTableAlterColumnAddIdentity,
   AlterTableAlterColumnDropDefault,
+  AlterTableAlterColumnDropIdentity,
   AlterTableAlterColumnDropNotNull,
   AlterTableAlterColumnSetDefault,
+  AlterTableAlterColumnSetGenerated,
   AlterTableAlterColumnSetNotNull,
   AlterTableAlterColumnType,
   AlterTableAttachPartition,
@@ -498,6 +501,41 @@ describe.concurrent("table", () => {
         "ALTER TABLE public.test_table ALTER COLUMN a DROP DEFAULT",
       );
 
+      const changeAddIdentity = new AlterTableAlterColumnAddIdentity({
+        table: withCols,
+        column: {
+          ...colInt,
+          is_identity: true,
+          is_identity_always: true,
+        },
+      });
+      await assertValidSql(changeAddIdentity.serialize());
+      expect(changeAddIdentity.serialize()).toBe(
+        "ALTER TABLE public.test_table ALTER COLUMN a ADD GENERATED ALWAYS AS IDENTITY",
+      );
+
+      const changeSetGenerated = new AlterTableAlterColumnSetGenerated({
+        table: withCols,
+        column: {
+          ...colInt,
+          is_identity: true,
+          is_identity_always: false,
+        },
+      });
+      await assertValidSql(changeSetGenerated.serialize());
+      expect(changeSetGenerated.serialize()).toBe(
+        "ALTER TABLE public.test_table ALTER COLUMN a SET GENERATED BY DEFAULT",
+      );
+
+      const changeDropIdentity = new AlterTableAlterColumnDropIdentity({
+        table: withCols,
+        column: { ...colInt },
+      });
+      await assertValidSql(changeDropIdentity.serialize());
+      expect(changeDropIdentity.serialize()).toBe(
+        "ALTER TABLE public.test_table ALTER COLUMN a DROP IDENTITY",
+      );
+
       const changeSetNotNull = new AlterTableAlterColumnSetNotNull({
         table: withCols,
         column: { ...colInt, not_null: true },