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

package/dist/core/objects/event-trigger/changes/event-trigger.comment.js

@@ -0,0 +1,46 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateEventTriggerChange, DropEventTriggerChange, } from "./event-trigger.base.js";
+export class CreateCommentOnEventTrigger extends CreateEventTriggerChange {
+    eventTrigger;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.eventTrigger = props.eventTrigger;
+    }
+    get creates() {
+        return [stableId.comment(this.eventTrigger.stableId)];
+    }
+    get requires() {
+        return [this.eventTrigger.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON EVENT TRIGGER",
+            this.eventTrigger.name,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: comment creation implies non-null
+            quoteLiteral(this.eventTrigger.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnEventTrigger extends DropEventTriggerChange {
+    eventTrigger;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.eventTrigger = props.eventTrigger;
+    }
+    get drops() {
+        return [stableId.comment(this.eventTrigger.stableId)];
+    }
+    get requires() {
+        return [
+            stableId.comment(this.eventTrigger.stableId),
+            this.eventTrigger.stableId,
+        ];
+    }
+    serialize() {
+        return ["COMMENT ON EVENT TRIGGER", this.eventTrigger.name, "IS NULL"].join(" ");
+    }
+}

package/dist/core/objects/event-trigger/changes/event-trigger.create.d.ts

@@ -0,0 +1,25 @@
+import type { EventTrigger } from "../event-trigger.model.ts";
+import { CreateEventTriggerChange } from "./event-trigger.base.ts";
+/**
+ * Create an event trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createeventtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE EVENT TRIGGER name
+ *     ON event
+ *     [ WHEN TAG IN (tag [, ...]) [ AND ... ] ]
+ *     EXECUTE { FUNCTION | PROCEDURE } function_name()
+ * ```
+ */
+export declare class CreateEventTrigger extends CreateEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly scope: "object";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+    });
+    get creates(): `eventTrigger:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/event-trigger/changes/event-trigger.create.js

@@ -0,0 +1,55 @@
+import { quoteLiteral } from "../../base.change.js";
+import { parseProcedureReference, stableId } from "../../utils.js";
+import { CreateEventTriggerChange } from "./event-trigger.base.js";
+/**
+ * Create an event trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createeventtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE EVENT TRIGGER name
+ *     ON event
+ *     [ WHEN TAG IN (tag [, ...]) [ AND ... ] ]
+ *     EXECUTE { FUNCTION | PROCEDURE } function_name()
+ * ```
+ */
+export class CreateEventTrigger extends CreateEventTriggerChange {
+    eventTrigger;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.eventTrigger = props.eventTrigger;
+    }
+    get creates() {
+        return [this.eventTrigger.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Owner dependency
+        dependencies.add(stableId.role(this.eventTrigger.owner));
+        // Function dependency
+        // Note: Event triggers call functions with no arguments, so we can build the stableId
+        const procRef = parseProcedureReference(`${this.eventTrigger.function_schema}.${this.eventTrigger.function_name}()`);
+        if (procRef) {
+            // Event trigger functions have no arguments, so stableId is procedure:schema.name()
+            dependencies.add(stableId.procedure(procRef.schema, procRef.name));
+        }
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = [
+            "CREATE EVENT TRIGGER",
+            this.eventTrigger.name,
+            "ON",
+            this.eventTrigger.event,
+        ];
+        const tags = this.eventTrigger.tags;
+        if (tags && tags.length > 0) {
+            const tagList = tags.map((tag) => quoteLiteral(tag)).join(", ");
+            parts.push("WHEN TAG IN", `(${tagList})`);
+        }
+        parts.push("EXECUTE FUNCTION", `${this.eventTrigger.function_schema}.${this.eventTrigger.function_name}()`);
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/event-trigger/changes/event-trigger.drop.d.ts

@@ -0,0 +1,22 @@
+import type { EventTrigger } from "../event-trigger.model.ts";
+import { DropEventTriggerChange } from "./event-trigger.base.ts";
+/**
+ * Drop an event trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropeventtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP EVENT TRIGGER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropEventTrigger extends DropEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly scope: "object";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+    });
+    get drops(): `eventTrigger:${string}`[];
+    get requires(): `eventTrigger:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/event-trigger/changes/event-trigger.drop.js

@@ -0,0 +1,28 @@
+import { DropEventTriggerChange } from "./event-trigger.base.js";
+/**
+ * Drop an event trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropeventtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP EVENT TRIGGER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropEventTrigger extends DropEventTriggerChange {
+    eventTrigger;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.eventTrigger = props.eventTrigger;
+    }
+    get drops() {
+        return [this.eventTrigger.stableId];
+    }
+    get requires() {
+        return [this.eventTrigger.stableId];
+    }
+    serialize() {
+        return ["DROP EVENT TRIGGER", this.eventTrigger.name].join(" ");
+    }
+}

package/dist/core/objects/event-trigger/changes/event-trigger.types.d.ts

@@ -0,0 +1,5 @@
+import type { AlterEventTrigger } from "./event-trigger.alter.ts";
+import type { CommentEventTrigger } from "./event-trigger.comment.ts";
+import type { CreateEventTrigger } from "./event-trigger.create.ts";
+import type { DropEventTrigger } from "./event-trigger.drop.ts";
+export type EventTriggerChange = AlterEventTrigger | CommentEventTrigger | CreateEventTrigger | DropEventTrigger;

package/dist/core/objects/event-trigger/changes/event-trigger.types.js

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

package/dist/core/objects/event-trigger/event-trigger.diff.d.ts

@@ -0,0 +1,13 @@
+import type { EventTriggerChange } from "./changes/event-trigger.types.ts";
+import type { EventTrigger } from "./event-trigger.model.ts";
+/**
+ * Diff two sets of event triggers from main and branch catalogs.
+ *
+ * @param ctx - Context containing currentUser
+ * @param main - The event triggers in the main catalog.
+ * @param branch - The event triggers in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffEventTriggers(ctx: {
+    currentUser: string;
+}, main: Record<string, EventTrigger>, branch: Record<string, EventTrigger>): EventTriggerChange[];

package/dist/core/objects/event-trigger/event-trigger.diff.js

@@ -0,0 +1,81 @@
+import { diffObjects } from "../base.diff.js";
+import { deepEqual, hasNonAlterableChanges } from "../utils.js";
+import { AlterEventTriggerChangeOwner, AlterEventTriggerSetEnabled, } from "./changes/event-trigger.alter.js";
+import { CreateCommentOnEventTrigger, DropCommentOnEventTrigger, } from "./changes/event-trigger.comment.js";
+import { CreateEventTrigger } from "./changes/event-trigger.create.js";
+import { DropEventTrigger } from "./changes/event-trigger.drop.js";
+/**
+ * Diff two sets of event triggers from main and branch catalogs.
+ *
+ * @param ctx - Context containing currentUser
+ * @param main - The event triggers in the main catalog.
+ * @param branch - The event triggers in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffEventTriggers(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const eventTriggerId of created) {
+        const eventTrigger = branch[eventTriggerId];
+        changes.push(new CreateEventTrigger({ eventTrigger }));
+        // OWNER: If the event trigger should be owned by someone other than the current user,
+        // emit ALTER EVENT TRIGGER ... OWNER TO after creation
+        if (eventTrigger.owner !== ctx.currentUser) {
+            changes.push(new AlterEventTriggerChangeOwner({
+                eventTrigger,
+                owner: eventTrigger.owner,
+            }));
+        }
+        if (eventTrigger.comment !== null) {
+            changes.push(new CreateCommentOnEventTrigger({ eventTrigger }));
+        }
+    }
+    for (const eventTriggerId of dropped) {
+        changes.push(new DropEventTrigger({ eventTrigger: main[eventTriggerId] }));
+    }
+    for (const eventTriggerId of altered) {
+        const mainEventTrigger = main[eventTriggerId];
+        const branchEventTrigger = branch[eventTriggerId];
+        const NON_ALTERABLE_FIELDS = [
+            "event",
+            "function_schema",
+            "function_name",
+            "tags",
+        ];
+        const shouldReplace = hasNonAlterableChanges(mainEventTrigger, branchEventTrigger, NON_ALTERABLE_FIELDS, { tags: deepEqual });
+        if (shouldReplace) {
+            changes.push(new DropEventTrigger({ eventTrigger: mainEventTrigger }), new CreateEventTrigger({ eventTrigger: branchEventTrigger }));
+            if (branchEventTrigger.comment !== null) {
+                changes.push(new CreateCommentOnEventTrigger({
+                    eventTrigger: branchEventTrigger,
+                }));
+            }
+            continue;
+        }
+        if (mainEventTrigger.enabled !== branchEventTrigger.enabled) {
+            changes.push(new AlterEventTriggerSetEnabled({
+                eventTrigger: mainEventTrigger,
+                enabled: branchEventTrigger.enabled,
+            }));
+        }
+        if (mainEventTrigger.owner !== branchEventTrigger.owner) {
+            changes.push(new AlterEventTriggerChangeOwner({
+                eventTrigger: mainEventTrigger,
+                owner: branchEventTrigger.owner,
+            }));
+        }
+        if (mainEventTrigger.comment !== branchEventTrigger.comment) {
+            if (branchEventTrigger.comment === null) {
+                changes.push(new DropCommentOnEventTrigger({
+                    eventTrigger: mainEventTrigger,
+                }));
+            }
+            else {
+                changes.push(new CreateCommentOnEventTrigger({
+                    eventTrigger: branchEventTrigger,
+                }));
+            }
+        }
+    }
+    return changes;
+}

package/dist/core/objects/event-trigger/event-trigger.model.d.ts

@@ -0,0 +1,45 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+declare const eventTriggerPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    event: z.ZodString;
+    function_schema: z.ZodString;
+    function_name: z.ZodString;
+    enabled: z.ZodEnum<{
+        O: "O";
+        D: "D";
+        R: "R";
+        A: "A";
+    }>;
+    tags: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.z.core.$strip>;
+export type EventTriggerProps = z.infer<typeof eventTriggerPropsSchema>;
+export declare class EventTrigger extends BasePgModel {
+    readonly name: EventTriggerProps["name"];
+    readonly event: EventTriggerProps["event"];
+    readonly function_schema: EventTriggerProps["function_schema"];
+    readonly function_name: EventTriggerProps["function_name"];
+    readonly enabled: EventTriggerProps["enabled"];
+    readonly tags: EventTriggerProps["tags"];
+    readonly owner: EventTriggerProps["owner"];
+    readonly comment: EventTriggerProps["comment"];
+    constructor(props: EventTriggerProps);
+    get stableId(): `eventTrigger:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        event: string;
+        function_schema: string;
+        function_name: string;
+        enabled: "O" | "D" | "R" | "A";
+        tags: string[] | null;
+        owner: string;
+        comment: string | null;
+    };
+}
+export declare function extractEventTriggers(sql: Sql): Promise<EventTrigger[]>;
+export {};

package/dist/core/objects/event-trigger/event-trigger.model.js

@@ -0,0 +1,89 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+const EventTriggerEnabledSchema = z.enum([
+    "O", // ORIGIN - trigger fires in origin mode
+    "D", // DISABLED - trigger does not fire
+    "R", // REPLICA - trigger fires only in replica session
+    "A", // ALWAYS - trigger fires regardless of replication mode
+]);
+const eventTriggerPropsSchema = z.object({
+    name: z.string(),
+    event: z.string(),
+    function_schema: z.string(),
+    function_name: z.string(),
+    enabled: EventTriggerEnabledSchema,
+    tags: z.array(z.string()).nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+});
+export class EventTrigger extends BasePgModel {
+    name;
+    event;
+    function_schema;
+    function_name;
+    enabled;
+    tags;
+    owner;
+    comment;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.name = props.name;
+        // Data fields
+        this.event = props.event;
+        this.function_schema = props.function_schema;
+        this.function_name = props.function_name;
+        this.enabled = props.enabled;
+        this.tags = props.tags;
+        this.owner = props.owner;
+        this.comment = props.comment;
+    }
+    get stableId() {
+        return `eventTrigger:${this.name}`;
+    }
+    get identityFields() {
+        return {
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            event: this.event,
+            function_schema: this.function_schema,
+            function_name: this.function_name,
+            enabled: this.enabled,
+            tags: this.tags,
+            owner: this.owner,
+            comment: this.comment,
+        };
+    }
+}
+export async function extractEventTriggers(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const rows = await sql `
+with extension_oids as (
+  select objid
+  from pg_depend d
+  where d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_event_trigger'::regclass
+)
+select
+  quote_ident(et.evtname) as name,
+  et.evtevent as event,
+  p.pronamespace::regnamespace::text as function_schema,
+  quote_ident(p.proname) as function_name,
+  et.evtenabled as enabled,
+  et.evttags as tags,
+  et.evtowner::regrole::text as owner,
+  obj_description(et.oid, 'pg_event_trigger') as comment
+from pg_catalog.pg_event_trigger et
+join pg_catalog.pg_proc p on p.oid = et.evtfoid
+left join extension_oids e on e.objid = et.oid
+where e.objid is null
+order by 1;
+    `;
+        const validatedRows = rows.map((row) => eventTriggerPropsSchema.parse(row));
+        return validatedRows.map((row) => new EventTrigger(row));
+    });
+}

package/dist/core/objects/extension/changes/extension.alter.d.ts

@@ -0,0 +1,44 @@
+import type { Extension } from "../extension.model.ts";
+import { AlterExtensionChange } from "./extension.base.ts";
+/**
+ * Alter an extension.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterextension.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER EXTENSION name UPDATE [ TO new_version ]
+ * ALTER EXTENSION name SET SCHEMA new_schema
+ * ALTER EXTENSION name ADD member_object
+ * ALTER EXTENSION name DROP member_object
+ * ```
+ */
+export type AlterExtension = AlterExtensionSetSchema | AlterExtensionUpdateVersion;
+/**
+ * ALTER EXTENSION ... UPDATE TO ...
+ */
+export declare class AlterExtensionUpdateVersion extends AlterExtensionChange {
+    readonly extension: Extension;
+    readonly version: string;
+    readonly scope: "object";
+    constructor(props: {
+        extension: Extension;
+        version: string;
+    });
+    get requires(): `extension:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER EXTENSION ... SET SCHEMA ...
+ */
+export declare class AlterExtensionSetSchema extends AlterExtensionChange {
+    readonly extension: Extension;
+    readonly schema: string;
+    readonly scope: "object";
+    constructor(props: {
+        extension: Extension;
+        schema: string;
+    });
+    get requires(): (`schema:${string}` | `extension:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/extension/changes/extension.alter.js

@@ -0,0 +1,51 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { AlterExtensionChange } from "./extension.base.js";
+/**
+ * ALTER EXTENSION ... UPDATE TO ...
+ */
+export class AlterExtensionUpdateVersion extends AlterExtensionChange {
+    extension;
+    version;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.extension = props.extension;
+        this.version = props.version;
+    }
+    get requires() {
+        return [this.extension.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER EXTENSION",
+            this.extension.name,
+            "UPDATE TO",
+            quoteLiteral(this.version),
+        ].join(" ");
+    }
+}
+/**
+ * ALTER EXTENSION ... SET SCHEMA ...
+ */
+export class AlterExtensionSetSchema extends AlterExtensionChange {
+    extension;
+    schema;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.extension = props.extension;
+        this.schema = props.schema;
+    }
+    get requires() {
+        return [this.extension.stableId, stableId.schema(this.schema)];
+    }
+    serialize() {
+        return [
+            "ALTER EXTENSION",
+            this.extension.name,
+            "SET SCHEMA",
+            this.schema,
+        ].join(" ");
+    }
+}

package/dist/core/objects/extension/changes/extension.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Extension } from "../extension.model.ts";
+declare abstract class BaseExtensionChange extends BaseChange {
+    abstract readonly extension: Extension;
+    abstract readonly scope: "object" | "comment";
+    readonly objectType: "extension";
+}
+export declare abstract class CreateExtensionChange extends BaseExtensionChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterExtensionChange extends BaseExtensionChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropExtensionChange extends BaseExtensionChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/extension/changes/extension.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseExtensionChange extends BaseChange {
+    objectType = "extension";
+}
+export class CreateExtensionChange extends BaseExtensionChange {
+    operation = "create";
+}
+export class AlterExtensionChange extends BaseExtensionChange {
+    operation = "alter";
+}
+export class DropExtensionChange extends BaseExtensionChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,26 @@
+import type { Extension } from "../extension.model.ts";
+import { CreateExtensionChange, DropExtensionChange } from "./extension.base.ts";
+export type CommentExtension = CreateCommentOnExtension | DropCommentOnExtension;
+/**
+ * Create/drop comments on extensions.
+ */
+export declare class CreateCommentOnExtension extends CreateExtensionChange {
+    readonly extension: Extension;
+    readonly scope: "comment";
+    constructor(props: {
+        extension: Extension;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `extension:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnExtension extends DropExtensionChange {
+    readonly extension: Extension;
+    readonly scope: "comment";
+    constructor(props: {
+        extension: Extension;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `extension:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,46 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateExtensionChange, DropExtensionChange, } from "./extension.base.js";
+/**
+ * Create/drop comments on extensions.
+ */
+export class CreateCommentOnExtension extends CreateExtensionChange {
+    extension;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.extension = props.extension;
+    }
+    get creates() {
+        return [stableId.comment(this.extension.stableId)];
+    }
+    get requires() {
+        return [this.extension.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON EXTENSION",
+            this.extension.name,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: extension comment is not nullable here
+            quoteLiteral(this.extension.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnExtension extends DropExtensionChange {
+    extension;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.extension = props.extension;
+    }
+    get drops() {
+        return [stableId.comment(this.extension.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.extension.stableId), this.extension.stableId];
+    }
+    serialize() {
+        return ["COMMENT ON EXTENSION", this.extension.name, "IS NULL"].join(" ");
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { Extension } from "../extension.model.ts";
+import { CreateExtensionChange } from "./extension.base.ts";
+/**
+ * Create an extension.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createextension.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE EXTENSION [ IF NOT EXISTS ] extension_name
+ *     [ WITH ] [ SCHEMA schema_name ]
+ *              [ VERSION version ]
+ *              [ CASCADE ]
+ * ```
+ */
+export declare class CreateExtension extends CreateExtensionChange {
+    readonly extension: Extension;
+    readonly scope: "object";
+    constructor(props: {
+        extension: Extension;
+    });
+    get creates(): string[];
+    get requires(): string[];
+    serialize(): string;
+}