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

package/dist/core/sort/custom-constraints.js

@@ -1,5 +1,6 @@
 import { getSchema } from "../change-utils.js";
 import { GrantRoleDefaultPrivileges, RevokeRoleDefaultPrivileges, } from "../objects/role/changes/role.privilege.js";
+import { AlterTableAlterColumnAddIdentity, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropIdentity, AlterTableAlterColumnSetDefault, } from "../objects/table/changes/table.alter.js";
 /**
  * Maps object type names to PostgreSQL default privilege objtype codes.
  * This mirrors the mapping in base.default-privileges.ts.
@@ -116,11 +117,74 @@ function generateDefaultPrivilegeConstraints(changes) {
     }
     return constraints;
 }
+function generateIdentityTransitionConstraints(changes) {
+    const constraints = [];
+    const dropDefaultByColumn = new Map();
+    const dropIdentityByColumn = new Map();
+    const addIdentityByColumn = new Map();
+    const setDefaultByColumn = new Map();
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const columnKey = "table" in change && "column" in change
+            ? `${change.table.schema}.${change.table.name}.${change.column.name}`
+            : null;
+        if (!columnKey)
+            continue;
+        if (change instanceof AlterTableAlterColumnDropDefault) {
+            const entries = dropDefaultByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            dropDefaultByColumn.set(columnKey, entries);
+        }
+        else if (change instanceof AlterTableAlterColumnAddIdentity) {
+            const entries = addIdentityByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            addIdentityByColumn.set(columnKey, entries);
+        }
+        else if (change instanceof AlterTableAlterColumnDropIdentity) {
+            const entries = dropIdentityByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            dropIdentityByColumn.set(columnKey, entries);
+        }
+        else if (change instanceof AlterTableAlterColumnSetDefault) {
+            const entries = setDefaultByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            setDefaultByColumn.set(columnKey, entries);
+        }
+    }
+    // These rules only order same-column ALTERs inside the create/alter phase.
+    // Sequence drops are handled separately in the earlier drop phase.
+    for (const [columnKey, dropDefaultIndexes] of dropDefaultByColumn) {
+        const addIdentityIndexes = addIdentityByColumn.get(columnKey) ?? [];
+        for (const sourceIndex of dropDefaultIndexes) {
+            for (const targetIndex of addIdentityIndexes) {
+                constraints.push({
+                    sourceChangeIndex: sourceIndex,
+                    targetChangeIndex: targetIndex,
+                    source: "custom",
+                });
+            }
+        }
+    }
+    for (const [columnKey, dropIdentityIndexes] of dropIdentityByColumn) {
+        const setDefaultIndexes = setDefaultByColumn.get(columnKey) ?? [];
+        for (const sourceIndex of dropIdentityIndexes) {
+            for (const targetIndex of setDefaultIndexes) {
+                constraints.push({
+                    sourceChangeIndex: sourceIndex,
+                    targetChangeIndex: targetIndex,
+                    source: "custom",
+                });
+            }
+        }
+    }
+    return constraints;
+}
 /**
  * All custom constraint generators.
  */
 const customConstraintGenerators = [
     generateDefaultPrivilegeConstraints,
+    generateIdentityTransitionConstraints,
 ];
 /**
  * Generate Constraints from custom constraint generators.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.13",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/core/expand-replace-dependencies.test.ts

@@ -1,7 +1,16 @@
 import { describe, expect, test } from "bun:test";
-import { createEmptyCatalog } from "./catalog.model.ts";
+import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.ts";
+import { DefaultPrivilegeState } from "./objects/base.default-privileges.ts";
+import { CreateSequence } from "./objects/sequence/changes/sequence.create.ts";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
+import { diffSequences } from "./objects/sequence/sequence.diff.ts";
+import { Sequence } from "./objects/sequence/sequence.model.ts";
+import { AlterTableAlterColumnSetDefault } from "./objects/table/changes/table.alter.ts";
+import { CreateTable } from "./objects/table/changes/table.create.ts";
+import { DropTable } from "./objects/table/changes/table.drop.ts";
+import { Table } from "./objects/table/table.model.ts";
 
 function mockChange(overrides: {
   creates?: string[];
@@ -67,4 +76,120 @@ describe("expandReplaceDependencies", () => {
     });
     expect(result).toBe(changes);
   });
+
+  test("does not replace the owning table for an owned sequence recreation", async () => {
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const mainSequence = new Sequence({
+      schema: "public",
+      name: "user_id_seq",
+      data_type: "integer",
+      start_value: 1,
+      minimum_value: 1n,
+      maximum_value: 2147483647n,
+      increment: 1,
+      cycle_option: false,
+      cache_size: 1,
+      persistence: "p",
+      owned_by_schema: "public",
+      owned_by_table: "users",
+      owned_by_column: "id",
+      comment: null,
+      privileges: [],
+      owner: "postgres",
+    });
+    const branchSequence = new Sequence({
+      ...mainSequence,
+      data_type: "bigint",
+      maximum_value: 9223372036854775807n,
+    });
+    const usersTable = 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: "postgres",
+      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.user_id_seq'::regclass)",
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+    const changes = diffSequences(
+      {
+        version: 170000,
+        currentUser: "postgres",
+        defaultPrivilegeState: new DefaultPrivilegeState({}),
+      },
+      { [mainSequence.stableId]: mainSequence },
+      { [branchSequence.stableId]: branchSequence },
+      { [usersTable.stableId]: usersTable },
+    );
+    const mainCatalog = new Catalog({
+      ...baseline,
+      sequences: { [mainSequence.stableId]: mainSequence },
+      tables: { [usersTable.stableId]: usersTable },
+      depends: [
+        {
+          dependent_stable_id: mainSequence.stableId,
+          referenced_stable_id: "column:public.users.id",
+          deptype: "a",
+        },
+        {
+          dependent_stable_id: "column:public.users.id",
+          referenced_stable_id: mainSequence.stableId,
+          deptype: "n",
+        },
+      ],
+    });
+    const branchCatalog = new Catalog({
+      ...baseline,
+      sequences: { [branchSequence.stableId]: branchSequence },
+      tables: { [usersTable.stableId]: usersTable },
+      depends: [],
+    });
+
+    const expanded = expandReplaceDependencies({
+      changes,
+      mainCatalog,
+      branchCatalog,
+    });
+
+    expect(changes[0]).toBeInstanceOf(DropSequence);
+    expect(changes[1]).toBeInstanceOf(CreateSequence);
+    expect(changes[3]).toBeInstanceOf(AlterTableAlterColumnSetDefault);
+    expect(expanded.some((change) => change instanceof DropTable)).toBe(false);
+    expect(expanded.some((change) => change instanceof CreateTable)).toBe(
+      false,
+    );
+  });
 });

package/src/core/expand-replace-dependencies.ts

@@ -19,6 +19,7 @@ import { CreateEnum } from "./objects/type/enum/changes/enum.create.ts";
 import { DropEnum } from "./objects/type/enum/changes/enum.drop.ts";
 import { CreateRange } from "./objects/type/range/changes/range.create.ts";
 import { DropRange } from "./objects/type/range/changes/range.drop.ts";
+import { stableId } from "./objects/utils.ts";
 import { CreateView } from "./objects/view/changes/view.create.ts";
 import { DropView } from "./objects/view/changes/view.drop.ts";
 
@@ -121,6 +122,17 @@ export function expandReplaceDependencies({
     if (!dependents) continue;
 
     for (const dependentRaw of dependents) {
+      if (
+        isOwnedSequenceColumnDependency(
+          refId,
+          dependentRaw,
+          mainCatalog,
+          branchCatalog,
+        )
+      ) {
+        continue;
+      }
+
       // Continue traversing the dependency graph from the raw dependent id.
       if (!visitedRefs.has(dependentRaw)) {
         visitedRefs.add(dependentRaw);
@@ -181,6 +193,44 @@ export function expandReplaceDependencies({
   return [...changes, ...additions];
 }
 
+function isOwnedSequenceColumnDependency(
+  referencedId: string,
+  dependentId: string,
+  mainCatalog: Catalog,
+  branchCatalog: Catalog,
+): boolean {
+  // When a sequence replace root is still OWNED BY the same column, the
+  // sequence->column pg_depend edge is bookkeeping for ownership, not a signal
+  // that the whole owning table needs to be replaced. Skipping that edge keeps
+  // expandReplaceDependencies focused on recreating the sequence itself.
+  if (
+    !referencedId.startsWith("sequence:") ||
+    !dependentId.startsWith("column:")
+  ) {
+    return false;
+  }
+
+  const sequence =
+    branchCatalog.sequences[referencedId] ??
+    mainCatalog.sequences[referencedId];
+  if (
+    !sequence?.owned_by_schema ||
+    !sequence.owned_by_table ||
+    !sequence.owned_by_column
+  ) {
+    return false;
+  }
+
+  return (
+    dependentId ===
+    stableId.column(
+      sequence.owned_by_schema,
+      sequence.owned_by_table,
+      sequence.owned_by_column,
+    )
+  );
+}
+
 function normalizeDependentId(dependentId: string): string | null {
   let id = dependentId;
 

package/src/core/export/index.ts

@@ -4,7 +4,11 @@
 
 import type { Change } from "../change.types.ts";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.ts";
-import type { Integration } from "../integrations/integration.types.ts";
+import {
+  type Integration,
+  type ResolvedIntegration,
+  resolveIntegration,
+} from "../integrations/integration.types.ts";
 import type { createPlan } from "../plan/create.ts";
 import { DEFAULT_OPTIONS } from "../plan/sql-format/constants.ts";
 import type { SqlFormatOptions } from "../plan/sql-format/types.ts";
@@ -29,7 +33,7 @@ type PlanResult = NonNullable<Awaited<ReturnType<typeof createPlan>>>;
 
 export interface ExportOptions {
   /** Integration for custom serialization */
-  integration?: Integration;
+  integration?: Pick<Integration, "serialize">;
   /**
    * SQL formatter options to control the output style.
    * Merged on top of the default export options (maxWidth: 180, keywordCase: "upper").
@@ -64,7 +68,9 @@ export function exportDeclarativeSchema(
   options?: ExportOptions,
 ): DeclarativeSchemaOutput {
   const { ctx, sortedChanges } = planResult;
-  const integration = options?.integration;
+  const integration = options?.integration
+    ? resolveIntegration(options?.integration)
+    : {};
   const formatOptions: SqlFormatOptions | undefined =
     options?.formatOptions === null
       ? undefined
@@ -108,7 +114,10 @@ export function exportDeclarativeSchema(
   };
 }
 
-function serializeChange(change: Change, integration?: Integration): string {
+function serializeChange(
+  change: Change,
+  integration?: ResolvedIntegration,
+): string {
   return integration?.serialize?.(change) ?? change.serialize();
 }
 

package/src/core/integrations/integration.types.ts

@@ -1,7 +1,65 @@
+import { compileFilterDSL, type FilterDSL } from "./filter/dsl.ts";
 import type { ChangeFilter } from "./filter/filter.types.ts";
+import { compileSerializeDSL, type SerializeDSL } from "./serialize/dsl.ts";
 import type { ChangeSerializer } from "./serialize/serialize.types.ts";
 
-export type Integration = {
+/**
+ * A resolved integration is an integration that has been compiled to a function.
+ */
+export type ResolvedIntegration = {
   filter?: ChangeFilter;
   serialize?: ChangeSerializer;
 };
+
+/**
+ * A raw integration is an integration that has not been compiled to a function.
+ */
+export type IntegrationDSL = {
+  filter?: FilterDSL;
+  serialize?: SerializeDSL;
+};
+
+/**
+ * An integration is a raw integration that has not been compiled to a function.
+ */
+export type Integration = {
+  filter?: ResolvedIntegration["filter"] | IntegrationDSL["filter"];
+  serialize?: ResolvedIntegration["serialize"] | IntegrationDSL["serialize"];
+};
+
+/**
+ * Resolve an integration either DSL or already resovled into a ResolvedIntegration.
+ * @param integration - The integration to resolve.
+ * @returns The resolved integration.
+ */
+export function resolveIntegration(
+  integration: Integration,
+): ResolvedIntegration | undefined {
+  // Determine if filter/serialize are DSL or functions, and extract DSL for storage
+  const isFilterDSL =
+    integration.filter && typeof integration.filter !== "function";
+  const isSerializeDSL =
+    integration.serialize && typeof integration.serialize !== "function";
+  const filterDSL = isFilterDSL ? (integration.filter as FilterDSL) : undefined;
+  const serializeDSL = isSerializeDSL
+    ? (integration.serialize as SerializeDSL)
+    : undefined;
+
+  // Build final integration: compile DSL if needed, use functions directly otherwise
+  if (integration.filter || integration.serialize) {
+    return {
+      filter:
+        typeof integration.filter === "function"
+          ? integration.filter
+          : filterDSL
+            ? compileFilterDSL(filterDSL)
+            : undefined,
+      serialize:
+        typeof integration.serialize === "function"
+          ? integration.serialize
+          : serializeDSL
+            ? compileSerializeDSL(serializeDSL)
+            : undefined,
+    };
+  }
+}

package/src/core/integrations/serialize/dsl.test.ts

@@ -1,22 +1,41 @@
 import { describe, expect, test } from "bun:test";
 import type { Change } from "../../change.types.ts";
 import { compileSerializeDSL } from "./dsl.ts";
+import type { SerializeOptions } from "./serialize.types.ts";
 
 function makeChange(
   type: string,
   operation: string,
-  serializeFn: (opts?: Record<string, unknown>) => string,
+  serializeFn: (opts?: SerializeOptions) => string,
 ): Change {
   return {
     objectType: type,
     operation,
     scope: "object",
     schema: { name: "test" },
+    extension: { schema: "pgmq" },
     serialize: serializeFn,
   } as unknown as Change;
 }
 
 describe("compileSerializeDSL", () => {
+  test("matching extension rule can skip schema serialization", () => {
+    const serializer = compileSerializeDSL([
+      {
+        when: { objectType: "extension", operation: "create" },
+        options: { skipSchema: true },
+      },
+    ]);
+
+    const change = makeChange("extension", "create", (opts) =>
+      opts?.skipSchema
+        ? "CREATE EXTENSION pgmq"
+        : "CREATE EXTENSION pgmq WITH SCHEMA pgmq",
+    );
+
+    expect(serializer(change)).toBe("CREATE EXTENSION pgmq");
+  });
+
   test("matching rule applies its options", () => {
     const serializer = compileSerializeDSL([
       {

package/src/core/integrations/serialize/dsl.ts

@@ -6,16 +6,7 @@
 
 import type { Change } from "../../change.types.ts";
 import { evaluatePattern, type FilterPattern } from "../filter/dsl.ts";
-import type { ChangeSerializer } from "./serialize.types.ts";
-
-/**
- * Serialization options that can be passed to change.serialize().
- */
-type SerializeOptions = {
-  skipAuthorization?: boolean;
-  // Can be extended with more options in the future
-  [key: string]: unknown;
-};
+import type { ChangeSerializer, SerializeOptions } from "./serialize.types.ts";
 
 /**
  * A serialization rule that applies options when a pattern matches.

package/src/core/integrations/serialize/serialize.types.ts

@@ -1,3 +1,40 @@
 import type { Change } from "../../change.types.ts";
 
+/**
+ * Shared serialization options passed to `change.serialize(options)`.
+ *
+ * This is the global source of truth for serialize-option flags used by the
+ * integration serialization DSL and concrete change serializers.
+ *
+ * @category Integration
+ */
+export type SerializeOptions = {
+  /** Skip `AUTHORIZATION` when serializing schema creation. */
+  skipAuthorization?: boolean;
+  /** Skip `WITH SCHEMA ...` when serializing extension creation. */
+  skipSchema?: boolean;
+};
+
+/**
+ * Schema-specific view of {@link SerializeOptions}.
+ *
+ * @category Integration
+ */
+export type SchemaSerializeOptions = Pick<
+  SerializeOptions,
+  "skipAuthorization"
+>;
+
+/**
+ * Extension-specific view of {@link SerializeOptions}.
+ *
+ * @category Integration
+ */
+export type ExtensionSerializeOptions = Pick<SerializeOptions, "skipSchema">;
+
+/**
+ * Compiled serializer function used during plan/declarative export rendering.
+ *
+ * @category Integration
+ */
 export type ChangeSerializer = (change: Change) => string | undefined;

package/src/core/integrations/supabase.ts

@@ -92,6 +92,12 @@ export const supabase: IntegrationDSL = {
         operation: "create",
         scope: "object",
       },
+      // Include extension DROPs used to disable some extensions (eg: pg-net)
+      {
+        objectType: "extension",
+        operation: "drop",
+        scope: "object",
+      },
       // Exclude system objects
       {
         not: {
@@ -141,5 +147,18 @@ export const supabase: IntegrationDSL = {
         skipAuthorization: true,
       },
     },
+    // pgmq extensions creates it's own schema on install doing a `CREATE EXTENSION pgmq WITH SCHEMA pgmq;`
+    // will cause an error because the schema will create extension and extension refer to unexisting schema
+    {
+      when: {
+        objectType: "extension",
+        operation: "create",
+        scope: "object",
+        "extension/schema": ["pgmq"],
+      },
+      options: {
+        skipSchema: true,
+      },
+    },
   ],
 };

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { AlterAggregateChange } from "./aggregate.base.ts";
 
@@ -23,7 +24,7 @@ export class AlterAggregateChangeOwner extends AlterAggregateChange {
     return [this.aggregate.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const signature = this.aggregate.identityArguments;
     const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
     const withArgs = signature.length > 0 ? `(${signature})` : "()";

package/src/core/objects/aggregate/changes/aggregate.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 { Aggregate } from "../aggregate.model.ts";
@@ -27,7 +28,7 @@ export class CreateCommentOnAggregate extends CreateAggregateChange {
     return [this.aggregate.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const signature = this.aggregate.identityArguments;
     const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
     const withArgs = signature.length > 0 ? `(${signature})` : "()";
@@ -53,7 +54,7 @@ export class DropCommentOnAggregate extends DropAggregateChange {
     return [stableId.comment(this.aggregate.stableId), this.aggregate.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const signature = this.aggregate.identityArguments;
     const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
     const withArgs = signature.length > 0 ? `(${signature})` : "()";

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import { quoteLiteral } from "../../base.change.ts";
 import {
   parseProcedureReference,
@@ -166,7 +167,7 @@ export class CreateAggregate extends CreateAggregateChange {
     return Array.from(dependencies);
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const signature = this.aggregate.identityArguments;
     const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
     const head = [

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { DropAggregateChange } from "./aggregate.base.ts";
 
@@ -23,7 +24,7 @@ export class DropAggregate extends DropAggregateChange {
     return [this.aggregate.stableId];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const signature = this.aggregate.identityArguments;
     const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
     const withArgs = signature.length > 0 ? `(${signature})` : "(*)";

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import {
   formatObjectPrivilegeList,
   getObjectKindPrefix,
@@ -39,7 +40,7 @@ export class GrantAggregatePrivileges extends AlterAggregateChange {
     return [this.aggregate.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) {
@@ -92,7 +93,7 @@ export class RevokeAggregatePrivileges extends AlterAggregateChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const kindPrefix = getObjectKindPrefix("FUNCTION");
     const list = this.privileges.map((p) => p.privilege);
     const privSql = formatObjectPrivilegeList("FUNCTION", list, this.version);
@@ -131,7 +132,7 @@ export class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
     ];
   }
 
-  serialize(): string {
+  serialize(_options?: SerializeOptions): string {
     const kindPrefix = getObjectKindPrefix("FUNCTION");
     const privSql = formatObjectPrivilegeList(
       "FUNCTION",

package/src/core/objects/base.change.ts

@@ -1,3 +1,5 @@
+import type { SerializeOptions } from "../integrations/serialize/serialize.types.ts";
+
 type ChangeOperation = "create" | "alter" | "drop";
 
 /**
@@ -61,7 +63,7 @@ export abstract class BaseChange {
   /**
    * Serialize the change into a single SQL statement.
    */
-  abstract serialize(options?: Record<string, unknown>): string;
+  abstract serialize(options?: SerializeOptions): string;
 }
 
 /**