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

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,88 @@
+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(): 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,39 @@
+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(): 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,10 @@
+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";
+
+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,116 @@
+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;
+    }
+
+    const NON_ALTERABLE_FIELDS: Array<keyof Trigger> = [
+      "function_schema",
+      "function_name",
+      "trigger_type",
+      "enabled",
+      "is_internal",
+      "deferrable",
+      "initially_deferred",
+      "argument_count",
+      "column_numbers",
+      "arguments",
+      "when_condition",
+      "old_table",
+      "new_table",
+      "owner",
+    ];
+    const shouldReplace = hasNonAlterableChanges(
+      mainTrigger,
+      branchTrigger,
+      NON_ALTERABLE_FIELDS,
+      { column_numbers: deepEqual, 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;
+}

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

@@ -0,0 +1,264 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+
+const TriggerEnabledSchema = z.enum([
+  "O", // ORIGIN - trigger fires in "origin" and "local" replica modes
+  "D", // DISABLED - trigger is disabled
+  "R", // REPLICA - trigger fires only in "replica" mode
+  "A", // ALWAYS - trigger fires regardless of replication mode
+]);
+
+const TriggerTableRelkindSchema = z.enum([
+  "r", // ordinary table
+  "p", // partitioned table
+  "f", // foreign table
+  "v", // view
+  "m", // materialized view
+]);
+
+const triggerPropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  table_name: z.string(),
+  table_relkind: TriggerTableRelkindSchema,
+  function_schema: z.string(),
+  function_name: z.string(),
+  trigger_type: z.number(),
+  enabled: TriggerEnabledSchema,
+  is_internal: z.boolean(),
+  deferrable: z.boolean(),
+  initially_deferred: z.boolean(),
+  argument_count: z.number(),
+  column_numbers: z.array(z.number()).nullable(),
+  arguments: z.array(z.string()),
+  when_condition: z.string().nullable(),
+  old_table: z.string().nullable(),
+  new_table: z.string().nullable(),
+  is_partition_clone: z.boolean(),
+  parent_trigger_name: z.string().nullable(),
+  parent_table_schema: z.string().nullable(),
+  parent_table_name: z.string().nullable(),
+  is_on_partitioned_table: z.boolean(),
+  owner: z.string(),
+  definition: z.string(),
+  comment: z.string().nullable(),
+});
+
+export type TriggerProps = z.infer<typeof triggerPropsSchema>;
+
+export class Trigger extends BasePgModel {
+  public readonly schema: TriggerProps["schema"];
+  public readonly name: TriggerProps["name"];
+  public readonly table_name: TriggerProps["table_name"];
+  public readonly table_relkind: TriggerProps["table_relkind"];
+  public readonly function_schema: TriggerProps["function_schema"];
+  public readonly function_name: TriggerProps["function_name"];
+  public readonly trigger_type: TriggerProps["trigger_type"];
+  public readonly enabled: TriggerProps["enabled"];
+  public readonly is_internal: TriggerProps["is_internal"];
+  public readonly deferrable: TriggerProps["deferrable"];
+  public readonly initially_deferred: TriggerProps["initially_deferred"];
+  public readonly argument_count: TriggerProps["argument_count"];
+  public readonly column_numbers: TriggerProps["column_numbers"];
+  public readonly arguments: TriggerProps["arguments"];
+  public readonly when_condition: TriggerProps["when_condition"];
+  public readonly old_table: TriggerProps["old_table"];
+  public readonly new_table: TriggerProps["new_table"];
+  public readonly is_partition_clone: TriggerProps["is_partition_clone"];
+  public readonly parent_trigger_name: TriggerProps["parent_trigger_name"];
+  public readonly parent_table_schema: TriggerProps["parent_table_schema"];
+  public readonly parent_table_name: TriggerProps["parent_table_name"];
+  public readonly is_on_partitioned_table: TriggerProps["is_on_partitioned_table"];
+  public readonly owner: TriggerProps["owner"];
+  public readonly definition: TriggerProps["definition"];
+  public readonly comment: TriggerProps["comment"];
+
+  constructor(props: TriggerProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+    this.table_name = props.table_name;
+    this.table_relkind = props.table_relkind;
+
+    // Data fields
+    this.function_schema = props.function_schema;
+    this.function_name = props.function_name;
+    this.trigger_type = props.trigger_type;
+    this.enabled = props.enabled;
+    this.is_internal = props.is_internal;
+    this.deferrable = props.deferrable;
+    this.initially_deferred = props.initially_deferred;
+    this.argument_count = props.argument_count;
+    this.column_numbers = props.column_numbers;
+    this.arguments = props.arguments;
+    this.when_condition = props.when_condition;
+    this.old_table = props.old_table;
+    this.new_table = props.new_table;
+    this.is_partition_clone = props.is_partition_clone;
+    this.parent_trigger_name = props.parent_trigger_name;
+    this.parent_table_schema = props.parent_table_schema;
+    this.parent_table_name = props.parent_table_name;
+    this.is_on_partitioned_table = props.is_on_partitioned_table;
+    this.owner = props.owner;
+    this.definition = props.definition;
+    this.comment = props.comment;
+  }
+
+  get isConstraintTrigger(): boolean {
+    return /^CREATE\s+CONSTRAINT\s+TRIGGER/i.test(this.definition.trim());
+  }
+
+  get stableId(): `trigger:${string}` {
+    return `trigger:${this.schema}.${this.table_name}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+      table_name: this.table_name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      function_schema: this.function_schema,
+      function_name: this.function_name,
+      trigger_type: this.trigger_type,
+      enabled: this.enabled,
+      is_internal: this.is_internal,
+      deferrable: this.deferrable,
+      initially_deferred: this.initially_deferred,
+      argument_count: this.argument_count,
+      column_numbers: this.column_numbers,
+      arguments: this.arguments,
+      when_condition: this.when_condition,
+      old_table: this.old_table,
+      new_table: this.new_table,
+      is_partition_clone: this.is_partition_clone,
+      parent_trigger_name: this.parent_trigger_name,
+      parent_table_schema: this.parent_table_schema,
+      parent_table_name: this.parent_table_name,
+      is_on_partitioned_table: this.is_on_partitioned_table,
+      owner: this.owner,
+      comment: this.comment,
+    };
+  }
+}
+
+export async function extractTriggers(pool: Pool): Promise<Trigger[]> {
+  const { rows: triggerRows } = await pool.query<TriggerProps>(sql`
+      with extension_trigger_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid    = 'pg_trigger'::regclass
+      ),
+      extension_table_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid    = 'pg_class'::regclass
+          and d.deptype    = 'e'
+      ),
+      extension_function_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid    = 'pg_proc'::regclass
+      )
+      select
+        tc.relnamespace::regnamespace::text as schema,
+        quote_ident(t.tgname)               as name,
+        quote_ident(tc.relname)             as table_name,
+        tc.relkind                          as table_relkind,
+
+        fc.pronamespace::regnamespace::text as function_schema,
+        quote_ident(fc.proname)             as function_name,
+
+        t.tgtype                            as trigger_type,
+        t.tgenabled                         as enabled,
+        t.tgisinternal                       as is_internal,
+        t.tgdeferrable                       as deferrable,
+        t.tginitdeferred                     as initially_deferred,
+        t.tgnargs                            as argument_count,
+        t.tgattr                             as column_numbers,
+
+        case when t.tgnargs > 0
+            then array_fill(''::text, array[t.tgnargs])
+            else array[]::text[]
+        end as arguments,
+
+        -- identify triggers cloned onto partitions (created/attached partitions)
+        (t.tgparentid <> 0::oid)            as is_partition_clone,
+        case when t.tgparentid <> 0::oid
+            then quote_ident(parent_t.tgname)
+            else null
+        end                                 as parent_trigger_name,
+        case when t.tgparentid <> 0::oid
+            then parent_tc.relnamespace::regnamespace::text
+            else null
+        end                                 as parent_table_schema,
+        case when t.tgparentid <> 0::oid
+            then quote_ident(parent_tc.relname)
+            else null
+        end                                 as parent_table_name,
+
+        (tc.relkind = 'p')                  as is_on_partitioned_table,
+
+        (
+          case
+            when strpos(defn.definition, ' WHEN (') > 0
+            and strpos(defn.definition, ') EXECUTE') >
+                strpos(defn.definition, ' WHEN (') + 7
+            then substr(
+                  defn.definition,
+                  strpos(defn.definition, ' WHEN (') + 7,
+                  strpos(defn.definition, ') EXECUTE')
+                    - (strpos(defn.definition, ' WHEN (') + 7)
+                )
+            else null
+          end
+        ) as when_condition,
+
+        t.tgoldtable                        as old_table,
+        t.tgnewtable                        as new_table,
+        tc.relowner::regrole::text          as owner,
+        defn.definition                     as definition,
+        obj_description(t.oid, 'pg_trigger') as comment
+
+      from pg_catalog.pg_trigger t
+      join pg_catalog.pg_class   tc on tc.oid = t.tgrelid
+      join pg_catalog.pg_proc    fc on fc.oid = t.tgfoid
+
+      -- compute trigger definition once
+      left join lateral (
+        select pg_get_triggerdef(t.oid, true) as definition
+      ) defn on true
+
+      -- parent trigger/table linkage for cloned (partition) triggers
+      left join pg_catalog.pg_trigger parent_t  on parent_t.oid  = t.tgparentid
+      left join pg_catalog.pg_class   parent_tc on parent_tc.oid = parent_t.tgrelid
+
+      left join extension_trigger_oids  e_trigger  on t.oid  = e_trigger.objid
+      left join extension_table_oids    e_table    on tc.oid = e_table.objid
+      left join extension_function_oids e_function on fc.oid = e_function.objid
+
+      where not tc.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e_trigger.objid is null
+        and e_table.objid is null
+        and e_function.objid is null
+        and not t.tgisinternal
+
+      order by 1, 2
+  `);
+  // Validate and parse each row using the Zod schema
+  const validatedRows = triggerRows.map((row: unknown) =>
+    triggerPropsSchema.parse(row),
+  );
+  return validatedRows.map((row: TriggerProps) => new Trigger(row));
+}