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

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

@@ -0,0 +1,555 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import {
+  BasePgModel,
+  columnPropsSchema,
+  normalizeColumns,
+  type TableLikeObject,
+} from "../base.model.ts";
+import { normalizePrivileges } from "../base.privilege.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../base.privilege-diff.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
+import {
+  normalizeSecurityLabels,
+  type SecurityLabelProps,
+  securityLabelPropsSchema,
+} from "../security-label.types.ts";
+
+const RelationPersistenceSchema = z.enum([
+  "p", // permanent
+  "u", // unlogged
+  "t", // temporary
+]);
+
+export const ReplicaIdentitySchema = z.enum([
+  "d", // DEFAULT (use default key)
+  "n", // NOTHING (no replica identity)
+  "f", // FULL (all columns)
+  "i", // INDEX (specific index)
+]);
+
+const ForeignKeyActionSchema = z.enum([
+  "a", // NO ACTION
+  "r", // RESTRICT
+  "c", // CASCADE
+  "n", // SET NULL
+  "d", // SET DEFAULT
+]);
+
+const ForeignKeyMatchTypeSchema = z.enum([
+  "f", // FULL
+  "p", // PARTIAL
+  "s", // SIMPLE
+  "u", // UNSPECIFIED (default)
+]);
+
+const tableConstraintPropsSchema = z.object({
+  name: z.string(),
+  constraint_type: z.enum([
+    "c", // CHECK constraint
+    "f", // FOREIGN KEY constraint
+    "p", // PRIMARY KEY constraint
+    "t", // TRIGGER constraint
+    "u", // UNIQUE constraint
+    "x", // EXCLUDE constraint
+  ]),
+  deferrable: z.boolean(),
+  initially_deferred: z.boolean(),
+  validated: z.boolean(),
+  is_local: z.boolean(),
+  no_inherit: z.boolean(),
+  is_temporal: z.boolean(),
+  is_partition_clone: z.boolean(),
+  parent_constraint_schema: z.string().nullable(),
+  parent_constraint_name: z.string().nullable(),
+  parent_table_schema: z.string().nullable(),
+  parent_table_name: z.string().nullable(),
+  key_columns: z.array(z.string()),
+  foreign_key_columns: z.array(z.string()).nullable(),
+  foreign_key_table: z.string().nullable(),
+  foreign_key_schema: z.string().nullable(),
+  foreign_key_table_is_partition: z.boolean().nullable(),
+  foreign_key_parent_schema: z.string().nullable(),
+  foreign_key_parent_table: z.string().nullable(),
+  foreign_key_effective_schema: z.string().nullable(),
+  foreign_key_effective_table: z.string().nullable(),
+  on_update: ForeignKeyActionSchema.nullable(),
+  on_delete: ForeignKeyActionSchema.nullable(),
+  match_type: ForeignKeyMatchTypeSchema.nullable(),
+  check_expression: z.string().nullable(),
+  owner: z.string(),
+  definition: z.string(),
+  comment: z.string().nullable().optional(),
+});
+
+export type TableConstraintProps = z.infer<typeof tableConstraintPropsSchema>;
+
+// pg_get_constraintdef(oid, pretty) can return NULL under the same conditions
+// as pg_get_indexdef: races with concurrent DDL, transient catalog
+// inconsistencies, recovery edges. An unreadable constraint cannot be diffed,
+// so we accept NULL here and filter the constraint out at extraction time
+// rather than crashing the whole catalog parse with a ZodError.
+const tableConstraintRowSchema = tableConstraintPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
+const tablePropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  persistence: RelationPersistenceSchema,
+  row_security: z.boolean(),
+  force_row_security: z.boolean(),
+  has_indexes: z.boolean(),
+  has_rules: z.boolean(),
+  has_triggers: z.boolean(),
+  has_subclasses: z.boolean(),
+  is_populated: z.boolean(),
+  replica_identity: ReplicaIdentitySchema,
+  replica_identity_index: z.string().nullable().optional(),
+  is_partition: z.boolean(),
+  options: z.array(z.string()).nullable(),
+  partition_bound: z.string().nullable(),
+  partition_by: z.string().nullable(),
+  owner: z.string(),
+  comment: z.string().nullable().optional(),
+  parent_schema: z.string().nullable(),
+  parent_name: z.string().nullable(),
+  columns: z.array(columnPropsSchema),
+  constraints: z.array(tableConstraintPropsSchema).optional(),
+  privileges: z.array(privilegePropsSchema),
+  security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+});
+
+const tableRowSchema = tablePropsSchema.extend({
+  constraints: z.array(tableConstraintRowSchema).optional(),
+});
+
+type TablePrivilegeProps = PrivilegeProps;
+/**
+ * Table input props. `security_labels` is optional on direct construction
+ * (defaults to `[]`); extraction always produces it via the Zod default.
+ */
+export type TableProps = z.infer<typeof tablePropsSchema>;
+type TableRow = z.infer<typeof tableRowSchema>;
+
+export class Table extends BasePgModel implements TableLikeObject {
+  public readonly schema: TableProps["schema"];
+  public readonly name: TableProps["name"];
+  public readonly persistence: TableProps["persistence"];
+  public readonly row_security: TableProps["row_security"];
+  public readonly force_row_security: TableProps["force_row_security"];
+  public readonly has_indexes: TableProps["has_indexes"];
+  public readonly has_rules: TableProps["has_rules"];
+  public readonly has_triggers: TableProps["has_triggers"];
+  public readonly has_subclasses: TableProps["has_subclasses"];
+  public readonly is_populated: TableProps["is_populated"];
+  public readonly replica_identity: TableProps["replica_identity"];
+  public readonly replica_identity_index: TableProps["replica_identity_index"];
+  public readonly is_partition: TableProps["is_partition"];
+  public readonly options: TableProps["options"];
+  public readonly partition_bound: TableProps["partition_bound"];
+  public readonly partition_by: TableProps["partition_by"];
+  public readonly owner: TableProps["owner"];
+  public readonly comment: TableProps["comment"];
+  public readonly parent_schema: TableProps["parent_schema"];
+  public readonly parent_name: TableProps["parent_name"];
+  public readonly columns: TableProps["columns"];
+  public readonly constraints: TableConstraintProps[];
+  public readonly privileges: TablePrivilegeProps[];
+  public readonly security_labels: SecurityLabelProps[];
+
+  constructor(props: TableProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+
+    // Data fields
+    this.persistence = props.persistence;
+    this.row_security = props.row_security;
+    this.force_row_security = props.force_row_security;
+    this.has_indexes = props.has_indexes;
+    this.has_rules = props.has_rules;
+    this.has_triggers = props.has_triggers;
+    this.has_subclasses = props.has_subclasses;
+    this.is_populated = props.is_populated;
+    this.replica_identity = props.replica_identity;
+    this.replica_identity_index = props.replica_identity_index ?? null;
+    this.is_partition = props.is_partition;
+    this.options = props.options;
+    this.partition_bound = props.partition_bound;
+    this.partition_by = props.partition_by;
+    this.owner = props.owner;
+    this.comment = props.comment;
+    this.parent_schema = props.parent_schema;
+    this.parent_name = props.parent_name;
+    this.columns = props.columns;
+    this.constraints = props.constraints ?? [];
+    this.privileges = props.privileges;
+    this.security_labels = props.security_labels ?? [];
+  }
+
+  get stableId(): `table:${string}` {
+    return `table:${this.schema}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      // Only include fields that can be managed via ALTER safely
+      persistence: this.persistence,
+      row_security: this.row_security,
+      force_row_security: this.force_row_security,
+      replica_identity: this.replica_identity,
+      replica_identity_index: this.replica_identity_index,
+      options: this.options,
+      // Partition membership can be altered via ATTACH/DETACH
+      parent_schema: this.parent_schema,
+      parent_name: this.parent_name,
+      partition_bound: this.partition_bound,
+      owner: this.owner,
+      comment: this.comment,
+      columns: this.columns,
+      constraints: this.constraints,
+      privileges: this.privileges,
+      security_labels: this.security_labels,
+    };
+  }
+
+  override stableSnapshot() {
+    const normalizeConstraints = () =>
+      [...this.constraints].sort((a, b) => {
+        const nameA = (a.name as string | undefined) ?? "";
+        const nameB = (b.name as string | undefined) ?? "";
+        return nameA.localeCompare(nameB);
+      });
+
+    return {
+      identity: this.identityFields,
+      data: {
+        ...this.dataFields,
+        columns: normalizeColumns(this.columns),
+        options: this.options ? [...this.options].sort() : this.options,
+        constraints: normalizeConstraints(),
+        privileges: normalizePrivileges(this.privileges),
+        security_labels: normalizeSecurityLabels(this.security_labels),
+      },
+    };
+  }
+}
+
+export async function extractTables(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Table[]> {
+  const tableRows = await extractWithDefinitionRetry({
+    label: "table constraints",
+    options,
+    hasNullDefinition: (row: TableRow) =>
+      row.constraints?.some((c) => c.definition === null) ?? false,
+    query: async () => {
+      const result = await pool.query<TableProps>(sql`
+with extension_oids as (
+  select objid
+  from pg_depend d
+  where d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::regclass
+), tables as (
+  select
+    c.relnamespace::regnamespace::text as schema,
+    quote_ident(c.relname) as name,
+    c.relpersistence as persistence,
+    c.relrowsecurity as row_security,
+    c.relforcerowsecurity as force_row_security,
+    c.relhasindex as has_indexes,
+    c.relhasrules as has_rules,
+    c.relhastriggers as has_triggers,
+    c.relhassubclass as has_subclasses,
+    c.relispopulated as is_populated,
+    c.relreplident as replica_identity,
+    (
+      select quote_ident(ri_class.relname)
+      from pg_index ri
+      join pg_class ri_class on ri_class.oid = ri.indexrelid
+      where ri.indrelid = c.oid
+        and ri.indisreplident is true
+      limit 1
+    ) as replica_identity_index,
+    c.relispartition as is_partition,
+    c.reloptions as options,
+    pg_get_expr(c.relpartbound, c.oid) as partition_bound,
+    pg_get_partkeydef(c.oid) as partition_by,
+    c.relowner::regrole::text as owner,
+    c_parent.relnamespace::regnamespace as parent_schema,
+    quote_ident(c_parent.relname) as parent_name,
+    c.oid as oid
+  from
+    pg_class c
+    left join extension_oids e1 on c.oid = e1.objid
+    left join pg_inherits i on i.inhrelid = c.oid
+    left join pg_class c_parent on i.inhparent = c_parent.oid
+  where
+    c.relkind in ('r', 'p')
+    and not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+    and e1.objid is null
+)
+select
+  t.schema,
+  t.name,
+  t.persistence,
+  t.row_security,
+  t.force_row_security,
+  t.has_indexes,
+  t.has_rules,
+  t.has_triggers,
+  t.has_subclasses,
+  t.is_populated,
+  t.replica_identity,
+  t.replica_identity_index,
+  t.is_partition,
+  t.options,
+  t.partition_bound,
+  t.partition_by,
+  t.owner,
+  obj_description(t.oid, 'pg_class') as comment,
+  t.parent_schema,
+  t.parent_name,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'name', quote_ident(c.conname),
+          'constraint_type', c.contype,
+          'deferrable', c.condeferrable,
+          'initially_deferred', c.condeferred,
+          'validated', c.convalidated,
+          'is_local', c.conislocal,
+          'no_inherit', c.connoinherit,
+          'is_temporal', coalesce((to_jsonb(c)->>'conperiod')::boolean, false),
+
+          -- Inherited from a parent (partition or classical inheritance).
+          -- coninhcount > 0 is the canonical signal across every constraint
+          -- kind. We previously used conparentid <> 0, but PostgreSQL only
+          -- populates conparentid for PK / UNIQUE / FK on partitions; CHECK
+          -- constraints on partitions always have conparentid = 0 and were
+          -- being re-emitted on every child, failing apply with 42710.
+          'is_partition_clone', (c.coninhcount > 0),
+          'parent_constraint_schema', case when c.conparentid <> 0::oid then pc.connamespace::regnamespace::text end,
+          'parent_constraint_name',   case when c.conparentid <> 0::oid then quote_ident(pc.conname) end,
+          'parent_table_schema',      case when c.conparentid <> 0::oid then pc_rel.relnamespace::regnamespace::text end,
+          'parent_table_name',        case when c.conparentid <> 0::oid then quote_ident(pc_rel.relname) end,
+
+          'key_columns',
+            case
+              when c.conkey is not null then coalesce(
+                (
+                  select json_agg(quote_ident(att.attname) order by pk.ordinality)
+                  from unnest(c.conkey) with ordinality as pk(attnum, ordinality)
+                  join pg_attribute att
+                    on att.attrelid = c.conrelid
+                  and att.attnum = pk.attnum
+                  and att.attisdropped = false
+                ),
+                '[]'::json
+              )
+              else '[]'::json
+            end,
+
+          'foreign_key_columns',
+            case
+              when c.contype = 'f' then (
+                select json_agg(quote_ident(att.attname) order by fk.ordinality)
+                from unnest(c.confkey) with ordinality as fk(attnum, ordinality)
+                join pg_attribute att
+                  on att.attrelid = c.confrelid
+                and att.attnum = fk.attnum
+                and att.attisdropped = false
+              )
+              else null
+            end,
+
+          -- existing FK target
+          'foreign_key_table',  quote_ident(ftc.relname),
+          'foreign_key_schema', ftc.relnamespace::regnamespace::text,
+
+          -- NEW: if FK points at a *partition*, expose its parent + an "effective" target
+          'foreign_key_table_is_partition',
+            case when c.contype = 'f' then coalesce(ftc.relispartition, false) else null end,
+          'foreign_key_parent_schema',
+            case when c.contype = 'f' and ftc.relispartition then ftc_parent.relnamespace::regnamespace::text else null end,
+          'foreign_key_parent_table',
+            case when c.contype = 'f' and ftc.relispartition then quote_ident(ftc_parent.relname) else null end,
+          'foreign_key_effective_schema',
+            case
+              when c.contype <> 'f' then null
+              when ftc.relispartition then ftc_parent.relnamespace::regnamespace::text
+              else ftc.relnamespace::regnamespace::text
+            end,
+          'foreign_key_effective_table',
+            case
+              when c.contype <> 'f' then null
+              when ftc.relispartition then quote_ident(ftc_parent.relname)
+              else quote_ident(ftc.relname)
+            end,
+
+          'on_update',  case when c.contype = 'f' then c.confupdtype   else null end,
+          'on_delete',  case when c.contype = 'f' then c.confdeltype   else null end,
+          'match_type', case when c.contype = 'f' then c.confmatchtype else null end,
+
+          'check_expression', pg_get_expr(c.conbin, c.conrelid),
+          'owner', t.owner,
+          'definition', pg_get_constraintdef(c.oid, true),
+          'comment', obj_description(c.oid, 'pg_constraint')
+        )
+        order by c.conname
+      )
+      from pg_catalog.pg_constraint c
+
+      -- NEW: parent constraint/table lookup (for propagated constraints)
+      left join pg_catalog.pg_constraint pc on pc.oid = c.conparentid
+      left join pg_catalog.pg_class pc_rel on pc_rel.oid = pc.conrelid
+
+      -- FK referenced table + parent table if it’s a partition
+      left join pg_catalog.pg_class ftc on ftc.oid = c.confrelid
+      left join pg_catalog.pg_inherits fi on fi.inhrelid = ftc.oid
+      left join pg_catalog.pg_class ftc_parent on ftc_parent.oid = fi.inhparent
+
+      left join pg_depend de
+        on de.classid = 'pg_constraint'::regclass
+      and de.objid = c.oid
+      and de.refclassid = 'pg_extension'::regclass
+
+      where c.conrelid = t.oid
+        -- Skip constraint triggers and PG18 NOT NULL constraints; they are modeled elsewhere
+        and c.contype not in ('t', 'n')
+        and not c.connamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and de.objid is null
+    ),
+    '[]'
+  ) as constraints,
+  coalesce(json_agg(
+    case when a.attname is not null then
+      json_build_object(
+        'name', quote_ident(a.attname),
+        'position', a.attnum,
+        'data_type', a.atttypid::regtype::text,
+        'data_type_str', format_type(a.atttypid, a.atttypmod),
+        'is_custom_type', ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema'),
+        'custom_type_type', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typtype else null end,
+        'custom_type_category', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typcategory else null end,
+        'custom_type_schema', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typnamespace::regnamespace else null end,
+        'custom_type_name', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then quote_ident(ty.typname) else null end,
+        'not_null', a.attnotnull,
+        'is_identity', a.attidentity != '',
+        'is_identity_always', a.attidentity = 'a',
+        'is_generated', a.attgenerated != '',
+        'collation', (
+          select quote_ident(c2.collname)
+          from pg_collation c2, pg_type t2
+          where c2.oid = a.attcollation
+            and t2.oid = a.atttypid
+            and a.attcollation <> t2.typcollation
+        ),
+        'default', pg_get_expr(ad.adbin, ad.adrelid),
+        'comment', col_description(a.attrelid, a.attnum),
+        'security_labels', coalesce(
+          (
+            select json_agg(
+              json_build_object('provider', sl.provider, 'label', sl.label)
+              order by sl.provider
+            )
+            from pg_catalog.pg_seclabel sl
+            where sl.objoid = t.oid
+              and sl.classoid = 'pg_class'::regclass
+              and sl.objsubid = a.attnum
+          ),
+          '[]'::json
+        )
+      )
+    end
+    order by a.attnum
+  ) filter (where a.attname is not null), '[]') as columns,
+  coalesce((
+    select json_agg(
+            json_build_object(
+              'grantee', case when grp.grantee = 0 then 'PUBLIC' else grp.grantee::regrole::text end,
+              'privilege', grp.privilege_type,
+              'grantable', grp.is_grantable,
+              'columns', case when grp.cols is not null and array_length(grp.cols,1) > 0
+                              then grp.cols
+                              else null end
+            )
+            order by grp.grantee, grp.privilege_type
+          )
+    from (
+      select
+        x.grantee,
+        x.privilege_type,
+        bool_or(x.is_grantable) as is_grantable,
+        array_agg(quote_ident(src.attname) order by src.attname)
+          filter (where src.attname is not null) as cols
+      from (
+        -- one row for object ACL + one row per column ACL
+        select null::name as attname, t.oid as relacl_oid, (
+          select COALESCE(c_rel.relacl, acldefault('r', c_rel.relowner)) from pg_class c_rel where c_rel.oid = t.oid
+        ) as acl
+        union all
+        select a2.attname, t.oid as relacl_oid, a2.attacl
+        from pg_attribute a2
+        where a2.attrelid = t.oid
+          and a2.attnum > 0
+          and not a2.attisdropped
+          and a2.attacl is not null
+      ) as src
+      join lateral aclexplode(src.acl) as x(grantor, grantee, privilege_type, is_grantable) on true
+      group by x.grantee, x.privilege_type
+    ) as grp
+  ), '[]') as privileges,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object('provider', sl.provider, 'label', sl.label)
+        order by sl.provider
+      )
+      from pg_catalog.pg_seclabel sl
+      where sl.objoid = t.oid
+        and sl.classoid = 'pg_class'::regclass
+        and sl.objsubid = 0
+    ),
+    '[]'::json
+  ) as security_labels
+from
+  tables t
+  left join pg_attribute a on a.attrelid = t.oid and a.attnum > 0 and not a.attisdropped
+  left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
+  left join pg_type ty on ty.oid = a.atttypid
+group by
+  t.oid, t.schema, t.name, t.persistence, t.row_security, t.force_row_security, t.has_indexes, t.has_rules, t.has_triggers, t.has_subclasses, t.is_populated, t.replica_identity, t.replica_identity_index, t.is_partition, t.options, t.partition_bound, t.partition_by, t.owner, t.parent_schema, t.parent_name
+order by
+  t.schema, t.name
+  `);
+      return result.rows.map((row: unknown) => tableRowSchema.parse(row));
+    },
+  });
+  const validatedRows = tableRows.map((row): TableProps => {
+    const filteredConstraints = row.constraints?.filter(
+      (c): c is TableConstraintProps => c.definition !== null,
+    );
+    return { ...row, constraints: filteredConstraints };
+  });
+  return validatedRows.map((row: TableProps) => new Table(row));
+}

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

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Trigger, type TriggerProps } from "../trigger.model.ts";
+import { ReplaceTrigger } from "./trigger.alter.ts";
+
+describe.concurrent("trigger", () => {
+  describe("alter", () => {
+    test("replace trigger", async () => {
+      const props: Omit<TriggerProps, "enabled"> = {
+        schema: "public",
+        name: "test_trigger",
+        table_name: "test_table",
+        table_relkind: "r",
+        function_schema: "public",
+        function_name: "test_function",
+        trigger_type: 1 << 4, // UPDATE (1<<4) = 16, AFTER is default (0), STATEMENT is default (0)
+        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 AFTER UPDATE ON public.test_table EXECUTE FUNCTION public.test_function()",
+        comment: null,
+      };
+      const branch = new Trigger({
+        ...props,
+        enabled: "D",
+      });
+
+      const change = new ReplaceTrigger({ trigger: branch });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "CREATE OR REPLACE TRIGGER test_trigger AFTER UPDATE ON public.test_table EXECUTE FUNCTION public.test_function()",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,74 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import type { TableLikeObject } from "../../base.model.ts";
+import type { Trigger } from "../trigger.model.ts";
+import { AlterTriggerChange } from "./trigger.base.ts";
+import { CreateTrigger } from "./trigger.create.ts";
+import { DropTrigger } from "./trigger.drop.ts";
+
+/**
+ * Alter a trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altertrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER TRIGGER name ON table_name RENAME TO new_name
+ * ```
+ */
+
+export type AlterTrigger = ReplaceTrigger;
+
+/**
+ * Replace a trigger by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER TRIGGER change.
+ */
+export class ReplaceTrigger extends AlterTriggerChange {
+  public readonly trigger: Trigger;
+  public readonly indexableObject?: TableLikeObject;
+  public readonly scope = "object" as const;
+
+  constructor(props: { trigger: Trigger; indexableObject?: TableLikeObject }) {
+    super();
+    this.trigger = props.trigger;
+    this.indexableObject = props.indexableObject;
+  }
+
+  get requires() {
+    return [this.trigger.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    if (this.trigger.isConstraintTrigger) {
+      const dropChange = new DropTrigger({ trigger: this.trigger });
+      const createChange = new CreateTrigger({
+        trigger: this.trigger,
+        indexableObject: this.indexableObject,
+        orReplace: false,
+      });
+      const commentSql =
+        this.trigger.comment !== null
+          ? [
+              "COMMENT ON TRIGGER",
+              this.trigger.name,
+              "ON",
+              `${this.trigger.schema}.${this.trigger.table_name}`,
+              "IS",
+              quoteLiteral(this.trigger.comment),
+            ].join(" ")
+          : null;
+
+      return [dropChange.serialize(), createChange.serialize(), commentSql]
+        .filter(Boolean)
+        .join(";\n");
+    }
+
+    const createChange = new CreateTrigger({
+      trigger: this.trigger,
+      indexableObject: this.indexableObject,
+      orReplace: true,
+    });
+
+    return createChange.serialize();
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Trigger } from "../trigger.model.ts";
+
+abstract class BaseTriggerChange extends BaseChange {
+  abstract readonly trigger: Trigger;
+  abstract readonly scope: "object" | "comment";
+  readonly objectType = "trigger" as const;
+}
+
+export abstract class CreateTriggerChange extends BaseTriggerChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterTriggerChange extends BaseTriggerChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropTriggerChange extends BaseTriggerChange {
+  readonly operation = "drop" as const;
+}