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

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { ColumnProps } from "../../base.model.ts";
 import { stableId } from "../../utils.ts";
 import type { Table, TableConstraintProps } from "../table.model.ts";
@@ -62,8 +63,11 @@ import { AlterTableChange } from "./table.base.ts";
 export type AlterTable =
   | AlterTableAddColumn
   | AlterTableAddConstraint
+  | AlterTableAlterColumnAddIdentity
   | AlterTableAlterColumnDropDefault
+  | AlterTableAlterColumnDropIdentity
   | AlterTableAlterColumnDropNotNull
+  | AlterTableAlterColumnSetGenerated
   | AlterTableAlterColumnSetDefault
   | AlterTableAlterColumnSetNotNull
   | AlterTableAlterColumnType
@@ -101,7 +105,7 @@ export class AlterTableChangeOwner extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -127,7 +131,7 @@ export class AlterTableSetLogged extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -152,7 +156,7 @@ export class AlterTableSetUnlogged extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -177,7 +181,7 @@ export class AlterTableEnableRowLevelSecurity extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -202,7 +206,7 @@ export class AlterTableDisableRowLevelSecurity extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -227,7 +231,7 @@ export class AlterTableForceRowLevelSecurity extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -252,7 +256,7 @@ export class AlterTableNoForceRowLevelSecurity extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -279,7 +283,7 @@ export class AlterTableSetStorageParams extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const storageParams = this.options.join(", ");
     return [
       "ALTER TABLE",
@@ -307,7 +311,7 @@ export class AlterTableResetStorageParams extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const paramsSql = this.params.join(", ");
     return [
       "ALTER TABLE",
@@ -365,7 +369,7 @@ export class AlterTableAddConstraint extends AlterTableChange {
     return reqs;
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -411,7 +415,7 @@ export class AlterTableDropConstraint extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -446,7 +450,7 @@ export class AlterTableValidateConstraint extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -474,7 +478,7 @@ export class AlterTableSetReplicaIdentity extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const clause =
       this.mode === "d"
         ? "DEFAULT"
@@ -516,7 +520,7 @@ export class AlterTableAddColumn extends AlterTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const parts: string[] = [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -572,7 +576,7 @@ export class AlterTableDropColumn extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -602,7 +606,7 @@ export class AlterTableAlterColumnType extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const parts: string[] = [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -638,7 +642,7 @@ export class AlterTableAlterColumnSetDefault extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const set = this.column.is_generated ? "SET EXPRESSION AS" : "SET DEFAULT";
 
     return [
@@ -672,7 +676,7 @@ export class AlterTableAlterColumnDropDefault extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -683,6 +687,103 @@ export class AlterTableAlterColumnDropDefault extends AlterTableChange {
   }
 }
 
+/**
+ * ALTER TABLE ... ALTER COLUMN ... ADD GENERATED ... AS IDENTITY
+ */
+export class AlterTableAlterColumnAddIdentity extends AlterTableChange {
+  public readonly table: Table;
+  public readonly column: ColumnProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { table: Table; column: ColumnProps }) {
+    super();
+    this.table = props.table;
+    this.column = props.column;
+  }
+
+  get requires() {
+    return [
+      stableId.column(this.table.schema, this.table.name, this.column.name),
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER TABLE",
+      `${this.table.schema}.${this.table.name}`,
+      "ALTER COLUMN",
+      this.column.name,
+      "ADD",
+      this.column.is_identity_always
+        ? "GENERATED ALWAYS AS IDENTITY"
+        : "GENERATED BY DEFAULT AS IDENTITY",
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER TABLE ... ALTER COLUMN ... DROP IDENTITY
+ */
+export class AlterTableAlterColumnDropIdentity extends AlterTableChange {
+  public readonly table: Table;
+  public readonly column: ColumnProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { table: Table; column: ColumnProps }) {
+    super();
+    this.table = props.table;
+    this.column = props.column;
+  }
+
+  get requires() {
+    return [
+      stableId.column(this.table.schema, this.table.name, this.column.name),
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER TABLE",
+      `${this.table.schema}.${this.table.name}`,
+      "ALTER COLUMN",
+      this.column.name,
+      "DROP IDENTITY",
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER TABLE ... ALTER COLUMN ... SET GENERATED { ALWAYS | BY DEFAULT }
+ */
+export class AlterTableAlterColumnSetGenerated extends AlterTableChange {
+  public readonly table: Table;
+  public readonly column: ColumnProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { table: Table; column: ColumnProps }) {
+    super();
+    this.table = props.table;
+    this.column = props.column;
+  }
+
+  get requires() {
+    return [
+      stableId.column(this.table.schema, this.table.name, this.column.name),
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER TABLE",
+      `${this.table.schema}.${this.table.name}`,
+      "ALTER COLUMN",
+      this.column.name,
+      "SET GENERATED",
+      this.column.is_identity_always ? "ALWAYS" : "BY DEFAULT",
+    ].join(" ");
+  }
+}
+
 /**
  * ALTER TABLE ... ALTER COLUMN ... SET NOT NULL
  */
@@ -703,7 +804,7 @@ export class AlterTableAlterColumnSetNotNull extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -734,7 +835,7 @@ export class AlterTableAlterColumnDropNotNull extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -764,7 +865,7 @@ export class AlterTableAttachPartition extends AlterTableChange {
     return [this.partition.stableId, this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const bound = this.partition.partition_bound ?? "DEFAULT";
     return [
       "ALTER TABLE",
@@ -795,7 +896,7 @@ export class AlterTableDetachPartition extends AlterTableChange {
     return [this.table.stableId, this.partition.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import { quoteLiteral } from "../../base.change.ts";
 import type { ColumnProps } from "../../base.model.ts";
 import { stableId } from "../../utils.ts";
@@ -49,7 +50,7 @@ export class CreateCommentOnTable extends CreateTableChange {
     return [this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -80,7 +81,7 @@ export class DropCommentOnTable extends DropTableChange {
     return [stableId.comment(this.table.stableId), this.table.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -118,7 +119,7 @@ export class CreateCommentOnColumn extends CreateTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON COLUMN",
       `${this.table.schema}.${this.table.name}.${this.column.name}`,
@@ -161,7 +162,7 @@ export class DropCommentOnColumn extends DropTableChange {
     return [stableId.comment(columnStableId), columnStableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON COLUMN",
       `${this.table.schema}.${this.table.name}.${this.column.name}`,
@@ -206,7 +207,7 @@ export class CreateCommentOnConstraint extends CreateTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON CONSTRAINT",
       this.constraint.name,
@@ -254,7 +255,7 @@ export class DropCommentOnConstraint extends DropTableChange {
     return [stableId.comment(constraintStableId), constraintStableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return [
       "COMMENT ON CONSTRAINT",
       this.constraint.name,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import { isUserDefinedTypeSchema, stableId } from "../../utils.ts";
 import type { Table } from "../table.model.ts";
 import { CreateTableChange } from "./table.base.ts";
@@ -93,7 +94,7 @@ export class CreateTable extends CreateTableChange {
     return Array.from(dependencies);
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const parts: string[] = ["CREATE"];
 
     // Add TEMPORARY/UNLOGGED based on persistence

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import { stableId } from "../../utils.ts";
 import type { Table } from "../table.model.ts";
 import { DropTableChange } from "./table.base.ts";
@@ -27,6 +28,15 @@ export class DropTable extends DropTableChange {
       ...this.table.columns.map((column) =>
         stableId.column(this.table.schema, this.table.name, column.name),
       ),
+      // Include constraint stableIds so FK relationships that only exist at the
+      // constraint level still affect whole-table drop ordering.
+      ...this.table.constraints.map((constraint) =>
+        stableId.constraint(
+          this.table.schema,
+          this.table.name,
+          constraint.name,
+        ),
+      ),
     ];
   }
 
@@ -36,10 +46,19 @@ export class DropTable extends DropTableChange {
       ...this.table.columns.map((col) =>
         stableId.column(this.table.schema, this.table.name, col.name),
       ),
+      // Mirror the dropped constraint ids in requires so drop-phase graph
+      // consumers can connect catalog FK edges back to this table drop.
+      ...this.table.constraints.map((constraint) =>
+        stableId.constraint(
+          this.table.schema,
+          this.table.name,
+          constraint.name,
+        ),
+      ),
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     return ["DROP TABLE", `${this.table.schema}.${this.table.name}`].join(" ");
   }
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import {
   formatObjectPrivilegeList,
   getObjectKindPrefix,
@@ -57,7 +58,7 @@ export class GrantTablePrivileges extends AlterTableChange {
     return [this.table.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) {
@@ -132,7 +133,7 @@ export class RevokeTablePrivileges extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const kindPrefix = getObjectKindPrefix("TABLE");
     const list = this.privileges.map((p) => p.privilege);
     const privSql = formatObjectPrivilegeList("TABLE", list, this.version);
@@ -183,7 +184,7 @@ export class RevokeGrantOptionTablePrivileges extends AlterTableChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const kindPrefix = getObjectKindPrefix("TABLE");
     const privSql = formatObjectPrivilegeList(
       "TABLE",

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

@@ -3,9 +3,12 @@ import { DefaultPrivilegeState } from "../base.default-privileges.ts";
 import {
   AlterTableAddColumn,
   AlterTableAddConstraint,
+  AlterTableAlterColumnAddIdentity,
   AlterTableAlterColumnDropDefault,
+  AlterTableAlterColumnDropIdentity,
   AlterTableAlterColumnDropNotNull,
   AlterTableAlterColumnSetDefault,
+  AlterTableAlterColumnSetGenerated,
   AlterTableAlterColumnSetNotNull,
   AlterTableAlterColumnType,
   AlterTableChangeOwner,
@@ -714,6 +717,124 @@ describe.concurrent("table.diff", () => {
     ).toBe(true);
   });
 
+  test("identity transitions emit drop/add/set-generated changes", () => {
+    const serialColumn = {
+      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: false,
+      is_identity: false,
+      is_identity_always: false,
+      is_generated: false,
+      collation: null,
+      default: "nextval('public.t_identity_id_seq'::regclass)",
+      comment: null,
+    };
+
+    const identityAlwaysColumn = {
+      ...serialColumn,
+      is_identity: true,
+      is_identity_always: true,
+      default: null,
+    };
+
+    const identityByDefaultColumn = {
+      ...identityAlwaysColumn,
+      is_identity_always: false,
+    };
+
+    const serialToIdentityMain = new Table({
+      ...base,
+      name: "t_identity",
+      columns: [serialColumn],
+    });
+    const serialToIdentityBranch = new Table({
+      ...base,
+      name: "t_identity",
+      columns: [identityAlwaysColumn],
+    });
+
+    const serialToIdentityChanges = diffTables(
+      testContext,
+      { [serialToIdentityMain.stableId]: serialToIdentityMain },
+      { [serialToIdentityBranch.stableId]: serialToIdentityBranch },
+    );
+    expect(
+      serialToIdentityChanges.some(
+        (c) => c instanceof AlterTableAlterColumnDropDefault,
+      ),
+    ).toBe(true);
+    expect(
+      serialToIdentityChanges.some(
+        (c) => c instanceof AlterTableAlterColumnAddIdentity,
+      ),
+    ).toBe(true);
+
+    const identityToSerialChanges = diffTables(
+      testContext,
+      { [serialToIdentityBranch.stableId]: serialToIdentityBranch },
+      { [serialToIdentityMain.stableId]: serialToIdentityMain },
+    );
+    expect(
+      identityToSerialChanges.some(
+        (c) => c instanceof AlterTableAlterColumnDropIdentity,
+      ),
+    ).toBe(true);
+    expect(
+      identityToSerialChanges.some(
+        (c) => c instanceof AlterTableAlterColumnSetDefault,
+      ),
+    ).toBe(true);
+
+    const alwaysToByDefaultMain = new Table({
+      ...base,
+      name: "t_identity_mode",
+      columns: [identityAlwaysColumn],
+    });
+    const alwaysToByDefaultBranch = new Table({
+      ...base,
+      name: "t_identity_mode",
+      columns: [identityByDefaultColumn],
+    });
+    const alwaysToByDefaultChanges = diffTables(
+      testContext,
+      { [alwaysToByDefaultMain.stableId]: alwaysToByDefaultMain },
+      { [alwaysToByDefaultBranch.stableId]: alwaysToByDefaultBranch },
+    );
+    expect(
+      alwaysToByDefaultChanges.some(
+        (c) => c instanceof AlterTableAlterColumnSetGenerated,
+      ),
+    ).toBe(true);
+
+    const byDefaultToAlwaysMain = new Table({
+      ...base,
+      name: "t_identity_mode_reverse",
+      columns: [identityByDefaultColumn],
+    });
+    const byDefaultToAlwaysBranch = new Table({
+      ...base,
+      name: "t_identity_mode_reverse",
+      columns: [identityAlwaysColumn],
+    });
+    const byDefaultToAlwaysChanges = diffTables(
+      testContext,
+      { [byDefaultToAlwaysMain.stableId]: byDefaultToAlwaysMain },
+      { [byDefaultToAlwaysBranch.stableId]: byDefaultToAlwaysBranch },
+    );
+    expect(
+      byDefaultToAlwaysChanges.some(
+        (c) => c instanceof AlterTableAlterColumnSetGenerated,
+      ),
+    ).toBe(true);
+  });
+
   test("created table with privileges emits grant changes", () => {
     const t = new Table({
       ...base,

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

@@ -8,9 +8,12 @@ import { deepEqual } from "../utils.ts";
 import {
   AlterTableAddColumn,
   AlterTableAddConstraint,
+  AlterTableAlterColumnAddIdentity,
   AlterTableAlterColumnDropDefault,
+  AlterTableAlterColumnDropIdentity,
   AlterTableAlterColumnDropNotNull,
   AlterTableAlterColumnSetDefault,
+  AlterTableAlterColumnSetGenerated,
   AlterTableAlterColumnSetNotNull,
   AlterTableAlterColumnType,
   AlterTableAttachPartition,
@@ -545,7 +548,7 @@ export function diffTables(
     // Helper to check if parent has the same column property change
     const parentHasSameColumnPropertyChange = (
       columnName: string,
-      property: "type" | "default" | "not_null",
+      property: "type" | "default" | "not_null" | "identity",
     ): boolean => {
       const { parentMain, parentBranch } = getParentTables();
       if (!parentMain || !parentBranch) {
@@ -601,6 +604,21 @@ export function diffTables(
             parentBranchCol.not_null === branchCol.not_null
           );
         }
+        case "identity": {
+          const parentIdentityChanged =
+            parentMainCol.is_identity !== parentBranchCol.is_identity ||
+            parentMainCol.is_identity_always !==
+              parentBranchCol.is_identity_always;
+          const partitionIdentityChanged =
+            mainCol.is_identity !== branchCol.is_identity ||
+            mainCol.is_identity_always !== branchCol.is_identity_always;
+          return (
+            parentIdentityChanged &&
+            partitionIdentityChanged &&
+            parentBranchCol.is_identity === branchCol.is_identity &&
+            parentBranchCol.is_identity_always === branchCol.is_identity_always
+          );
+        }
       }
     };
 
@@ -698,6 +716,19 @@ export function diffTables(
         }
       }
 
+      // PostgreSQL rejects SET DEFAULT while the column still has identity metadata,
+      // so identity removal must lead the IDENTITY -> serial/default transition.
+      if (mainCol.is_identity && !branchCol.is_identity) {
+        if (!parentHasSameColumnPropertyChange(name, "identity")) {
+          changes.push(
+            new AlterTableAlterColumnDropIdentity({
+              table: branchTable,
+              column: branchCol,
+            }),
+          );
+        }
+      }
+
       // DEFAULT change
       if (mainCol.default !== branchCol.default) {
         // Skip if parent has the same default change
@@ -746,6 +777,38 @@ export function diffTables(
         }
       }
 
+      // Serial-like defaults have to be cleared before ADD GENERATED AS IDENTITY,
+      // while mode-only flips stay in-place on an existing identity column.
+      if (
+        (!mainCol.is_identity && branchCol.is_identity) ||
+        (mainCol.is_identity &&
+          branchCol.is_identity &&
+          mainCol.is_identity_always !== branchCol.is_identity_always)
+      ) {
+        // Skip if parent has the same identity change
+        if (!parentHasSameColumnPropertyChange(name, "identity")) {
+          if (!mainCol.is_identity && branchCol.is_identity) {
+            changes.push(
+              new AlterTableAlterColumnAddIdentity({
+                table: branchTable,
+                column: branchCol,
+              }),
+            );
+          } else if (
+            mainCol.is_identity &&
+            branchCol.is_identity &&
+            mainCol.is_identity_always !== branchCol.is_identity_always
+          ) {
+            changes.push(
+              new AlterTableAlterColumnSetGenerated({
+                table: branchTable,
+                column: branchCol,
+              }),
+            );
+          }
+        }
+      }
+
       // NOT NULL change
       if (mainCol.not_null !== branchCol.not_null) {
         // Skip if parent has the same NOT NULL change