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

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

@@ -0,0 +1,69 @@
+// src/objects/subscription/changes/subscription.create.ts
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Subscription } from "../subscription.model.ts";
+import { collectSubscriptionOptions } from "../utils.ts";
+import { CreateSubscriptionChange } from "./subscription.base.ts";
+
+export class CreateSubscription extends CreateSubscriptionChange {
+  readonly subscription: Subscription;
+  readonly scope = "object" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  get creates() {
+    return [this.subscription.stableId];
+  }
+
+  get requires() {
+    return [stableId.role(this.subscription.owner)];
+  }
+
+  serialize(): string {
+    const parts: string[] = [
+      "CREATE SUBSCRIPTION",
+      this.subscription.name,
+      "CONNECTION",
+      quoteLiteral(this.subscription.conninfo),
+      "PUBLICATION",
+      this.subscription.publications.join(", "),
+    ];
+
+    const optionEntries = collectSubscriptionOptions(this.subscription, {
+      includeTwoPhase: true,
+      includeEnabled: true,
+    });
+    const optionsMap = new Map(
+      optionEntries.map(({ key, value }) => [key, value]),
+    );
+
+    if (!this.subscription.replication_slot_created) {
+      optionsMap.set("create_slot", "false");
+      optionsMap.set("connect", "false");
+
+      const defaultSlotName = this.subscription.raw_name;
+      const slotName = this.subscription.slot_name ?? defaultSlotName;
+      const shouldUseNone =
+        this.subscription.slot_is_none || slotName === defaultSlotName;
+
+      if (shouldUseNone) {
+        optionsMap.set("slot_name", "NONE");
+      } else {
+        optionsMap.set("slot_name", quoteLiteral(slotName));
+      }
+    }
+
+    const withOptions = Array.from(optionsMap.entries()).map(
+      ([key, value]) => `${key} = ${value}`,
+    );
+
+    if (withOptions.length > 0) {
+      parts.push("WITH", `(${withOptions.join(", ")})`);
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { Subscription } from "../subscription.model.ts";
+import { DropSubscription } from "./subscription.drop.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.drop", () => {
+  test("serialize drop subscription", () => {
+    const subscription = makeSubscription();
+    const change = new DropSubscription({ subscription });
+
+    expect(change.drops).toEqual([subscription.stableId]);
+    expect(change.serialize()).toBe("DROP SUBSCRIPTION sub_base");
+  });
+});

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

@@ -0,0 +1,20 @@
+import type { Subscription } from "../subscription.model.ts";
+import { DropSubscriptionChange } from "./subscription.base.ts";
+
+export class DropSubscription extends DropSubscriptionChange {
+  public readonly subscription: Subscription;
+  public readonly scope = "object" as const;
+
+  constructor(props: { subscription: Subscription }) {
+    super();
+    this.subscription = props.subscription;
+  }
+
+  get drops() {
+    return [this.subscription.stableId];
+  }
+
+  serialize(): string {
+    return `DROP SUBSCRIPTION ${this.subscription.name}`;
+  }
+}

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

@@ -0,0 +1,22 @@
+import type {
+  AlterSubscriptionDisable,
+  AlterSubscriptionEnable,
+  AlterSubscriptionSetConnection,
+  AlterSubscriptionSetOptions,
+  AlterSubscriptionSetOwner,
+  AlterSubscriptionSetPublication,
+} from "./subscription.alter.ts";
+import type { CommentSubscription } from "./subscription.comment.ts";
+import type { CreateSubscription } from "./subscription.create.ts";
+import type { DropSubscription } from "./subscription.drop.ts";
+
+export type SubscriptionChange =
+  | CreateSubscription
+  | DropSubscription
+  | AlterSubscriptionSetConnection
+  | AlterSubscriptionSetPublication
+  | AlterSubscriptionEnable
+  | AlterSubscriptionDisable
+  | AlterSubscriptionSetOptions
+  | AlterSubscriptionSetOwner
+  | CommentSubscription;

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

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "bun:test";
+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 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(
+      { currentUser: "postgres" },
+      {},
+      { [subscription.stableId]: subscription },
+    );
+    expect(created.some((change) => change instanceof CreateSubscription)).toBe(
+      true,
+    );
+
+    const dropped = diffSubscriptions(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [mainSubscription.stableId]: mainSubscription },
+      { [branchDisabled.stableId]: branchDisabled },
+    );
+    expect(
+      disableChanges.some(
+        (change) => change instanceof AlterSubscriptionDisable,
+      ),
+    ).toBe(true);
+
+    const enableChanges = diffSubscriptions(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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(
+      { currentUser: "postgres" },
+      { [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,241 @@
+import { diffObjects } from "../base.diff.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: { currentUser: string },
+  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;
+}