@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

package/src/core/objects/event-trigger/changes/event-trigger.comment.ts

@@ -0,0 +1,67 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { EventTrigger } from "../event-trigger.model.ts";
+import {
+  CreateEventTriggerChange,
+  DropEventTriggerChange,
+} from "./event-trigger.base.ts";
+
+export type CommentEventTrigger =
+  | CreateCommentOnEventTrigger
+  | DropCommentOnEventTrigger;
+
+export class CreateCommentOnEventTrigger extends CreateEventTriggerChange {
+  public readonly eventTrigger: EventTrigger;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { eventTrigger: EventTrigger }) {
+    super();
+    this.eventTrigger = props.eventTrigger;
+  }
+
+  get creates() {
+    return [stableId.comment(this.eventTrigger.stableId)];
+  }
+
+  get requires() {
+    return [this.eventTrigger.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    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 {
+  public readonly eventTrigger: EventTrigger;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { eventTrigger: EventTrigger }) {
+    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(_options?: SerializeOptions): string {
+    return ["COMMENT ON EVENT TRIGGER", this.eventTrigger.name, "IS NULL"].join(
+      " ",
+    );
+  }
+}

package/src/core/objects/event-trigger/changes/event-trigger.create.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { EventTrigger } from "../event-trigger.model.ts";
+import { CreateEventTrigger } from "./event-trigger.create.ts";
+
+describe("event trigger create change", () => {
+  test("serialize create event trigger", async () => {
+    const eventTrigger = new EventTrigger({
+      name: "ddl_logger",
+      event: "ddl_command_start",
+      function_schema: "public",
+      function_name: "log_ddl",
+      enabled: "O",
+      tags: ["CREATE TABLE", "ALTER TABLE"],
+      owner: "postgres",
+      comment: null,
+    });
+
+    const change = new CreateEventTrigger({ eventTrigger });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE EVENT TRIGGER ddl_logger ON ddl_command_start WHEN TAG IN ('CREATE TABLE', 'ALTER TABLE') EXECUTE FUNCTION public.log_ddl()",
+    );
+  });
+});

package/src/core/objects/event-trigger/changes/event-trigger.create.ts

@@ -0,0 +1,73 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { parseProcedureReference, stableId } from "../../utils.ts";
+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 class CreateEventTrigger extends CreateEventTriggerChange {
+  public readonly eventTrigger: EventTrigger;
+  public readonly scope = "object" as const;
+
+  constructor(props: { eventTrigger: EventTrigger }) {
+    super();
+    this.eventTrigger = props.eventTrigger;
+  }
+
+  get creates() {
+    return [this.eventTrigger.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // 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(_options?: SerializeOptions): string {
+    const parts: string[] = [
+      "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/src/core/objects/event-trigger/changes/event-trigger.drop.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { EventTrigger } from "../event-trigger.model.ts";
+import { DropEventTrigger } from "./event-trigger.drop.ts";
+
+describe("event trigger drop change", () => {
+  test("serialize drop event trigger", async () => {
+    const eventTrigger = new EventTrigger({
+      name: "ddl_logger",
+      event: "ddl_command_start",
+      function_schema: "public",
+      function_name: "log_ddl",
+      enabled: "O",
+      tags: null,
+      owner: "postgres",
+      comment: null,
+    });
+
+    const change = new DropEventTrigger({ eventTrigger });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP EVENT TRIGGER ddl_logger");
+  });
+});

package/src/core/objects/event-trigger/changes/event-trigger.drop.ts

@@ -0,0 +1,35 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+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 class DropEventTrigger extends DropEventTriggerChange {
+  public readonly eventTrigger: EventTrigger;
+  public readonly scope = "object" as const;
+
+  constructor(props: { eventTrigger: EventTrigger }) {
+    super();
+    this.eventTrigger = props.eventTrigger;
+  }
+
+  get drops() {
+    return [this.eventTrigger.stableId];
+  }
+
+  get requires() {
+    return [this.eventTrigger.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return ["DROP EVENT TRIGGER", this.eventTrigger.name].join(" ");
+  }
+}

package/src/core/objects/event-trigger/changes/event-trigger.types.ts

@@ -0,0 +1,11 @@
+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";
+
+/** Union of all event-trigger-related change variants (`objectType: "event_trigger"`). @category Change Types */
+export type EventTriggerChange =
+  | AlterEventTrigger
+  | CommentEventTrigger
+  | CreateEventTrigger
+  | DropEventTrigger;

package/src/core/objects/event-trigger/event-trigger.diff.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import {
+  AlterEventTriggerChangeOwner,
+  AlterEventTriggerSetEnabled,
+} from "./changes/event-trigger.alter.ts";
+import {
+  CreateCommentOnEventTrigger,
+  DropCommentOnEventTrigger,
+} from "./changes/event-trigger.comment.ts";
+import { CreateEventTrigger } from "./changes/event-trigger.create.ts";
+import { DropEventTrigger } from "./changes/event-trigger.drop.ts";
+import { diffEventTriggers } from "./event-trigger.diff.ts";
+import { EventTrigger, type EventTriggerProps } from "./event-trigger.model.ts";
+
+const ctx: Pick<ObjectDiffContext, "currentUser"> = {
+  currentUser: "postgres",
+};
+
+const base: EventTriggerProps = {
+  name: "ddl_logger",
+  event: "ddl_command_start",
+  function_schema: "public",
+  function_name: "log_ddl",
+  enabled: "O",
+  tags: ["CREATE TABLE"],
+  owner: "postgres",
+  comment: null,
+};
+
+describe.concurrent("event-trigger.diff", () => {
+  test("create and drop event trigger", () => {
+    const eventTrigger = new EventTrigger(base);
+
+    const created = diffEventTriggers(
+      ctx,
+      {},
+      { [eventTrigger.stableId]: eventTrigger },
+    );
+    expect(created).toHaveLength(1);
+    expect(created[0]).toBeInstanceOf(CreateEventTrigger);
+
+    const dropped = diffEventTriggers(
+      ctx,
+      { [eventTrigger.stableId]: eventTrigger },
+      {},
+    );
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0]).toBeInstanceOf(DropEventTrigger);
+  });
+
+  test("replace when non-alterable fields change", () => {
+    const mainEventTrigger = new EventTrigger(base);
+    const branchEventTrigger = new EventTrigger({
+      ...base,
+      function_name: "log_ddl_v2",
+    });
+
+    const changes = diffEventTriggers(
+      ctx,
+      { [mainEventTrigger.stableId]: mainEventTrigger },
+      { [branchEventTrigger.stableId]: branchEventTrigger },
+    );
+
+    expect(changes).toHaveLength(2);
+    expect(changes[0]).toBeInstanceOf(DropEventTrigger);
+    expect(changes[1]).toBeInstanceOf(CreateEventTrigger);
+  });
+
+  test("alter enabled state", () => {
+    const mainEventTrigger = new EventTrigger(base);
+    const branchEventTrigger = new EventTrigger({
+      ...base,
+      enabled: "D",
+    });
+
+    const changes = diffEventTriggers(
+      ctx,
+      { [mainEventTrigger.stableId]: mainEventTrigger },
+      { [branchEventTrigger.stableId]: branchEventTrigger },
+    );
+
+    expect(changes).toHaveLength(1);
+    expect(changes[0]).toBeInstanceOf(AlterEventTriggerSetEnabled);
+  });
+
+  test("alter owner", () => {
+    const mainEventTrigger = new EventTrigger(base);
+    const branchEventTrigger = new EventTrigger({
+      ...base,
+      owner: "new_owner",
+    });
+
+    const changes = diffEventTriggers(
+      ctx,
+      { [mainEventTrigger.stableId]: mainEventTrigger },
+      { [branchEventTrigger.stableId]: branchEventTrigger },
+    );
+
+    expect(changes).toHaveLength(1);
+    expect(changes[0]).toBeInstanceOf(AlterEventTriggerChangeOwner);
+  });
+
+  test("comment changes", () => {
+    const mainEventTrigger = new EventTrigger(base);
+    const branchWithComment = new EventTrigger({
+      ...base,
+      comment: "logs ddl commands",
+    });
+    const branchWithoutComment = new EventTrigger({
+      ...base,
+      comment: null,
+    });
+
+    const createCommentChanges = diffEventTriggers(
+      ctx,
+      { [mainEventTrigger.stableId]: mainEventTrigger },
+      { [branchWithComment.stableId]: branchWithComment },
+    );
+    expect(createCommentChanges).toHaveLength(1);
+    expect(createCommentChanges[0]).toBeInstanceOf(CreateCommentOnEventTrigger);
+
+    const dropCommentChanges = diffEventTriggers(
+      ctx,
+      { [branchWithComment.stableId]: branchWithComment },
+      { [branchWithoutComment.stableId]: branchWithoutComment },
+    );
+    expect(dropCommentChanges).toHaveLength(1);
+    expect(dropCommentChanges[0]).toBeInstanceOf(DropCommentOnEventTrigger);
+  });
+});

package/src/core/objects/event-trigger/event-trigger.diff.ts

@@ -0,0 +1,127 @@
+import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterEventTriggerChangeOwner,
+  AlterEventTriggerSetEnabled,
+} from "./changes/event-trigger.alter.ts";
+import {
+  CreateCommentOnEventTrigger,
+  DropCommentOnEventTrigger,
+} from "./changes/event-trigger.comment.ts";
+import { CreateEventTrigger } from "./changes/event-trigger.create.ts";
+import { DropEventTrigger } from "./changes/event-trigger.drop.ts";
+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 function diffEventTriggers(
+  ctx: Pick<ObjectDiffContext, "currentUser">,
+  main: Record<string, EventTrigger>,
+  branch: Record<string, EventTrigger>,
+): EventTriggerChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: EventTriggerChange[] = [];
+
+  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: Array<keyof EventTrigger> = [
+      "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/src/core/objects/event-trigger/event-trigger.model.ts

@@ -0,0 +1,106 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+
+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 type EventTriggerProps = z.infer<typeof eventTriggerPropsSchema>;
+
+export class EventTrigger extends BasePgModel {
+  public readonly name: EventTriggerProps["name"];
+  public readonly event: EventTriggerProps["event"];
+  public readonly function_schema: EventTriggerProps["function_schema"];
+  public readonly function_name: EventTriggerProps["function_name"];
+  public readonly enabled: EventTriggerProps["enabled"];
+  public readonly tags: EventTriggerProps["tags"];
+  public readonly owner: EventTriggerProps["owner"];
+  public readonly comment: EventTriggerProps["comment"];
+
+  constructor(props: EventTriggerProps) {
+    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(): `eventTrigger:${string}` {
+    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(
+  pool: Pool,
+): Promise<EventTrigger[]> {
+  const { rows } = await pool.query<EventTriggerProps>(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: unknown) =>
+    eventTriggerPropsSchema.parse(row),
+  );
+
+  return validatedRows.map((row: EventTriggerProps) => new EventTrigger(row));
+}

package/src/core/objects/extension/changes/extension.alter.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Extension, type ExtensionProps } from "../extension.model.ts";
+import {
+  AlterExtensionSetSchema,
+  AlterExtensionUpdateVersion,
+} from "./extension.alter.ts";
+
+describe.concurrent("extension", () => {
+  describe("alter", () => {
+    test("update version", async () => {
+      const props: Omit<ExtensionProps, "version"> = {
+        name: "test_extension",
+        schema: "public",
+        relocatable: true,
+        owner: "test",
+        comment: null,
+        members: [],
+      };
+      const extension = new Extension({
+        ...props,
+        version: "1.0",
+      });
+
+      const change = new AlterExtensionUpdateVersion({
+        extension,
+        version: "2.0",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER EXTENSION test_extension UPDATE TO '2.0'",
+      );
+    });
+
+    test("set schema", async () => {
+      const props: Omit<ExtensionProps, "schema"> = {
+        name: "test_extension",
+        relocatable: true,
+        version: "1.0",
+        owner: "test",
+        comment: null,
+        members: [],
+      };
+      const extension = new Extension({
+        ...props,
+        schema: "public",
+      });
+
+      const change = new AlterExtensionSetSchema({
+        extension,
+        schema: "extensions",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER EXTENSION test_extension SET SCHEMA extensions",
+      );
+    });
+  });
+});