@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.21

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

@@ -0,0 +1,334 @@
+import { diffObjects } from "../base.diff.ts";
+import {
+  diffPrivileges,
+  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 {
+  AlterSequenceSetOptions,
+  AlterSequenceSetOwnedBy,
+} from "./changes/sequence.alter.ts";
+import {
+  CreateCommentOnSequence,
+  DropCommentOnSequence,
+} from "./changes/sequence.comment.ts";
+import { CreateSequence } from "./changes/sequence.create.ts";
+import { DropSequence } from "./changes/sequence.drop.ts";
+import {
+  GrantSequencePrivileges,
+  RevokeGrantOptionSequencePrivileges,
+  RevokeSequencePrivileges,
+} from "./changes/sequence.privilege.ts";
+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.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @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).
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffSequences(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, Sequence>,
+  branch: Record<string, Sequence>,
+  branchTables: Record<string, Table> = {},
+): SequenceOrColumnSetDefaultChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: SequenceOrColumnSetDefaultChange[] = [];
+
+  for (const sequenceId of created) {
+    const createdSeq = branch[sequenceId];
+    changes.push(new CreateSequence({ sequence: createdSeq }));
+    if (createdSeq.comment !== null) {
+      changes.push(new CreateCommentOnSequence({ sequence: createdSeq }));
+    }
+    // If the created sequence is OWNED BY a column, emit an ALTER to set it
+    if (
+      createdSeq.owned_by_schema !== null &&
+      createdSeq.owned_by_table !== null &&
+      createdSeq.owned_by_column !== null
+    ) {
+      changes.push(
+        new AlterSequenceSetOwnedBy({
+          sequence: createdSeq,
+          ownedBy: {
+            schema: createdSeq.owned_by_schema,
+            table: createdSeq.owned_by_table,
+            column: createdSeq.owned_by_column,
+          } as { schema: string; table: string; column: string },
+        }),
+      );
+    }
+
+    // PRIVILEGES: For created objects, compare against default privileges state
+    // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+    // so objects are created with the default privileges state in effect.
+    // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+    // needed to reach the final desired state.
+    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+      ctx.currentUser,
+      "sequence",
+      createdSeq.schema ?? "",
+    );
+    const creatorFilteredDefaults =
+      createdSeq.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
+    const desiredPrivileges = createdSeq.privileges;
+    // Filter out owner privileges - owner always has ALL privileges implicitly
+    // and shouldn't be compared. Use the sequence owner as the reference.
+    const privilegeResults = diffPrivileges(
+      creatorFilteredDefaults,
+      desiredPrivileges,
+      createdSeq.owner,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdSeq,
+        createdSeq,
+        "sequence",
+        {
+          Grant: GrantSequencePrivileges,
+          Revoke: RevokeSequencePrivileges,
+          RevokeGrantOption: RevokeGrantOptionSequencePrivileges,
+        },
+        ctx.version,
+      ) as SequenceChange[]),
+    );
+  }
+
+  for (const sequenceId of dropped) {
+    const sequence = main[sequenceId];
+    // Skip generating DROP SEQUENCE if the sequence is owned by a table/column that's being dropped.
+    // PostgreSQL automatically cascades owned sequences when the owning table OR the owning
+    // column is dropped (via OWNED BY). Emitting DROP SEQUENCE in those cases would either
+    // fail at apply time (sequence already gone) or — in the column-drop case — create an
+    // unbreakable DropSequence ↔ AlterTableDropColumn cycle in the drop-phase sort graph.
+    if (
+      sequence.owned_by_schema &&
+      sequence.owned_by_table &&
+      sequence.owned_by_column
+    ) {
+      const ownedByTableId = `table:${sequence.owned_by_schema}.${sequence.owned_by_table}`;
+      const ownedByTable = branchTables[ownedByTableId];
+      // Owning table is dropped → PG auto-drops the owned sequence.
+      if (!ownedByTable) {
+        continue;
+      }
+      // Owning column is dropped (table survives) → PG still auto-drops the owned
+      // sequence as part of the column drop, so we must not emit DROP SEQUENCE.
+      const ownedByColumnExists = ownedByTable.columns?.some(
+        (col) => col.name === sequence.owned_by_column,
+      );
+      if (!ownedByColumnExists) {
+        continue;
+      }
+    }
+    changes.push(new DropSequence({ sequence }));
+  }
+
+  for (const sequenceId of altered) {
+    const mainSequence = main[sequenceId];
+    const branchSequence = branch[sequenceId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the sequence
+    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 }),
+      );
+      // Re-apply OWNED BY if present on branch
+      if (
+        branchSequence.owned_by_schema !== null &&
+        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,
+            ownedBy: {
+              schema: branchSequence.owned_by_schema,
+              table: branchSequence.owned_by_table,
+              column: branchSequence.owned_by_column,
+            } 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 ||
+        mainSequence.owned_by_column !== null
+      ) {
+        // If main had ownership but branch removed it, emit OWNED BY NONE
+        changes.push(
+          new AlterSequenceSetOwnedBy({
+            sequence: mainSequence,
+            ownedBy: null,
+          }),
+        );
+      }
+    } 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 ||
+        mainSequence.start_value !== branchSequence.start_value ||
+        mainSequence.cache_size !== branchSequence.cache_size ||
+        mainSequence.cycle_option !== branchSequence.cycle_option;
+
+      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));
+        }
+        if (mainSequence.minimum_value !== branchSequence.minimum_value) {
+          const defaultMin = BigInt(1);
+          if (branchSequence.minimum_value === defaultMin) {
+            options.push("NO MINVALUE");
+          } else {
+            options.push("MINVALUE", branchSequence.minimum_value.toString());
+          }
+        }
+        if (mainSequence.maximum_value !== branchSequence.maximum_value) {
+          const defaultMax =
+            branchSequence.data_type === "integer"
+              ? BigInt("2147483647")
+              : BigInt("9223372036854775807");
+          if (branchSequence.maximum_value === defaultMax) {
+            options.push("NO MAXVALUE");
+          } else {
+            options.push("MAXVALUE", branchSequence.maximum_value.toString());
+          }
+        }
+        if (mainSequence.start_value !== branchSequence.start_value) {
+          options.push("START WITH", String(branchSequence.start_value));
+        }
+        if (mainSequence.cache_size !== branchSequence.cache_size) {
+          options.push("CACHE", String(branchSequence.cache_size));
+        }
+        if (mainSequence.cycle_option !== branchSequence.cycle_option) {
+          options.push(branchSequence.cycle_option ? "CYCLE" : "NO CYCLE");
+        }
+        changes.push(
+          new AlterSequenceSetOptions({ sequence: mainSequence, options }),
+        );
+      }
+
+      const ownedByChanged =
+        mainSequence.owned_by_schema !== branchSequence.owned_by_schema ||
+        mainSequence.owned_by_table !== branchSequence.owned_by_table ||
+        mainSequence.owned_by_column !== branchSequence.owned_by_column;
+
+      if (ownedByChanged) {
+        const ownedBy =
+          branchSequence.owned_by_schema &&
+          branchSequence.owned_by_table &&
+          branchSequence.owned_by_column
+            ? {
+                schema: branchSequence.owned_by_schema,
+                table: branchSequence.owned_by_table,
+                column: branchSequence.owned_by_column,
+              }
+            : null;
+        changes.push(
+          new AlterSequenceSetOwnedBy({ sequence: mainSequence, ownedBy }),
+        );
+      }
+
+      // COMMENT
+      if (mainSequence.comment !== branchSequence.comment) {
+        if (branchSequence.comment === null) {
+          changes.push(new DropCommentOnSequence({ sequence: mainSequence }));
+        } else {
+          changes.push(
+            new CreateCommentOnSequence({ sequence: branchSequence }),
+          );
+        }
+      }
+
+      // PRIVILEGES
+      // Filter out owner privileges - owner always has ALL privileges implicitly
+      // and shouldn't be compared. Use branch owner as the reference.
+      const privilegeResults = diffPrivileges(
+        mainSequence.privileges,
+        branchSequence.privileges,
+        branchSequence.owner,
+      );
+
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchSequence,
+          mainSequence,
+          "sequence",
+          {
+            Grant: GrantSequencePrivileges,
+            Revoke: RevokeSequencePrivileges,
+            RevokeGrantOption: RevokeGrantOptionSequencePrivileges,
+          },
+          ctx.version,
+        ) as SequenceChange[]),
+      );
+
+      // Note: Sequence renaming would also use ALTER SEQUENCE ... RENAME TO ...
+      // But since our Sequence model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+    }
+  }
+
+  return changes;
+}

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

@@ -0,0 +1,185 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../base.privilege-diff.ts";
+
+const sequencePropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  data_type: z.string(),
+  start_value: z.number(),
+  minimum_value: z.bigint(),
+  maximum_value: z.bigint(),
+  increment: z.number(),
+  cycle_option: z.boolean(),
+  cache_size: z.number(),
+  persistence: z.string(),
+  owned_by_schema: z.string().nullable(),
+  owned_by_table: z.string().nullable(),
+  owned_by_column: z.string().nullable(),
+  comment: z.string().nullable(),
+  privileges: z.array(privilegePropsSchema),
+  owner: z.string(),
+});
+
+type SequencePrivilegeProps = PrivilegeProps;
+export type SequenceProps = z.infer<typeof sequencePropsSchema>;
+
+export class Sequence extends BasePgModel {
+  public readonly schema: SequenceProps["schema"];
+  public readonly name: SequenceProps["name"];
+  public readonly data_type: SequenceProps["data_type"];
+  public readonly start_value: SequenceProps["start_value"];
+  public readonly minimum_value: SequenceProps["minimum_value"];
+  public readonly maximum_value: SequenceProps["maximum_value"];
+  public readonly increment: SequenceProps["increment"];
+  public readonly cycle_option: SequenceProps["cycle_option"];
+  public readonly cache_size: SequenceProps["cache_size"];
+  public readonly persistence: SequenceProps["persistence"];
+  public readonly owned_by_schema: SequenceProps["owned_by_schema"];
+  public readonly owned_by_table: SequenceProps["owned_by_table"];
+  public readonly owned_by_column: SequenceProps["owned_by_column"];
+  public readonly comment: SequenceProps["comment"];
+  public readonly privileges: SequencePrivilegeProps[];
+  public readonly owner: SequenceProps["owner"];
+
+  constructor(props: SequenceProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+
+    // Data fields
+    this.data_type = props.data_type;
+    this.start_value = props.start_value;
+    this.minimum_value = props.minimum_value;
+    this.maximum_value = props.maximum_value;
+    this.increment = props.increment;
+    this.cycle_option = props.cycle_option;
+    this.cache_size = props.cache_size;
+    this.persistence = props.persistence;
+    this.owned_by_schema = props.owned_by_schema;
+    this.owned_by_table = props.owned_by_table;
+    this.owned_by_column = props.owned_by_column;
+    this.comment = props.comment;
+    this.privileges = props.privileges;
+    this.owner = props.owner;
+  }
+
+  get stableId(): `sequence:${string}` {
+    return `sequence:${this.schema}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      data_type: this.data_type,
+      start_value: this.start_value,
+      minimum_value: this.minimum_value,
+      maximum_value: this.maximum_value,
+      increment: this.increment,
+      cycle_option: this.cycle_option,
+      cache_size: this.cache_size,
+      persistence: this.persistence,
+      owned_by_schema: this.owned_by_schema,
+      owned_by_table: this.owned_by_table,
+      owned_by_column: this.owned_by_column,
+      comment: this.comment,
+      privileges: this.privileges,
+      owner: this.owner,
+    };
+  }
+}
+
+export async function extractSequences(pool: Pool): Promise<Sequence[]> {
+  const { rows: sequenceRows } = await pool.query<SequenceProps>(sql`
+with extension_sequence_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::regclass
+),
+extension_table_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::regclass
+    and d.deptype = 'e'
+)
+select
+  c.relnamespace::regnamespace::text as schema,
+  quote_ident(c.relname) as name,
+  format_type(s.seqtypid, null) as data_type,
+  s.seqstart::int as start_value,
+  s.seqmin as minimum_value,
+  s.seqmax as maximum_value,
+  s.seqincrement::int as increment,
+  s.seqcycle as cycle_option,
+  s.seqcache::int as cache_size,
+  c.relpersistence as persistence,
+  quote_ident(t_ns.nspname) as owned_by_schema,
+  case when t.relname is not null then quote_ident(t.relname) else null end as owned_by_table,
+  case when att.attname is not null then quote_ident(att.attname) else null end as owned_by_column,
+  obj_description(c.oid, 'pg_class') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+          'privilege', x.privilege_type,
+          'grantable', x.is_grantable
+        )
+        order by x.grantee, x.privilege_type
+      )
+      from lateral aclexplode(COALESCE(c.relacl, acldefault('S', c.relowner))) as x(grantor, grantee, privilege_type, is_grantable)
+    ), '[]'
+  ) as privileges,
+  c.relowner::regrole::text as owner
+from
+  pg_catalog.pg_class c
+  inner join pg_catalog.pg_sequence s on s.seqrelid = c.oid
+  left join pg_depend d on d.classid = 'pg_class'::regclass and d.objid = c.oid and d.refclassid = 'pg_class'::regclass and d.deptype = 'a'
+  left join pg_class t on t.oid = d.refobjid
+  left join pg_namespace t_ns on t.relnamespace = t_ns.oid
+  left join pg_attribute att on att.attrelid = t.oid and att.attnum = d.refobjsubid and d.refobjsubid > 0
+  left outer join extension_sequence_oids e_seq on c.oid = e_seq.objid
+  left outer join extension_table_oids e_table on t.oid = e_table.objid
+  where not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e_seq.objid is null
+  and (t.oid is null or e_table.objid is null)
+  and c.relkind = 'S'
+  -- exclude sequences that are tied to an IDENTITY column
+  and not exists (
+    select 1
+    from pg_depend di
+    where di.classid = 'pg_class'::regclass
+      and di.objid = c.oid
+      and di.refclassid = 'pg_class'::regclass
+      and di.deptype = 'i'
+  )
+order by
+  1, 2
+  `);
+  // Validate and parse each row using the Zod schema
+  const validatedRows = sequenceRows.map((row: unknown) =>
+    sequencePropsSchema.parse(row),
+  );
+  return validatedRows.map((row: SequenceProps) => new Sequence(row));
+}

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

@@ -0,0 +1,134 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { stableId } from "../../utils.ts";
+import { Subscription } from "../subscription.model.ts";
+import {
+  AlterSubscriptionDisable,
+  AlterSubscriptionEnable,
+  AlterSubscriptionSetConnection,
+  AlterSubscriptionSetOptions,
+  AlterSubscriptionSetOwner,
+  AlterSubscriptionSetPublication,
+} from "./subscription.alter.ts";
+
+type SubscriptionProps = ConstructorParameters<typeof Subscription>[0];
+
+const base: SubscriptionProps = {
+  name: "sub_base",
+  raw_name: "sub_base",
+  owner: "owner1",
+  comment: null,
+  enabled: true,
+  binary: false,
+  streaming: "off",
+  two_phase: false,
+  disable_on_error: false,
+  password_required: true,
+  run_as_owner: false,
+  failover: false,
+  conninfo: "host=example dbname=postgres",
+  slot_name: null,
+  slot_is_none: false,
+  replication_slot_created: true,
+  synchronous_commit: "off",
+  publications: ["pub_base"],
+  origin: "any",
+};
+
+const makeSubscription = (override: Partial<SubscriptionProps> = {}) =>
+  new Subscription({
+    ...base,
+    ...override,
+    publications: override.publications
+      ? [...override.publications]
+      : [...base.publications],
+  });
+
+describe("subscription.alter", () => {
+  test("set connection serializes conninfo literal", async () => {
+    const subscription = makeSubscription({
+      conninfo: "dbname=postgres host=replica",
+    });
+    const change = new AlterSubscriptionSetConnection({ subscription });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base CONNECTION 'dbname=postgres host=replica'",
+    );
+  });
+
+  test("set publication preserves ordering and refresh hint when disabled", async () => {
+    const enabledSubscription = makeSubscription({
+      publications: ["pub_a", "pub_b"],
+      enabled: true,
+    });
+    const enabledChange = new AlterSubscriptionSetPublication({
+      subscription: enabledSubscription,
+    });
+
+    await assertValidSql(enabledChange.serialize());
+
+    expect(enabledChange.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base SET PUBLICATION pub_a, pub_b",
+    );
+
+    const disabledSubscription = makeSubscription({
+      publications: ["pub_b", "pub_a"],
+      enabled: false,
+    });
+    const disabledChange = new AlterSubscriptionSetPublication({
+      subscription: disabledSubscription,
+    });
+
+    await assertValidSql(disabledChange.serialize());
+
+    expect(disabledChange.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base SET PUBLICATION pub_a, pub_b WITH (refresh = false)",
+    );
+  });
+
+  test("toggle enablement serializes ENABLE and DISABLE statements", async () => {
+    const subscription = makeSubscription();
+
+    expect(new AlterSubscriptionEnable({ subscription }).serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base ENABLE",
+    );
+    expect(new AlterSubscriptionDisable({ subscription }).serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base DISABLE",
+    );
+  });
+
+  test("set options delegates to option formatter", async () => {
+    const subscription = makeSubscription({
+      slot_name: "custom_slot",
+      slot_is_none: false,
+      disable_on_error: true,
+      origin: "none",
+    });
+    const change = new AlterSubscriptionSetOptions({
+      subscription,
+      options: ["slot_name", "disable_on_error", "origin"],
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base SET (slot_name = 'custom_slot', disable_on_error = true, origin = 'none')",
+    );
+  });
+
+  test("set owner tracks role dependency", async () => {
+    const subscription = makeSubscription();
+    const change = new AlterSubscriptionSetOwner({
+      subscription,
+      owner: "new_owner",
+    });
+
+    expect(change.requires).toEqual([stableId.role("new_owner")]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base OWNER TO new_owner",
+    );
+  });
+});