@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

package/dist/core/objects/subscription/changes/subscription.comment.d.ts

@@ -0,0 +1,23 @@
+import type { Subscription } from "../subscription.model.ts";
+import { CreateSubscriptionChange, DropSubscriptionChange } from "./subscription.base.ts";
+export type CommentSubscription = CreateCommentOnSubscription | DropCommentOnSubscription;
+export declare class CreateCommentOnSubscription extends CreateSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "comment";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `subscription:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnSubscription extends DropSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "comment";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `subscription:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/subscription/changes/subscription.comment.js

@@ -0,0 +1,46 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateSubscriptionChange, DropSubscriptionChange, } from "./subscription.base.js";
+export class CreateCommentOnSubscription extends CreateSubscriptionChange {
+    subscription;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    get creates() {
+        return [stableId.comment(this.subscription.stableId)];
+    }
+    get requires() {
+        return [this.subscription.stableId];
+    }
+    serialize() {
+        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 {
+    subscription;
+    scope = "comment";
+    constructor(props) {
+        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() {
+        return `COMMENT ON SUBSCRIPTION ${this.subscription.name} IS NULL`;
+    }
+}

package/dist/core/objects/subscription/changes/subscription.create.d.ts

@@ -0,0 +1,12 @@
+import type { Subscription } from "../subscription.model.ts";
+import { CreateSubscriptionChange } from "./subscription.base.ts";
+export declare class CreateSubscription extends CreateSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    get creates(): `subscription:${string}`[];
+    get requires(): `role:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/subscription/changes/subscription.create.js

@@ -0,0 +1,52 @@
+// src/objects/subscription/changes/subscription.create.ts
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { collectSubscriptionOptions } from "../utils.js";
+import { CreateSubscriptionChange } from "./subscription.base.js";
+export class CreateSubscription extends CreateSubscriptionChange {
+    subscription;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    get creates() {
+        return [this.subscription.stableId];
+    }
+    get requires() {
+        return [stableId.role(this.subscription.owner)];
+    }
+    serialize() {
+        const parts = [
+            "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/dist/core/objects/subscription/changes/subscription.drop.d.ts

@@ -0,0 +1,11 @@
+import type { Subscription } from "../subscription.model.ts";
+import { DropSubscriptionChange } from "./subscription.base.ts";
+export declare class DropSubscription extends DropSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    get drops(): `subscription:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/subscription/changes/subscription.drop.js

@@ -0,0 +1,15 @@
+import { DropSubscriptionChange } from "./subscription.base.js";
+export class DropSubscription extends DropSubscriptionChange {
+    subscription;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    get drops() {
+        return [this.subscription.stableId];
+    }
+    serialize() {
+        return `DROP SUBSCRIPTION ${this.subscription.name}`;
+    }
+}

package/dist/core/objects/subscription/changes/subscription.types.d.ts

@@ -0,0 +1,5 @@
+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/dist/core/objects/subscription/changes/subscription.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/objects/subscription/subscription.diff.d.ts

@@ -0,0 +1,5 @@
+import type { SubscriptionChange } from "./changes/subscription.types.ts";
+import type { Subscription } from "./subscription.model.ts";
+export declare function diffSubscriptions(ctx: {
+    currentUser: string;
+}, main: Record<string, Subscription>, branch: Record<string, Subscription>): SubscriptionChange[];

package/dist/core/objects/subscription/subscription.diff.js

@@ -0,0 +1,167 @@
+import { diffObjects } from "../base.diff.js";
+import { hasNonAlterableChanges } from "../utils.js";
+import { AlterSubscriptionDisable, AlterSubscriptionEnable, AlterSubscriptionSetConnection, AlterSubscriptionSetOptions, AlterSubscriptionSetOwner, AlterSubscriptionSetPublication, } from "./changes/subscription.alter.js";
+import { CreateCommentOnSubscription, DropCommentOnSubscription, } from "./changes/subscription.comment.js";
+import { CreateSubscription } from "./changes/subscription.create.js";
+import { DropSubscription } from "./changes/subscription.drop.js";
+const NON_ALTERABLE_FIELDS = [
+    "two_phase",
+];
+const SETTABLE_OPTIONS = [
+    "slot_name",
+    "binary",
+    "streaming",
+    "synchronous_commit",
+    "disable_on_error",
+    "password_required",
+    "run_as_owner",
+    "origin",
+    "failover",
+];
+export function diffSubscriptions(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    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 = [];
+        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 = 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/dist/core/objects/subscription/subscription.model.d.ts

@@ -0,0 +1,80 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+declare const subscriptionPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    raw_name: z.ZodString;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodBoolean;
+    binary: z.ZodBoolean;
+    streaming: z.ZodEnum<{
+        off: "off";
+        on: "on";
+        parallel: "parallel";
+    }>;
+    two_phase: z.ZodBoolean;
+    disable_on_error: z.ZodBoolean;
+    password_required: z.ZodBoolean;
+    run_as_owner: z.ZodBoolean;
+    failover: z.ZodBoolean;
+    conninfo: z.ZodString;
+    slot_name: z.ZodNullable<z.ZodString>;
+    slot_is_none: z.ZodBoolean;
+    replication_slot_created: z.ZodBoolean;
+    synchronous_commit: z.ZodString;
+    publications: z.ZodArray<z.ZodString>;
+    origin: z.ZodEnum<{
+        any: "any";
+        none: "none";
+    }>;
+}, z.z.core.$strip>;
+export type SubscriptionProps = z.infer<typeof subscriptionPropsSchema>;
+export declare class Subscription extends BasePgModel {
+    readonly name: SubscriptionProps["name"];
+    readonly raw_name: SubscriptionProps["raw_name"];
+    readonly owner: SubscriptionProps["owner"];
+    readonly comment: SubscriptionProps["comment"];
+    readonly enabled: SubscriptionProps["enabled"];
+    readonly binary: SubscriptionProps["binary"];
+    readonly streaming: SubscriptionProps["streaming"];
+    readonly two_phase: SubscriptionProps["two_phase"];
+    readonly disable_on_error: SubscriptionProps["disable_on_error"];
+    readonly password_required: SubscriptionProps["password_required"];
+    readonly run_as_owner: SubscriptionProps["run_as_owner"];
+    readonly failover: SubscriptionProps["failover"];
+    readonly conninfo: SubscriptionProps["conninfo"];
+    readonly slot_name: SubscriptionProps["slot_name"];
+    readonly slot_is_none: SubscriptionProps["slot_is_none"];
+    readonly replication_slot_created: SubscriptionProps["replication_slot_created"];
+    readonly synchronous_commit: SubscriptionProps["synchronous_commit"];
+    readonly publications: SubscriptionProps["publications"];
+    readonly origin: SubscriptionProps["origin"];
+    constructor(props: SubscriptionProps);
+    get stableId(): `subscription:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        raw_name: string;
+        owner: string;
+        comment: string | null;
+        enabled: boolean;
+        binary: boolean;
+        streaming: "off" | "on" | "parallel";
+        two_phase: boolean;
+        disable_on_error: boolean;
+        password_required: boolean;
+        run_as_owner: boolean;
+        failover: boolean;
+        conninfo: string;
+        slot_name: string | null;
+        slot_is_none: boolean;
+        replication_slot_created: boolean;
+        synchronous_commit: string;
+        publications: string[];
+        origin: "any" | "none";
+    };
+}
+export declare function extractSubscriptions(sql: Sql): Promise<Subscription[]>;
+export {};

package/dist/core/objects/subscription/subscription.model.js

@@ -0,0 +1,166 @@
+import z from "zod";
+import { extractVersion } from "../../context.js";
+import { BasePgModel } from "../base.model.js";
+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 class Subscription extends BasePgModel {
+    name;
+    raw_name;
+    owner;
+    comment;
+    enabled;
+    binary;
+    streaming;
+    two_phase;
+    disable_on_error;
+    password_required;
+    run_as_owner;
+    failover;
+    conninfo;
+    slot_name;
+    slot_is_none;
+    replication_slot_created;
+    synchronous_commit;
+    publications;
+    origin;
+    constructor(props) {
+        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() {
+        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(sql) {
+    return sql.begin(async (tx) => {
+        await tx `set search_path = ''`;
+        const version = await extractVersion(tx);
+        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
+        const rows = await tx `
+      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,
+        ${isPostgres16OrGreater ? tx ` s.subpasswordrequired ` : tx ` true `} as password_required,
+        ${isPostgres17OrGreater ? tx ` s.subrunasowner ` : tx ` false `} as run_as_owner,
+        ${isPostgres17_2OrGreater ? tx ` s.subfailover ` : tx ` false `} 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,
+        ${isPostgres17_3OrGreater
+            ? tx ` case s.suborigin when 'none' then 'none' else 'any' end `
+            : tx ` 'any' `} 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 validated = rows.map((row) => subscriptionPropsSchema.parse(row));
+        return validated.map((row) => new Subscription(row));
+    });
+}

package/dist/core/objects/subscription/utils.d.ts

@@ -0,0 +1,37 @@
+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;
+}
+/**
+ * Convenience helper used by ALTER change classes. It stitches the option key/value
+ * into the canonical `"key = value"` form that PostgreSQL expects.
+ */
+export declare function formatSubscriptionOption(subscription: Subscription, option: SubscriptionSettableOption): string;
+/**
+ * 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 declare function collectSubscriptionOptions(subscription: Subscription, { includeEnabled, includeTwoPhase }?: CollectOptions): {
+    key: string;
+    value: string;
+}[];
+export {};