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

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

@@ -0,0 +1,275 @@
+import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { diffSecurityLabels } from "../security-label.types.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 {
+  CreateSecurityLabelOnSubscription,
+  DropSecurityLabelOnSubscription,
+} from "./changes/subscription.security-label.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 label of subscription.security_labels) {
+      changes.push(
+        new CreateSecurityLabelOnSubscription({
+          subscription,
+          securityLabel: label,
+        }),
+      );
+    }
+  }
+
+  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,
+          }),
+        );
+      }
+    }
+
+    // SECURITY LABELS
+    changes.push(
+      ...diffSecurityLabels<
+        CreateSecurityLabelOnSubscription | DropSecurityLabelOnSubscription
+      >(
+        mainSubscription.security_labels,
+        branchSubscription.security_labels,
+        (securityLabel) =>
+          new CreateSecurityLabelOnSubscription({
+            subscription: branchSubscription,
+            securityLabel,
+          }),
+        (securityLabel) =>
+          new DropSecurityLabelOnSubscription({
+            subscription: mainSubscription,
+            securityLabel,
+          }),
+      ),
+    );
+  }
+
+  return changes;
+}

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

@@ -0,0 +1,211 @@
+import type { Pool } from "pg";
+import z from "zod";
+import { extractVersion } from "../../context.ts";
+import { BasePgModel } from "../base.model.ts";
+import {
+  type SecurityLabelProps,
+  securityLabelPropsSchema,
+} from "../security-label.types.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"]),
+  security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+});
+
+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"];
+  public readonly security_labels: SecurityLabelProps[];
+
+  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;
+    this.security_labels = props.security_labels ?? [];
+  }
+
+  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,
+      security_labels: this.security_labels,
+    };
+  }
+}
+
+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,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object('provider', sl.provider, 'label', sl.label)
+              order by sl.provider
+            )
+            from pg_catalog.pg_seclabel sl
+            where sl.objoid = s.oid
+              and sl.classoid = 'pg_subscription'::regclass
+              and sl.objsubid = 0
+          ),
+          '[]'::json
+        ) as security_labels
+      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));
+}

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

@@ -0,0 +1,156 @@
+// src/objects/subscription/utils.ts
+import { quoteLiteral } from "../base.change.ts";
+import type { Subscription } from "./subscription.model.ts";
+
+/**
+ * Subscription parameters that can be manipulated via `ALTER SUBSCRIPTION ... SET (...)`.
+ * The list intentionally mirrors the options we surface in diff output. When you add a new
+ * entry here, make sure the corresponding serialization/version handling exists in
+ * `getSubscriptionOptionValue` and in the SQL emitter.
+ */
+export type SubscriptionSettableOption =
+  | "slot_name"
+  | "binary"
+  | "streaming"
+  | "synchronous_commit"
+  | "disable_on_error"
+  | "password_required"
+  | "run_as_owner"
+  | "origin"
+  | "failover";
+
+interface CollectOptions {
+  includeEnabled?: boolean;
+  includeTwoPhase?: boolean;
+}
+
+/**
+ * Resolve the textual value we should emit for a given subscription option.
+ *
+ * Each branch encodes the quirks we already normalize in the model. For example,
+ * `slot_name` collapses to `NONE` when the subscription was extracted without an
+ * associated logical slot, while `streaming` stays free-form because PG 17+ allows
+ * enumerated values (`on`/`off`/`parallel`).
+ */
+function getSubscriptionOptionValue(
+  subscription: Subscription,
+  option: SubscriptionSettableOption,
+): string {
+  switch (option) {
+    case "slot_name": {
+      if (subscription.slot_is_none) return "NONE";
+      if (subscription.slot_name) return quoteLiteral(subscription.slot_name);
+      return quoteLiteral(subscription.raw_name);
+    }
+    case "binary":
+      return subscription.binary ? "true" : "false";
+    case "streaming":
+      return quoteLiteral(subscription.streaming);
+    case "synchronous_commit":
+      return quoteLiteral(subscription.synchronous_commit);
+    case "disable_on_error":
+      return subscription.disable_on_error ? "true" : "false";
+    case "password_required":
+      return subscription.password_required ? "true" : "false";
+    case "run_as_owner":
+      return subscription.run_as_owner ? "true" : "false";
+    case "origin":
+      return quoteLiteral(subscription.origin);
+    case "failover":
+      return subscription.failover ? "true" : "false";
+    default: {
+      const _exhaustive: never = option;
+      return _exhaustive;
+    }
+  }
+}
+
+/**
+ * Convenience helper used by ALTER change classes. It stitches the option key/value
+ * into the canonical `"key = value"` form that PostgreSQL expects.
+ */
+export function formatSubscriptionOption(
+  subscription: Subscription,
+  option: SubscriptionSettableOption,
+): string {
+  return `${option} = ${getSubscriptionOptionValue(subscription, option)}`;
+}
+
+/**
+ * Collect all options that should accompany a CREATE/ALTER statement.
+ *
+ * This routine encapsulates the nuanced logic around default slot handling and
+ * version-dependent fields:
+ *  - When `includeEnabled` is true we emit `enabled = false` for disabled subs so that
+ *    recreating them does not inadvertently enable replication.
+ *  - When we know no replication slot exists we force `slot_name = NONE`, plus
+ *    `connect = false` / `create_slot = false` in the caller.
+ *  - Optional flags (`streaming`, `password_required`, `origin`, etc.) are emitted only
+ *    when their value deviates from the PostgreSQL defaults.
+ *
+ * Callers can toggle `includeTwoPhase` / `includeEnabled` to opt-in to those
+ * adjustments depending on which statement is being generated.
+ */
+export function collectSubscriptionOptions(
+  subscription: Subscription,
+  { includeEnabled = false, includeTwoPhase = false }: CollectOptions = {},
+) {
+  const entries: { key: string; value: string }[] = [];
+
+  if (includeEnabled && !subscription.enabled) {
+    entries.push({ key: "enabled", value: "false" });
+  }
+
+  if (subscription.slot_is_none) {
+    entries.push({ key: "slot_name", value: "NONE" });
+  } else if (subscription.slot_name) {
+    entries.push({
+      key: "slot_name",
+      value: quoteLiteral(subscription.slot_name),
+    });
+  }
+
+  if (subscription.binary) {
+    entries.push({ key: "binary", value: "true" });
+  }
+
+  if (subscription.streaming !== "off") {
+    entries.push({
+      key: "streaming",
+      value: quoteLiteral(subscription.streaming),
+    });
+  }
+
+  if (subscription.synchronous_commit !== "off") {
+    entries.push({
+      key: "synchronous_commit",
+      value: quoteLiteral(subscription.synchronous_commit),
+    });
+  }
+
+  if (includeTwoPhase && subscription.two_phase) {
+    entries.push({ key: "two_phase", value: "true" });
+  }
+
+  if (subscription.disable_on_error) {
+    entries.push({ key: "disable_on_error", value: "true" });
+  }
+
+  if (!subscription.password_required) {
+    entries.push({ key: "password_required", value: "false" });
+  }
+
+  if (subscription.run_as_owner) {
+    entries.push({ key: "run_as_owner", value: "true" });
+  }
+
+  if (subscription.origin === "none") {
+    entries.push({ key: "origin", value: quoteLiteral("none") });
+  }
+
+  if (subscription.failover) {
+    entries.push({ key: "failover", value: "true" });
+  }
+
+  return entries;
+}