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

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

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Trigger } from "../trigger.model.ts";
+import { CreateTrigger } from "./trigger.create.ts";
+
+describe("trigger", () => {
+  test("create", async () => {
+    const trigger = new Trigger({
+      schema: "public",
+      name: "test_trigger",
+      table_name: "test_table",
+      table_relkind: "r",
+      function_schema: "public",
+      function_name: "test_function",
+      trigger_type: (1 << 1) | (1 << 2) | (1 << 0), // BEFORE (1<<1) | INSERT (1<<2) | ROW (1<<0) = 7
+      enabled: "O",
+      is_internal: false,
+      deferrable: false,
+      initially_deferred: false,
+      argument_count: 0,
+      column_numbers: null,
+      arguments: [],
+      when_condition: null,
+      old_table: null,
+      new_table: null,
+      is_partition_clone: false,
+      parent_trigger_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      is_on_partitioned_table: false,
+      owner: "test",
+      definition:
+        "CREATE TRIGGER test_trigger BEFORE INSERT ON public.test_table FOR EACH ROW EXECUTE FUNCTION public.test_function()",
+      comment: null,
+    });
+
+    const change = new CreateTrigger({
+      trigger,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE TRIGGER test_trigger BEFORE INSERT ON public.test_table FOR EACH ROW EXECUTE FUNCTION public.test_function()",
+    );
+  });
+});

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

@@ -0,0 +1,89 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { TableLikeObject } from "../../base.model.ts";
+import { stableId } from "../../utils.ts";
+import type { Trigger } from "../trigger.model.ts";
+import { CreateTriggerChange } from "./trigger.base.ts";
+
+/**
+ * Create a trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] [ CONSTRAINT ] TRIGGER name { BEFORE | AFTER | INSTEAD OF } { event [ OR ... ] }
+ *     ON table_name
+ *     [ FROM referenced_table_name ]
+ *     [ NOT DEFERRABLE | [ DEFERRABLE ] [ INITIALLY IMMEDIATE | INITIALLY DEFERRED ] ]
+ *     [ REFERENCING { { OLD | NEW } TABLE [ AS ] transition_relation_name } [ ... ] ]
+ *     [ FOR [ EACH ] { ROW | STATEMENT } ]
+ *     [ WHEN ( condition ) ]
+ *     EXECUTE { FUNCTION | PROCEDURE } function_name ( arguments )
+ *
+ * where event can be one of:
+ *
+ *     INSERT
+ *     UPDATE [ OF column_name [, ... ] ]
+ *     DELETE
+ *     TRUNCATE
+ * ```
+ */
+export class CreateTrigger extends CreateTriggerChange {
+  public readonly trigger: Trigger;
+  public readonly indexableObject?: TableLikeObject;
+  public readonly orReplace?: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    trigger: Trigger;
+    indexableObject?: TableLikeObject;
+    orReplace?: boolean;
+  }) {
+    super();
+    this.trigger = props.trigger;
+    this.indexableObject = props.indexableObject;
+    this.orReplace = props.orReplace;
+  }
+
+  get creates() {
+    return [this.trigger.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.trigger.schema));
+
+    // Table dependency
+    dependencies.add(
+      stableId.table(this.trigger.schema, this.trigger.table_name),
+    );
+
+    // Function dependency
+    // Trigger functions always have signature () RETURNS trigger, so no arguments.
+    dependencies.add(
+      stableId.procedure(
+        this.trigger.function_schema,
+        this.trigger.function_name,
+      ),
+    );
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.trigger.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    let definition = this.trigger.definition.trim();
+    const isConstraintTrigger = this.trigger.isConstraintTrigger;
+
+    definition = definition.replace(
+      /^CREATE\s+(?:OR\s+REPLACE\s+)?/i,
+      `CREATE ${this.orReplace && !isConstraintTrigger ? "OR REPLACE " : ""}`,
+    );
+
+    return definition;
+  }
+}

package/src/core/objects/trigger/changes/trigger.drop.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Trigger } from "../trigger.model.ts";
+import { DropTrigger } from "./trigger.drop.ts";
+
+describe("trigger", () => {
+  test("drop", async () => {
+    const trigger = new Trigger({
+      schema: "public",
+      name: "test_trigger",
+      table_name: "test_table",
+      table_relkind: "r",
+      function_schema: "public",
+      function_name: "test_function",
+      trigger_type: 66,
+      enabled: "O",
+      is_internal: false,
+      deferrable: false,
+      initially_deferred: false,
+      argument_count: 0,
+      column_numbers: null,
+      arguments: [],
+      when_condition: null,
+      old_table: null,
+      new_table: null,
+      is_partition_clone: false,
+      parent_trigger_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      is_on_partitioned_table: false,
+      owner: "test",
+      definition:
+        "CREATE TRIGGER test_trigger BEFORE UPDATE ON public.test_table FOR EACH ROW EXECUTE FUNCTION public.test_function()",
+      comment: null,
+    });
+
+    const change = new DropTrigger({
+      trigger,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "DROP TRIGGER test_trigger ON public.test_table",
+    );
+  });
+});

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

@@ -0,0 +1,40 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { Trigger } from "../trigger.model.ts";
+import { DropTriggerChange } from "./trigger.base.ts";
+
+/**
+ * Drop a trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropTrigger extends DropTriggerChange {
+  public readonly trigger: Trigger;
+  public readonly scope = "object" as const;
+
+  constructor(props: { trigger: Trigger }) {
+    super();
+    this.trigger = props.trigger;
+  }
+
+  get drops() {
+    return [this.trigger.stableId];
+  }
+
+  get requires() {
+    return [this.trigger.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "DROP TRIGGER",
+      this.trigger.name,
+      "ON",
+      `${this.trigger.schema}.${this.trigger.table_name}`,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,11 @@
+import type { AlterTrigger } from "./trigger.alter.ts";
+import type { CommentTrigger } from "./trigger.comment.ts";
+import type { CreateTrigger } from "./trigger.create.ts";
+import type { DropTrigger } from "./trigger.drop.ts";
+
+/** Union of all trigger-related change variants (`objectType: "trigger"`). @category Change Types */
+export type TriggerChange =
+  | AlterTrigger
+  | CommentTrigger
+  | CreateTrigger
+  | DropTrigger;

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

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test";
+import { ReplaceTrigger } from "./changes/trigger.alter.ts";
+import { CreateTrigger } from "./changes/trigger.create.ts";
+import { DropTrigger } from "./changes/trigger.drop.ts";
+import { diffTriggers } from "./trigger.diff.ts";
+import { Trigger, type TriggerProps } from "./trigger.model.ts";
+
+const base: Omit<
+  TriggerProps,
+  | "function_name"
+  | "column_numbers"
+  | "arguments"
+  | "when_condition"
+  | "old_table"
+  | "new_table"
+> = {
+  schema: "public",
+  name: "trg",
+  table_name: "t",
+  table_relkind: "r",
+  function_schema: "public",
+  trigger_type: 1,
+  enabled: "O",
+  is_internal: false,
+  deferrable: false,
+  initially_deferred: false,
+  argument_count: 0,
+  is_partition_clone: false,
+  parent_trigger_name: null,
+  parent_table_schema: null,
+  parent_table_name: null,
+  is_on_partitioned_table: false,
+  owner: "o1",
+  definition: "CREATE TRIGGER trg ON t FOR EACH ROW EXECUTE FUNCTION fn1()",
+  comment: null,
+};
+
+describe.concurrent("trigger.diff", () => {
+  test("create and drop", () => {
+    const trg = new Trigger({
+      ...base,
+      function_name: "fn1",
+      column_numbers: null,
+      arguments: [],
+      when_condition: null,
+      old_table: null,
+      new_table: null,
+    });
+
+    const created = diffTriggers({}, { [trg.stableId]: trg });
+    expect(created[0]).toBeInstanceOf(CreateTrigger);
+
+    const dropped = diffTriggers({ [trg.stableId]: trg }, {});
+    expect(dropped[0]).toBeInstanceOf(DropTrigger);
+  });
+
+  test("replace when non-alterable changes", () => {
+    const main = new Trigger({
+      ...base,
+      function_name: "fn1",
+      column_numbers: null,
+      arguments: [],
+      when_condition: null,
+      old_table: null,
+      new_table: null,
+    });
+    const branch = new Trigger({
+      ...base,
+      function_name: "fn2",
+      column_numbers: null,
+      arguments: [],
+      when_condition: null,
+      old_table: null,
+      new_table: null,
+    });
+
+    const changes = diffTriggers(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(1);
+    expect(changes[0]).toBeInstanceOf(ReplaceTrigger);
+  });
+});

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

@@ -0,0 +1,121 @@
+import { diffObjects } from "../base.diff.ts";
+import type { TableLikeObject } from "../base.model.ts";
+import { deepEqual, hasNonAlterableChanges, stableId } from "../utils.ts";
+import { ReplaceTrigger } from "./changes/trigger.alter.ts";
+import {
+  CreateCommentOnTrigger,
+  DropCommentOnTrigger,
+} from "./changes/trigger.comment.ts";
+import { CreateTrigger } from "./changes/trigger.create.ts";
+import { DropTrigger } from "./changes/trigger.drop.ts";
+import type { TriggerChange } from "./changes/trigger.types.ts";
+import type { Trigger } from "./trigger.model.ts";
+
+/**
+ * Diff two sets of triggers from main and branch catalogs.
+ *
+ * @param main - The triggers in the main catalog.
+ * @param branch - The triggers in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffTriggers(
+  main: Record<string, Trigger>,
+  branch: Record<string, Trigger>,
+  branchIndexableObjects?: Record<string, TableLikeObject>,
+): TriggerChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: TriggerChange[] = [];
+
+  for (const triggerId of created) {
+    const trigger = branch[triggerId];
+
+    // Skip trigger clones on partitions - they are automatically created when the parent trigger is created
+    if (trigger.is_partition_clone) {
+      continue;
+    }
+
+    const tableStableId = stableId.table(trigger.schema, trigger.table_name);
+    changes.push(
+      new CreateTrigger({
+        trigger: trigger,
+        indexableObject: branchIndexableObjects?.[tableStableId],
+      }),
+    );
+    if (trigger.comment !== null) {
+      changes.push(new CreateCommentOnTrigger({ trigger: trigger }));
+    }
+  }
+
+  for (const triggerId of dropped) {
+    const trigger = main[triggerId];
+
+    // Skip trigger clones on partitions - they are automatically dropped when the parent trigger is dropped
+    if (trigger.is_partition_clone) {
+      continue;
+    }
+
+    changes.push(new DropTrigger({ trigger }));
+  }
+
+  for (const triggerId of altered) {
+    const mainTrigger = main[triggerId];
+    const branchTrigger = branch[triggerId];
+
+    // Skip trigger clones on partitions - they are automatically updated when the parent trigger is updated
+    if (mainTrigger.is_partition_clone || branchTrigger.is_partition_clone) {
+      continue;
+    }
+
+    // Note: column_numbers is excluded because it contains pg_trigger.tgattr
+    // attnums that differ between databases when physical column layouts
+    // diverge but logical (named) columns match. The definition field
+    // (pg_get_triggerdef) already captures the UPDATE OF column list by name,
+    // so we compare by definition instead.
+    const NON_ALTERABLE_FIELDS: Array<keyof Trigger> = [
+      "function_schema",
+      "function_name",
+      "trigger_type",
+      "enabled",
+      "is_internal",
+      "deferrable",
+      "initially_deferred",
+      "argument_count",
+      "arguments",
+      "when_condition",
+      "old_table",
+      "new_table",
+      "owner",
+      "definition", // Compare by definition instead of column_numbers (tgattr)
+    ];
+    const shouldReplace = hasNonAlterableChanges(
+      mainTrigger,
+      branchTrigger,
+      NON_ALTERABLE_FIELDS,
+      { arguments: deepEqual },
+    );
+    if (shouldReplace) {
+      const tableStableId = stableId.table(
+        branchTrigger.schema,
+        branchTrigger.table_name,
+      );
+      changes.push(
+        new ReplaceTrigger({
+          trigger: branchTrigger,
+          indexableObject: branchIndexableObjects?.[tableStableId],
+        }),
+      );
+    } else {
+      // COMMENT
+      if (mainTrigger.comment !== branchTrigger.comment) {
+        if (branchTrigger.comment === null) {
+          changes.push(new DropCommentOnTrigger({ trigger: mainTrigger }));
+        } else {
+          changes.push(new CreateCommentOnTrigger({ trigger: branchTrigger }));
+        }
+      }
+    }
+  }
+
+  return changes;
+}