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

package/dist/core/objects/table/table.model.d.ts

@@ -2,19 +2,22 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
+import { type SecurityLabelProps } from "../security-label.types.ts";
 export declare const ReplicaIdentitySchema: z.ZodEnum<{
-    f: "f";
     n: "n";
     i: "i";
     d: "d";
+    f: "f";
 }>;
 declare const tableConstraintPropsSchema: z.ZodObject<{
     name: z.ZodString;
     constraint_type: z.ZodEnum<{
-        f: "f";
         u: "u";
-        p: "p";
+        t: "t";
         c: "c";
+        p: "p";
+        f: "f";
         x: "x";
     }>;
     deferrable: z.ZodBoolean;
@@ -22,6 +25,7 @@ declare const tableConstraintPropsSchema: z.ZodObject<{
     validated: z.ZodBoolean;
     is_local: z.ZodBoolean;
     no_inherit: z.ZodBoolean;
+    is_temporal: z.ZodBoolean;
     is_partition_clone: z.ZodBoolean;
     parent_constraint_schema: z.ZodNullable<z.ZodString>;
     parent_constraint_name: z.ZodNullable<z.ZodString>;
@@ -37,24 +41,24 @@ declare const tableConstraintPropsSchema: z.ZodObject<{
     foreign_key_effective_schema: z.ZodNullable<z.ZodString>;
     foreign_key_effective_table: z.ZodNullable<z.ZodString>;
     on_update: z.ZodNullable<z.ZodEnum<{
-        r: "r";
         n: "n";
         a: "a";
+        r: "r";
         d: "d";
         c: "c";
     }>>;
     on_delete: z.ZodNullable<z.ZodEnum<{
-        r: "r";
         n: "n";
         a: "a";
+        r: "r";
         d: "d";
         c: "c";
     }>>;
     match_type: z.ZodNullable<z.ZodEnum<{
-        f: "f";
         u: "u";
         s: "s";
         p: "p";
+        f: "f";
     }>>;
     check_expression: z.ZodNullable<z.ZodString>;
     owner: z.ZodString;
@@ -78,11 +82,12 @@ declare const tablePropsSchema: z.ZodObject<{
     has_subclasses: z.ZodBoolean;
     is_populated: z.ZodBoolean;
     replica_identity: z.ZodEnum<{
-        f: "f";
         n: "n";
         i: "i";
         d: "d";
+        f: "f";
     }>;
+    replica_identity_index: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     is_partition: z.ZodBoolean;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
     partition_bound: z.ZodNullable<z.ZodString>;
@@ -108,14 +113,19 @@ declare const tablePropsSchema: z.ZodObject<{
         collation: z.ZodNullable<z.ZodString>;
         default: z.ZodNullable<z.ZodString>;
         comment: z.ZodNullable<z.ZodString>;
+        security_labels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            label: z.ZodString;
+        }, z.z.core.$strip>>>;
     }, z.z.core.$strip>>;
     constraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         constraint_type: z.ZodEnum<{
-            f: "f";
             u: "u";
-            p: "p";
+            t: "t";
             c: "c";
+            p: "p";
+            f: "f";
             x: "x";
         }>;
         deferrable: z.ZodBoolean;
@@ -123,6 +133,7 @@ declare const tablePropsSchema: z.ZodObject<{
         validated: z.ZodBoolean;
         is_local: z.ZodBoolean;
         no_inherit: z.ZodBoolean;
+        is_temporal: z.ZodBoolean;
         is_partition_clone: z.ZodBoolean;
         parent_constraint_schema: z.ZodNullable<z.ZodString>;
         parent_constraint_name: z.ZodNullable<z.ZodString>;
@@ -138,24 +149,24 @@ declare const tablePropsSchema: z.ZodObject<{
         foreign_key_effective_schema: z.ZodNullable<z.ZodString>;
         foreign_key_effective_table: z.ZodNullable<z.ZodString>;
         on_update: z.ZodNullable<z.ZodEnum<{
-            r: "r";
             n: "n";
             a: "a";
+            r: "r";
             d: "d";
             c: "c";
         }>>;
         on_delete: z.ZodNullable<z.ZodEnum<{
-            r: "r";
             n: "n";
             a: "a";
+            r: "r";
             d: "d";
             c: "c";
         }>>;
         match_type: z.ZodNullable<z.ZodEnum<{
-            f: "f";
             u: "u";
             s: "s";
             p: "p";
+            f: "f";
         }>>;
         check_expression: z.ZodNullable<z.ZodString>;
         owner: z.ZodString;
@@ -168,8 +179,16 @@ declare const tablePropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    security_labels: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        label: z.ZodString;
+    }, z.z.core.$strip>>>>;
 }, z.z.core.$strip>;
 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>;
 export declare class Table extends BasePgModel implements TableLikeObject {
     readonly schema: TableProps["schema"];
@@ -183,6 +202,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
     readonly has_subclasses: TableProps["has_subclasses"];
     readonly is_populated: TableProps["is_populated"];
     readonly replica_identity: TableProps["replica_identity"];
+    readonly replica_identity_index: TableProps["replica_identity_index"];
     readonly is_partition: TableProps["is_partition"];
     readonly options: TableProps["options"];
     readonly partition_bound: TableProps["partition_bound"];
@@ -194,6 +214,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
     readonly columns: TableProps["columns"];
     readonly constraints: TableConstraintProps[];
     readonly privileges: TablePrivilegeProps[];
+    readonly security_labels: SecurityLabelProps[];
     constructor(props: TableProps);
     get stableId(): `table:${string}`;
     get identityFields(): {
@@ -204,7 +225,8 @@ export declare class Table extends BasePgModel implements TableLikeObject {
         persistence: "u" | "t" | "p";
         row_security: boolean;
         force_row_security: boolean;
-        replica_identity: "f" | "n" | "i" | "d";
+        replica_identity: "n" | "i" | "d" | "f";
+        replica_identity_index: string | null | undefined;
         options: string[] | null;
         parent_schema: string | null;
         parent_name: string | null;
@@ -228,15 +250,20 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             collation: string | null;
             default: string | null;
             comment: string | null;
+            security_labels?: {
+                provider: string;
+                label: string;
+            }[] | undefined;
         }[];
         constraints: {
             name: string;
-            constraint_type: "f" | "u" | "p" | "c" | "x";
+            constraint_type: "u" | "t" | "c" | "p" | "f" | "x";
             deferrable: boolean;
             initially_deferred: boolean;
             validated: boolean;
             is_local: boolean;
             no_inherit: boolean;
+            is_temporal: boolean;
             is_partition_clone: boolean;
             parent_constraint_schema: string | null;
             parent_constraint_name: string | null;
@@ -251,9 +278,9 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             foreign_key_parent_table: string | null;
             foreign_key_effective_schema: string | null;
             foreign_key_effective_table: string | null;
-            on_update: "r" | "n" | "a" | "d" | "c" | null;
-            on_delete: "r" | "n" | "a" | "d" | "c" | null;
-            match_type: "f" | "u" | "s" | "p" | null;
+            on_update: "n" | "a" | "r" | "d" | "c" | null;
+            on_delete: "n" | "a" | "r" | "d" | "c" | null;
+            match_type: "u" | "s" | "p" | "f" | null;
             check_expression: string | null;
             owner: string;
             definition: string;
@@ -265,6 +292,10 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             grantable: boolean;
             columns?: string[] | null | undefined;
         }[];
+        security_labels: {
+            provider: string;
+            label: string;
+        }[];
     };
     stableSnapshot(): {
         identity: {
@@ -288,16 +319,21 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 collation: string | null;
                 default: string | null;
                 comment: string | null;
+                security_labels?: {
+                    provider: string;
+                    label: string;
+                }[] | undefined;
             }[];
             options: string[] | null;
             constraints: {
                 name: string;
-                constraint_type: "f" | "u" | "p" | "c" | "x";
+                constraint_type: "u" | "t" | "c" | "p" | "f" | "x";
                 deferrable: boolean;
                 initially_deferred: boolean;
                 validated: boolean;
                 is_local: boolean;
                 no_inherit: boolean;
+                is_temporal: boolean;
                 is_partition_clone: boolean;
                 parent_constraint_schema: string | null;
                 parent_constraint_name: string | null;
@@ -312,9 +348,9 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 foreign_key_parent_table: string | null;
                 foreign_key_effective_schema: string | null;
                 foreign_key_effective_table: string | null;
-                on_update: "r" | "n" | "a" | "d" | "c" | null;
-                on_delete: "r" | "n" | "a" | "d" | "c" | null;
-                match_type: "f" | "u" | "s" | "p" | null;
+                on_update: "n" | "a" | "r" | "d" | "c" | null;
+                on_delete: "n" | "a" | "r" | "d" | "c" | null;
+                match_type: "u" | "s" | "p" | "f" | null;
                 check_expression: string | null;
                 owner: string;
                 definition: string;
@@ -324,11 +360,17 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 grantee: string;
                 privilege: string;
                 grantable: boolean;
+                columns: string[] | null | undefined;
+            }[];
+            security_labels: {
+                provider: string;
+                label: string;
             }[];
             persistence: "u" | "t" | "p";
             row_security: boolean;
             force_row_security: boolean;
-            replica_identity: "f" | "n" | "i" | "d";
+            replica_identity: "n" | "i" | "d" | "f";
+            replica_identity_index: string | null | undefined;
             parent_schema: string | null;
             parent_name: string | null;
             partition_bound: string | null;
@@ -337,5 +379,5 @@ export declare class Table extends BasePgModel implements TableLikeObject {
         };
     };
 }
-export declare function extractTables(pool: Pool): Promise<Table[]>;
+export declare function extractTables(pool: Pool, options?: ExtractRetryOptions): Promise<Table[]>;
 export {};

package/dist/core/objects/table/table.model.js

@@ -3,6 +3,8 @@ import z from "zod";
 import { BasePgModel, columnPropsSchema, normalizeColumns, } from "../base.model.js";
 import { normalizePrivileges } from "../base.privilege.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
+import { normalizeSecurityLabels, securityLabelPropsSchema, } from "../security-label.types.js";
 const RelationPersistenceSchema = z.enum([
     "p", // permanent
     "u", // unlogged
@@ -33,6 +35,7 @@ const tableConstraintPropsSchema = z.object({
         "c", // CHECK constraint
         "f", // FOREIGN KEY constraint
         "p", // PRIMARY KEY constraint
+        "t", // TRIGGER constraint
         "u", // UNIQUE constraint
         "x", // EXCLUDE constraint
     ]),
@@ -41,6 +44,7 @@ const tableConstraintPropsSchema = z.object({
     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(),
@@ -63,6 +67,14 @@ const tableConstraintPropsSchema = z.object({
     definition: z.string(),
     comment: z.string().nullable().optional(),
 });
+// 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(),
@@ -75,6 +87,7 @@ const tablePropsSchema = z.object({
     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(),
@@ -86,6 +99,10 @@ const tablePropsSchema = z.object({
     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(),
 });
 export class Table extends BasePgModel {
     schema;
@@ -99,6 +116,7 @@ export class Table extends BasePgModel {
     has_subclasses;
     is_populated;
     replica_identity;
+    replica_identity_index;
     is_partition;
     options;
     partition_bound;
@@ -110,6 +128,7 @@ export class Table extends BasePgModel {
     columns;
     constraints;
     privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -125,6 +144,7 @@ export class Table extends BasePgModel {
         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;
@@ -136,6 +156,7 @@ export class Table extends BasePgModel {
         this.columns = props.columns;
         this.constraints = props.constraints ?? [];
         this.privileges = props.privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         return `table:${this.schema}.${this.name}`;
@@ -153,6 +174,7 @@ export class Table extends BasePgModel {
             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,
@@ -163,6 +185,7 @@ export class Table extends BasePgModel {
             columns: this.columns,
             constraints: this.constraints,
             privileges: this.privileges,
+            security_labels: this.security_labels,
         };
     }
     stableSnapshot() {
@@ -179,12 +202,18 @@ export class Table extends BasePgModel {
                 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) {
-    const { rows: tableRows } = await pool.query(sql `
+export async function extractTables(pool, options) {
+    const tableRows = await extractWithDefinitionRetry({
+        label: "table constraints",
+        options,
+        hasNullDefinition: (row) => row.constraints?.some((c) => c.definition === null) ?? false,
+        query: async () => {
+            const result = await pool.query(sql `
 with extension_oids as (
   select objid
   from pg_depend d
@@ -203,6 +232,14 @@ with extension_oids as (
     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,
@@ -233,6 +270,7 @@ select
   t.has_subclasses,
   t.is_populated,
   t.replica_identity,
+  t.replica_identity_index,
   t.is_partition,
   t.options,
   t.partition_bound,
@@ -252,9 +290,15 @@ select
           'validated', c.convalidated,
           'is_local', c.conislocal,
           'no_inherit', c.connoinherit,
+          'is_temporal', coalesce((to_jsonb(c)->>'conperiod')::boolean, false),
 
-          -- NEW: propagated-to-partition tagging (PG15+)
-          'is_partition_clone', (c.conparentid <> 0::oid),
+          -- 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,
@@ -262,13 +306,16 @@ select
 
           'key_columns',
             case
-              when c.conkey is not null then (
-                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
+              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,
@@ -338,6 +385,8 @@ select
       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
     ),
@@ -367,7 +416,20 @@ select
             and a.attcollation <> t2.typcollation
         ),
         'default', pg_get_expr(ad.adbin, ad.adrelid),
-        'comment', col_description(a.attrelid, a.attnum)
+        '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
@@ -394,7 +456,7 @@ select
       from (
         -- one row for object ACL + one row per column ACL
         select null::name as attname, t.oid as relacl_oid, (
-          select c_rel.relacl from pg_class c_rel where c_rel.oid = t.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
@@ -407,18 +469,36 @@ select
       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
+  ), '[]') 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.is_partition, t.options, t.partition_bound, t.partition_by, t.owner, t.parent_schema, t.parent_name
+  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
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = tableRows.map((row) => tablePropsSchema.parse(row));
+            return result.rows.map((row) => tableRowSchema.parse(row));
+        },
+    });
+    const validatedRows = tableRows.map((row) => {
+        const filteredConstraints = row.constraints?.filter((c) => c.definition !== null);
+        return { ...row, constraints: filteredConstraints };
+    });
     return validatedRows.map((row) => new Table(row));
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { TableLikeObject } from "../../base.model.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { AlterTriggerChange } from "./trigger.base.ts";
@@ -25,5 +26,5 @@ export declare class ReplaceTrigger extends AlterTriggerChange {
         indexableObject?: TableLikeObject;
     });
     get requires(): `trigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -1,5 +1,7 @@
+import { quoteLiteral } from "../../base.change.js";
 import { AlterTriggerChange } from "./trigger.base.js";
 import { CreateTrigger } from "./trigger.create.js";
+import { DropTrigger } from "./trigger.drop.js";
 /**
  * Replace a trigger by dropping and recreating it.
  * This is used when properties that cannot be altered via ALTER TRIGGER change.
@@ -16,7 +18,28 @@ export class ReplaceTrigger extends AlterTriggerChange {
     get requires() {
         return [this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
+        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,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { CreateTriggerChange, DropTriggerChange } from "./trigger.base.ts";
 export type CommentTrigger = CreateCommentOnTrigger | DropCommentOnTrigger;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnTrigger extends CreateTriggerChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `trigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnTrigger extends DropTriggerChange {
     readonly trigger: Trigger;
@@ -19,5 +20,5 @@ export declare class DropCommentOnTrigger extends DropTriggerChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `trigger:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnTrigger extends CreateTriggerChange {
     get requires() {
         return [this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TRIGGER",
             this.trigger.name,
@@ -39,7 +39,7 @@ export class DropCommentOnTrigger extends DropTriggerChange {
     get requires() {
         return [stableId.comment(this.trigger.stableId), this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TRIGGER",
             this.trigger.name,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { TableLikeObject } from "../../base.model.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { CreateTriggerChange } from "./trigger.base.ts";
@@ -37,5 +38,5 @@ export declare class CreateTrigger extends CreateTriggerChange {
     });
     get creates(): `trigger:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -45,17 +45,16 @@ export class CreateTrigger extends CreateTriggerChange {
         // Table dependency
         dependencies.add(stableId.table(this.trigger.schema, this.trigger.table_name));
         // Function dependency
-        // Note: We can't build the exact procedure stableId without argument types.
-        // The trigger definition contains the full function call, but parsing it would be complex.
-        // For now, we rely on pg_depend extraction for procedure dependencies.
-        // If needed, we could parse the trigger definition to extract the full function signature.
+        // 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() {
+    serialize(_options) {
         let definition = this.trigger.definition.trim();
-        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace ? "OR REPLACE " : ""}`);
+        const isConstraintTrigger = this.trigger.isConstraintTrigger;
+        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace && !isConstraintTrigger ? "OR REPLACE " : ""}`);
         return definition;
     }
 }