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

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,70 @@
+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 {
+  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", async () => {
+    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]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "COMMENT ON SUBSCRIPTION sub_base IS 'subscription''s metadata'",
+    );
+  });
+
+  test("drop comment serializes and tracks drops", async () => {
+    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,
+    ]);
+    await assertValidSql(change.serialize());
+    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,80 @@
+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 { 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", async () => {
+    const subscription = makeSubscription();
+    const change = new CreateSubscription({ subscription });
+
+    expect(change.creates).toEqual([subscription.stableId]);
+    expect(change.requires).toEqual([stableId.role(subscription.owner)]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "CREATE SUBSCRIPTION sub_base CONNECTION 'host=example dbname=postgres' PUBLICATION pub_base",
+    );
+  });
+
+  test("serialize subscription with extended options", async () => {
+    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)]);
+    await assertValidSql(change.serialize());
+    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)",
+    );
+  });
+});

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,48 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+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", async () => {
+    const subscription = makeSubscription();
+    const change = new DropSubscription({ subscription });
+
+    expect(change.drops).toEqual([subscription.stableId]);
+    await assertValidSql(change.serialize());
+    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;