@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.4

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(c.relacl) 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,124 @@
+import { describe, expect, test } from "bun:test";
+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", () => {
+    const subscription = makeSubscription({
+      conninfo: "dbname=postgres host=replica",
+    });
+    const change = new AlterSubscriptionSetConnection({ subscription });
+
+    expect(change.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base CONNECTION 'dbname=postgres host=replica'",
+    );
+  });
+
+  test("set publication preserves ordering and refresh hint when disabled", () => {
+    const enabledSubscription = makeSubscription({
+      publications: ["pub_a", "pub_b"],
+      enabled: true,
+    });
+    const enabledChange = new AlterSubscriptionSetPublication({
+      subscription: enabledSubscription,
+    });
+
+    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,
+    });
+
+    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", () => {
+    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", () => {
+    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"],
+    });
+
+    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", () => {
+    const subscription = makeSubscription();
+    const change = new AlterSubscriptionSetOwner({
+      subscription,
+      owner: "new_owner",
+    });
+
+    expect(change.requires).toEqual([stableId.role("new_owner")]);
+    expect(change.serialize()).toBe(
+      "ALTER SUBSCRIPTION sub_base OWNER TO new_owner",
+    );
+  });
+});

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

@@ -0,0 +1,110 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Subscription } from "../subscription.model.ts";
+import {
+  formatSubscriptionOption,
+  type SubscriptionSettableOption,
+} from "../utils.ts";
+import { AlterSubscriptionChange } from "./subscription.base.ts";
+
+export class AlterSubscriptionSetConnection extends AlterSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  serialize(): string {
+    return `ALTER SUBSCRIPTION ${this.subscription.name} CONNECTION ${quoteLiteral(this.subscription.conninfo)}`;
+  }
+}
+
+export class AlterSubscriptionSetPublication extends AlterSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  serialize(): string {
+    const base = `ALTER SUBSCRIPTION ${this.subscription.name} SET PUBLICATION ${this.subscription.publications.join(", ")}`;
+    if (!this.subscription.enabled) {
+      return `${base} WITH (refresh = false)`;
+    }
+    return base;
+  }
+}
+
+export class AlterSubscriptionEnable extends AlterSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  serialize(): string {
+    return `ALTER SUBSCRIPTION ${this.subscription.name} ENABLE`;
+  }
+}
+
+export class AlterSubscriptionDisable extends AlterSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  serialize(): string {
+    return `ALTER SUBSCRIPTION ${this.subscription.name} DISABLE`;
+  }
+}
+
+export class AlterSubscriptionSetOptions extends AlterSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+  private readonly options: SubscriptionSettableOption[];
+
+  constructor(props: {
+    subscription: Subscription;
+    options: SubscriptionSettableOption[];
+  }) {
+    super();
+    this.subscription = props.subscription;
+    this.options = props.options;
+  }
+
+  serialize(): string {
+    const assignments = this.options.map((option) =>
+      formatSubscriptionOption(this.subscription, option),
+    );
+    return `ALTER SUBSCRIPTION ${this.subscription.name} SET (${assignments.join(", ")})`;
+  }
+}
+
+export class AlterSubscriptionSetOwner extends AlterSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+  public readonly owner: string;
+
+  constructor(props: { subscription: Subscription; owner: string }) {
+    super();
+    this.subscription = props.subscription;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [stableId.role(this.owner)];
+  }
+
+  serialize(): string {
+    return `ALTER SUBSCRIPTION ${this.subscription.name} OWNER TO ${this.owner}`;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Subscription } from "../subscription.model.ts";
+
+abstract class BaseSubscriptionChange extends BaseChange {
+  abstract readonly subscription: Subscription;
+  abstract readonly scope: "object" | "comment";
+  readonly objectType = "subscription" as const;
+}
+
+export abstract class CreateSubscriptionChange extends BaseSubscriptionChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterSubscriptionChange extends BaseSubscriptionChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropSubscriptionChange extends BaseSubscriptionChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import { stableId } from "../../utils.ts";
+import { Subscription } from "../subscription.model.ts";
+import {
+  CreateCommentOnSubscription,
+  DropCommentOnSubscription,
+} from "./subscription.comment.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.comment", () => {
+  test("create comment serializes and declares dependencies", () => {
+    const subscription = makeSubscription({
+      comment: "subscription's metadata",
+    });
+    const change = new CreateCommentOnSubscription({ subscription });
+
+    expect(change.creates).toEqual([stableId.comment(subscription.stableId)]);
+    expect(change.requires).toEqual([subscription.stableId]);
+    expect(change.serialize()).toBe(
+      "COMMENT ON SUBSCRIPTION sub_base IS 'subscription''s metadata'",
+    );
+  });
+
+  test("drop comment serializes and tracks drops", () => {
+    const subscription = makeSubscription({ comment: "not used" });
+    const change = new DropCommentOnSubscription({ subscription });
+
+    expect(change.drops).toEqual([stableId.comment(subscription.stableId)]);
+    expect(change.requires).toEqual([
+      stableId.comment(subscription.stableId),
+      subscription.stableId,
+    ]);
+    expect(change.serialize()).toBe("COMMENT ON SUBSCRIPTION sub_base IS NULL");
+  });
+});

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

@@ -0,0 +1,64 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Subscription } from "../subscription.model.ts";
+import {
+  CreateSubscriptionChange,
+  DropSubscriptionChange,
+} from "./subscription.base.ts";
+
+export type CommentSubscription =
+  | CreateCommentOnSubscription
+  | DropCommentOnSubscription;
+
+export class CreateCommentOnSubscription extends CreateSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  get creates() {
+    return [stableId.comment(this.subscription.stableId)];
+  }
+
+  get requires() {
+    return [this.subscription.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON SUBSCRIPTION",
+      this.subscription.name,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: ensures comment provided by caller
+      quoteLiteral(this.subscription.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnSubscription extends DropSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  get drops() {
+    return [stableId.comment(this.subscription.stableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.comment(this.subscription.stableId),
+      this.subscription.stableId,
+    ];
+  }
+
+  serialize(): string {
+    return `COMMENT ON SUBSCRIPTION ${this.subscription.name} IS NULL`;
+  }
+}

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

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { stableId } from "../../utils.ts";
+import { Subscription } from "../subscription.model.ts";
+import { CreateSubscription } from "./subscription.create.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.create", () => {
+  test("serialize minimal subscription", () => {
+    const subscription = makeSubscription();
+    const change = new CreateSubscription({ subscription });
+
+    expect(change.creates).toEqual([subscription.stableId]);
+    expect(change.requires).toEqual([stableId.role(subscription.owner)]);
+    expect(change.serialize()).toBe(
+      "CREATE SUBSCRIPTION sub_base CONNECTION 'host=example dbname=postgres' PUBLICATION pub_base",
+    );
+  });
+
+  test("serialize subscription with extended options", () => {
+    const subscription = makeSubscription({
+      enabled: false,
+      binary: true,
+      streaming: "parallel",
+      two_phase: true,
+      disable_on_error: true,
+      password_required: false,
+      run_as_owner: true,
+      failover: true,
+      conninfo: "dbname=postgres application_name=sub_base",
+      slot_name: "custom_slot",
+      slot_is_none: false,
+      replication_slot_created: false,
+      synchronous_commit: "local",
+      publications: ["pub_b", "pub_a"],
+      origin: "none",
+    });
+
+    const change = new CreateSubscription({ subscription });
+
+    expect(change.requires).toEqual([stableId.role(subscription.owner)]);
+    expect(change.serialize()).toBe(
+      "CREATE SUBSCRIPTION sub_base CONNECTION 'dbname=postgres application_name=sub_base' PUBLICATION pub_a, pub_b WITH (enabled = false, slot_name = 'custom_slot', binary = true, streaming = 'parallel', synchronous_commit = 'local', two_phase = true, disable_on_error = true, password_required = false, run_as_owner = true, origin = 'none', failover = true, create_slot = false, connect = false)",
+    );
+  });
+});