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

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

@@ -0,0 +1,237 @@
+import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import {
+  AlterSubscriptionDisable,
+  AlterSubscriptionEnable,
+  AlterSubscriptionSetConnection,
+  AlterSubscriptionSetOptions,
+  AlterSubscriptionSetOwner,
+  AlterSubscriptionSetPublication,
+} from "./changes/subscription.alter.ts";
+import {
+  CreateCommentOnSubscription,
+  DropCommentOnSubscription,
+} from "./changes/subscription.comment.ts";
+import { CreateSubscription } from "./changes/subscription.create.ts";
+import { DropSubscription } from "./changes/subscription.drop.ts";
+import { diffSubscriptions } from "./subscription.diff.ts";
+import { Subscription, type SubscriptionProps } from "./subscription.model.ts";
+
+const ctx: Pick<ObjectDiffContext, "currentUser"> = {
+  currentUser: "postgres",
+};
+
+const baseProps: SubscriptionProps = {
+  name: "mysub",
+  raw_name: "mysub",
+  owner: "postgres",
+  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=localhost port=5432 dbname=postgres",
+  slot_name: null,
+  slot_is_none: false,
+  replication_slot_created: true,
+  synchronous_commit: "off",
+  publications: ["pub_a"],
+  origin: "any",
+};
+
+describe.concurrent("subscription.diff", () => {
+  test("create and drop subscription", () => {
+    const subscription = new Subscription(baseProps);
+    const created = diffSubscriptions(
+      ctx,
+      {},
+      { [subscription.stableId]: subscription },
+    );
+    expect(created.some((change) => change instanceof CreateSubscription)).toBe(
+      true,
+    );
+
+    const dropped = diffSubscriptions(
+      ctx,
+      { [subscription.stableId]: subscription },
+      {},
+    );
+    expect(dropped.some((change) => change instanceof DropSubscription)).toBe(
+      true,
+    );
+  });
+
+  test("detect connection string change", () => {
+    // conninfo changes are detected by diff, but filtered by integration filter
+    const mainSubscription = new Subscription(baseProps);
+    const branchSubscription = new Subscription({
+      ...baseProps,
+      conninfo: "host=replica port=5433 dbname=postgres",
+    });
+    const changes = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchSubscription.stableId]: branchSubscription },
+    );
+    // conninfo changes are detected (filtering happens at integration level)
+    expect(
+      changes.some(
+        (change) => change instanceof AlterSubscriptionSetConnection,
+      ),
+    ).toBe(true);
+  });
+
+  test("detect publication list change", () => {
+    const mainSubscription = new Subscription(baseProps);
+    const branchSubscription = new Subscription({
+      ...baseProps,
+      publications: ["pub_a", "pub_b"],
+    });
+    const changes = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchSubscription.stableId]: branchSubscription },
+    );
+    expect(
+      changes.some(
+        (change) => change instanceof AlterSubscriptionSetPublication,
+      ),
+    ).toBe(true);
+  });
+
+  test("detect enabled toggle", () => {
+    const mainSubscription = new Subscription(baseProps);
+    const branchDisabled = new Subscription({
+      ...baseProps,
+      enabled: false,
+    });
+    const disableChanges = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchDisabled.stableId]: branchDisabled },
+    );
+    expect(
+      disableChanges.some(
+        (change) => change instanceof AlterSubscriptionDisable,
+      ),
+    ).toBe(true);
+
+    const enableChanges = diffSubscriptions(
+      ctx,
+      { [branchDisabled.stableId]: branchDisabled },
+      { [mainSubscription.stableId]: mainSubscription },
+    );
+    expect(
+      enableChanges.some((change) => change instanceof AlterSubscriptionEnable),
+    ).toBe(true);
+  });
+
+  test("detect option changes including slot name overrides", () => {
+    const mainSubscription = new Subscription(baseProps);
+    const branchSubscription = new Subscription({
+      ...baseProps,
+      binary: true,
+      streaming: "parallel",
+      synchronous_commit: "local",
+      disable_on_error: true,
+      password_required: false,
+      run_as_owner: true,
+      origin: "none",
+      failover: true,
+      slot_name: "custom_slot",
+      slot_is_none: false,
+    });
+    const changes = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchSubscription.stableId]: branchSubscription },
+    );
+    const setOptionsChange = changes.find(
+      (change) => change instanceof AlterSubscriptionSetOptions,
+    ) as AlterSubscriptionSetOptions | undefined;
+    expect(setOptionsChange).toBeDefined();
+    expect(setOptionsChange?.serialize()).toBe(
+      "ALTER SUBSCRIPTION mysub SET (slot_name = 'custom_slot', binary = true, streaming = 'parallel', synchronous_commit = 'local', disable_on_error = true, password_required = false, run_as_owner = true, origin = 'none', failover = true)",
+    );
+  });
+
+  test("set slot name to NONE when branch subscription uses slotless configuration", () => {
+    const mainSubscription = new Subscription(baseProps);
+    const branchSubscription = new Subscription({
+      ...baseProps,
+      slot_name: null,
+      slot_is_none: true,
+      replication_slot_created: false,
+    });
+    const changes = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchSubscription.stableId]: branchSubscription },
+    );
+    const setOptionsChange = changes.find(
+      (change) => change instanceof AlterSubscriptionSetOptions,
+    ) as AlterSubscriptionSetOptions | undefined;
+    expect(setOptionsChange).toBeDefined();
+    expect(setOptionsChange?.serialize()).toBe(
+      "ALTER SUBSCRIPTION mysub SET (slot_name = NONE)",
+    );
+  });
+
+  test("owner and comment changes", () => {
+    const mainSubscription = new Subscription(baseProps);
+    const branchSubscription = new Subscription({
+      ...baseProps,
+      owner: "other_role",
+      comment: "replication subscription",
+    });
+    const changes = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchSubscription.stableId]: branchSubscription },
+    );
+    expect(
+      changes.some((change) => change instanceof AlterSubscriptionSetOwner),
+    ).toBe(true);
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnSubscription),
+    ).toBe(true);
+
+    const removeCommentSubscription = new Subscription({
+      ...baseProps,
+      comment: null,
+    });
+    const dropCommentChanges = diffSubscriptions(
+      ctx,
+      { [branchSubscription.stableId]: branchSubscription },
+      { [removeCommentSubscription.stableId]: removeCommentSubscription },
+    );
+    expect(
+      dropCommentChanges.some(
+        (change) => change instanceof DropCommentOnSubscription,
+      ),
+    ).toBe(true);
+  });
+
+  test("two_phase change triggers drop and recreate", () => {
+    const mainSubscription = new Subscription(baseProps);
+    const branchSubscription = new Subscription({
+      ...baseProps,
+      two_phase: true,
+    });
+    const changes = diffSubscriptions(
+      ctx,
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchSubscription.stableId]: branchSubscription },
+    );
+    expect(
+      changes.filter((change) => change instanceof DropSubscription).length,
+    ).toBe(1);
+    expect(
+      changes.filter((change) => change instanceof CreateSubscription).length,
+    ).toBe(1);
+  });
+});

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

@@ -0,0 +1,242 @@
+import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterSubscriptionDisable,
+  AlterSubscriptionEnable,
+  AlterSubscriptionSetConnection,
+  AlterSubscriptionSetOptions,
+  AlterSubscriptionSetOwner,
+  AlterSubscriptionSetPublication,
+} from "./changes/subscription.alter.ts";
+import {
+  CreateCommentOnSubscription,
+  DropCommentOnSubscription,
+} from "./changes/subscription.comment.ts";
+import { CreateSubscription } from "./changes/subscription.create.ts";
+import { DropSubscription } from "./changes/subscription.drop.ts";
+import type { SubscriptionChange } from "./changes/subscription.types.ts";
+import type { Subscription } from "./subscription.model.ts";
+import type { SubscriptionSettableOption } from "./utils.ts";
+
+const NON_ALTERABLE_FIELDS: Array<keyof Subscription["dataFields"]> = [
+  "two_phase",
+];
+
+const SETTABLE_OPTIONS: SubscriptionSettableOption[] = [
+  "slot_name",
+  "binary",
+  "streaming",
+  "synchronous_commit",
+  "disable_on_error",
+  "password_required",
+  "run_as_owner",
+  "origin",
+  "failover",
+];
+
+export function diffSubscriptions(
+  ctx: Pick<ObjectDiffContext, "currentUser">,
+  main: Record<string, Subscription>,
+  branch: Record<string, Subscription>,
+): SubscriptionChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+  const changes: SubscriptionChange[] = [];
+
+  for (const id of created) {
+    const subscription = branch[id];
+    changes.push(new CreateSubscription({ subscription }));
+
+    // OWNER: If the subscription should be owned by someone other than the current user,
+    // emit ALTER SUBSCRIPTION ... OWNER TO after creation
+    if (subscription.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterSubscriptionSetOwner({
+          subscription,
+          owner: subscription.owner,
+        }),
+      );
+    }
+
+    if (subscription.comment !== null) {
+      changes.push(new CreateCommentOnSubscription({ subscription }));
+    }
+  }
+
+  for (const id of dropped) {
+    changes.push(new DropSubscription({ subscription: main[id] }));
+  }
+
+  for (const id of altered) {
+    const mainSubscription = main[id];
+    const branchSubscription = branch[id];
+
+    if (
+      hasNonAlterableChanges(
+        mainSubscription.dataFields,
+        branchSubscription.dataFields,
+        NON_ALTERABLE_FIELDS,
+      )
+    ) {
+      changes.push(new DropSubscription({ subscription: mainSubscription }));
+      changes.push(
+        new CreateSubscription({ subscription: branchSubscription }),
+      );
+      if (branchSubscription.comment !== null) {
+        changes.push(
+          new CreateCommentOnSubscription({ subscription: branchSubscription }),
+        );
+      }
+      continue;
+    }
+
+    if (mainSubscription.conninfo !== branchSubscription.conninfo) {
+      changes.push(
+        new AlterSubscriptionSetConnection({
+          subscription: branchSubscription,
+        }),
+      );
+    }
+
+    const publicationsChanged =
+      mainSubscription.publications.length !==
+        branchSubscription.publications.length ||
+      mainSubscription.publications.some(
+        (pub, index) => pub !== branchSubscription.publications[index],
+      );
+
+    if (publicationsChanged) {
+      changes.push(
+        new AlterSubscriptionSetPublication({
+          subscription: branchSubscription,
+        }),
+      );
+    }
+
+    if (mainSubscription.enabled !== branchSubscription.enabled) {
+      if (branchSubscription.enabled) {
+        changes.push(
+          new AlterSubscriptionEnable({ subscription: branchSubscription }),
+        );
+      } else {
+        changes.push(
+          new AlterSubscriptionDisable({ subscription: branchSubscription }),
+        );
+      }
+    }
+
+    const optionKeys: SubscriptionSettableOption[] = [];
+    for (const option of SETTABLE_OPTIONS) {
+      switch (option) {
+        case "slot_name": {
+          if (
+            mainSubscription.slot_is_none !== branchSubscription.slot_is_none ||
+            mainSubscription.slot_name !== branchSubscription.slot_name
+          ) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "binary": {
+          if (mainSubscription.binary !== branchSubscription.binary) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "streaming": {
+          if (mainSubscription.streaming !== branchSubscription.streaming) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "synchronous_commit": {
+          if (
+            mainSubscription.synchronous_commit !==
+            branchSubscription.synchronous_commit
+          ) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "disable_on_error": {
+          if (
+            mainSubscription.disable_on_error !==
+            branchSubscription.disable_on_error
+          ) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "password_required": {
+          if (
+            mainSubscription.password_required !==
+            branchSubscription.password_required
+          ) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "run_as_owner": {
+          if (
+            mainSubscription.run_as_owner !== branchSubscription.run_as_owner
+          ) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "origin": {
+          if (mainSubscription.origin !== branchSubscription.origin) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        case "failover": {
+          if (mainSubscription.failover !== branchSubscription.failover) {
+            optionKeys.push(option);
+          }
+          break;
+        }
+        default: {
+          const _exhaustive: never = option;
+          void _exhaustive;
+        }
+      }
+    }
+
+    if (optionKeys.length > 0) {
+      changes.push(
+        new AlterSubscriptionSetOptions({
+          subscription: branchSubscription,
+          options: optionKeys,
+        }),
+      );
+    }
+
+    if (mainSubscription.owner !== branchSubscription.owner) {
+      changes.push(
+        new AlterSubscriptionSetOwner({
+          subscription: branchSubscription,
+          owner: branchSubscription.owner,
+        }),
+      );
+    }
+
+    if (mainSubscription.comment !== branchSubscription.comment) {
+      if (branchSubscription.comment === null) {
+        if (mainSubscription.comment !== null) {
+          changes.push(
+            new DropCommentOnSubscription({ subscription: mainSubscription }),
+          );
+        }
+      } else {
+        changes.push(
+          new CreateCommentOnSubscription({
+            subscription: branchSubscription,
+          }),
+        );
+      }
+    }
+  }
+
+  return changes;
+}

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

@@ -0,0 +1,190 @@
+import type { Pool } from "pg";
+import z from "zod";
+import { extractVersion } from "../../context.ts";
+import { BasePgModel } from "../base.model.ts";
+
+const subscriptionPropsSchema = z.object({
+  name: z.string(),
+  raw_name: z.string(),
+  owner: z.string(),
+  comment: z.string().nullable(),
+  enabled: z.boolean(),
+  binary: z.boolean(),
+  streaming: z.enum(["off", "on", "parallel"]),
+  two_phase: z.boolean(),
+  disable_on_error: z.boolean(),
+  password_required: z.boolean(),
+  run_as_owner: z.boolean(),
+  failover: z.boolean(),
+  conninfo: z.string(),
+  slot_name: z.string().nullable(),
+  slot_is_none: z.boolean(),
+  replication_slot_created: z.boolean(),
+  synchronous_commit: z.string(),
+  publications: z.array(z.string()),
+  origin: z.enum(["any", "none"]),
+});
+
+export type SubscriptionProps = z.infer<typeof subscriptionPropsSchema>;
+
+export class Subscription extends BasePgModel {
+  public readonly name: SubscriptionProps["name"];
+  public readonly raw_name: SubscriptionProps["raw_name"];
+  public readonly owner: SubscriptionProps["owner"];
+  public readonly comment: SubscriptionProps["comment"];
+  public readonly enabled: SubscriptionProps["enabled"];
+  public readonly binary: SubscriptionProps["binary"];
+  public readonly streaming: SubscriptionProps["streaming"];
+  public readonly two_phase: SubscriptionProps["two_phase"];
+  public readonly disable_on_error: SubscriptionProps["disable_on_error"];
+  public readonly password_required: SubscriptionProps["password_required"];
+  public readonly run_as_owner: SubscriptionProps["run_as_owner"];
+  public readonly failover: SubscriptionProps["failover"];
+  public readonly conninfo: SubscriptionProps["conninfo"];
+  public readonly slot_name: SubscriptionProps["slot_name"];
+  public readonly slot_is_none: SubscriptionProps["slot_is_none"];
+  public readonly replication_slot_created: SubscriptionProps["replication_slot_created"];
+  public readonly synchronous_commit: SubscriptionProps["synchronous_commit"];
+  public readonly publications: SubscriptionProps["publications"];
+  public readonly origin: SubscriptionProps["origin"];
+
+  constructor(props: SubscriptionProps) {
+    super();
+
+    this.name = props.name;
+    this.raw_name = props.raw_name;
+    this.owner = props.owner;
+    this.comment = props.comment;
+    this.enabled = props.enabled;
+    this.binary = props.binary;
+    this.streaming = props.streaming;
+    this.two_phase = props.two_phase;
+    this.disable_on_error = props.disable_on_error;
+    this.password_required = props.password_required;
+    this.run_as_owner = props.run_as_owner;
+    this.failover = props.failover;
+    this.conninfo = props.conninfo;
+    this.slot_name = props.slot_name;
+    this.slot_is_none = props.slot_is_none;
+    this.replication_slot_created = props.replication_slot_created;
+    this.synchronous_commit = props.synchronous_commit;
+    this.publications = [...props.publications].sort((a, b) =>
+      a.localeCompare(b),
+    );
+    this.origin = props.origin;
+  }
+
+  get stableId(): `subscription:${string}` {
+    return `subscription:${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      raw_name: this.raw_name,
+      owner: this.owner,
+      comment: this.comment,
+      enabled: this.enabled,
+      binary: this.binary,
+      streaming: this.streaming,
+      two_phase: this.two_phase,
+      disable_on_error: this.disable_on_error,
+      password_required: this.password_required,
+      run_as_owner: this.run_as_owner,
+      failover: this.failover,
+      conninfo: this.conninfo,
+      slot_name: this.slot_name,
+      slot_is_none: this.slot_is_none,
+      replication_slot_created: this.replication_slot_created,
+      synchronous_commit: this.synchronous_commit,
+      publications: this.publications,
+      origin: this.origin,
+    };
+  }
+}
+
+export async function extractSubscriptions(
+  pool: Pool,
+): Promise<Subscription[]> {
+  const version = await extractVersion(pool);
+  const isPostgres16OrGreater = version >= 160000;
+  const isPostgres17OrGreater = version >= 170000;
+  const isPostgres17_2OrGreater = version >= 170002; // failover added in 17.2 (170002)
+  const isPostgres17_3OrGreater = version >= 170003; // origin column added in 17.3
+
+  // Build the query dynamically based on PostgreSQL version
+  const passwordRequiredExpr = isPostgres16OrGreater
+    ? "s.subpasswordrequired"
+    : "true";
+  const runAsOwnerExpr = isPostgres17OrGreater ? "s.subrunasowner" : "false";
+  const failoverExpr = isPostgres17_2OrGreater ? "s.subfailover" : "false";
+  const originExpr = isPostgres17_3OrGreater
+    ? "case s.suborigin when 'none' then 'none' else 'any' end"
+    : "'any'";
+
+  const queryText = `
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_subscription'::regclass
+      ),
+      scoped_subscriptions as (
+        select s.*
+        from pg_subscription s
+        where s.subdbid = (select oid from pg_database where datname = current_database())
+      )
+      select
+        quote_ident(s.subname) as name,
+        s.subname::text as raw_name,
+        s.subowner::regrole::text as owner,
+        obj_description(s.oid, 'pg_subscription') as comment,
+        s.subenabled as enabled,
+        s.subbinary as binary,
+        case s.substream::text
+          when 'f' then 'off'
+          when 't' then 'on'
+          when 'p' then 'parallel'
+          else 'off'
+        end as streaming,
+        (s.subtwophasestate <> 'd') as two_phase,
+        s.subdisableonerr as disable_on_error,
+        ${passwordRequiredExpr} as password_required,
+        ${runAsOwnerExpr} as run_as_owner,
+        ${failoverExpr} as failover,
+        s.subconninfo as conninfo,
+        case
+          when s.subslotname is null then null
+          when s.subslotname = s.subname then null
+          else s.subslotname::text
+        end as slot_name,
+        s.subslotname is null as slot_is_none,
+        (r.slot_name is not null) as replication_slot_created,
+        s.subsynccommit as synchronous_commit,
+        coalesce(
+          (
+            select json_agg(quote_ident(pub) order by quote_ident(pub))
+            from unnest(s.subpublications) as pub
+          ),
+          '[]'::json
+        ) as publications,
+        ${originExpr} as origin
+      from scoped_subscriptions s
+      left join pg_replication_slots r
+        on r.slot_name = s.subslotname
+       and r.datoid = s.subdbid
+      left join extension_oids e on e.objid = s.oid
+      where e.objid is null
+      order by s.subname
+  `;
+
+  const { rows } = await pool.query<SubscriptionProps>(queryText);
+
+  const validated = rows.map((row) => subscriptionPropsSchema.parse(row));
+  return validated.map((row) => new Subscription(row));
+}