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

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

@@ -1,7 +1,7 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
 import { deepEqual } from "../utils.js";
-import { AlterTableAddColumn, AlterTableAddConstraint, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropNotNull, AlterTableAlterColumnSetDefault, AlterTableAlterColumnSetNotNull, AlterTableAlterColumnType, AlterTableAttachPartition, AlterTableChangeOwner, AlterTableDetachPartition, AlterTableDisableRowLevelSecurity, AlterTableDropColumn, AlterTableDropConstraint, AlterTableEnableRowLevelSecurity, AlterTableForceRowLevelSecurity, AlterTableNoForceRowLevelSecurity, AlterTableResetStorageParams, AlterTableSetLogged, AlterTableSetReplicaIdentity, AlterTableSetStorageParams, AlterTableSetUnlogged, AlterTableValidateConstraint, } from "./changes/table.alter.js";
+import { AlterTableAddColumn, AlterTableAddConstraint, AlterTableAlterColumnAddIdentity, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropIdentity, AlterTableAlterColumnDropNotNull, AlterTableAlterColumnSetDefault, AlterTableAlterColumnSetGenerated, AlterTableAlterColumnSetNotNull, AlterTableAlterColumnType, AlterTableAttachPartition, AlterTableChangeOwner, AlterTableDetachPartition, AlterTableDisableRowLevelSecurity, AlterTableDropColumn, AlterTableDropConstraint, AlterTableEnableRowLevelSecurity, AlterTableForceRowLevelSecurity, AlterTableNoForceRowLevelSecurity, AlterTableResetStorageParams, AlterTableSetLogged, AlterTableSetReplicaIdentity, AlterTableSetStorageParams, AlterTableSetUnlogged, AlterTableValidateConstraint, } from "./changes/table.alter.js";
 import { CreateCommentOnColumn, CreateCommentOnConstraint, CreateCommentOnTable, DropCommentOnColumn, DropCommentOnConstraint, DropCommentOnTable, } from "./changes/table.comment.js";
 import { CreateTable } from "./changes/table.create.js";
 import { DropTable } from "./changes/table.drop.js";
@@ -66,6 +66,7 @@ function createAlterConstraintChange(mainTable, branchTable) {
             mainC.validated !== branchC.validated ||
             mainC.is_local !== branchC.is_local ||
             mainC.no_inherit !== branchC.no_inherit ||
+            mainC.is_temporal !== branchC.is_temporal ||
             JSON.stringify(mainC.key_columns) !==
                 JSON.stringify(branchC.key_columns) ||
             JSON.stringify(mainC.foreign_key_columns) !==
@@ -149,6 +150,16 @@ export function diffTables(ctx, main, branch) {
         if (branchTable.force_row_security) {
             changes.push(new AlterTableForceRowLevelSecurity({ table: branchTable }));
         }
+        // REPLICA IDENTITY: If non-default, emit ALTER TABLE ... REPLICA IDENTITY
+        if (branchTable.replica_identity !== "d") {
+            // Skip 'i' (USING INDEX) — handled by index changes
+            if (branchTable.replica_identity !== "i") {
+                changes.push(new AlterTableSetReplicaIdentity({
+                    table: branchTable,
+                    mode: branchTable.replica_identity,
+                }));
+            }
+        }
         changes.push(...createAlterConstraintChange(
         // Create a dummy table with no constraints do diff constraints against
         new Table({
@@ -171,86 +182,18 @@ export function diffTables(ctx, main, branch) {
         // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
         // needed to reach the final desired state.
         const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "table", branchTable.schema ?? "");
+        const creatorFilteredDefaults = branchTable.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         const desiredPrivileges = branchTable.privileges;
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the table owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, branchTable.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantTablePrivileges({
-                            table: branchTable,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeTablePrivileges({
-                        table: branchTable,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    const originalPriv = effectiveDefaults.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionTablePrivileges({
-                        table: branchTable,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, branchTable.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchTable, branchTable, "table", {
+            Grant: GrantTablePrivileges,
+            Revoke: RevokeTablePrivileges,
+            RevokeGrantOption: RevokeGrantOptionTablePrivileges,
+        }, effectiveDefaults, ctx.version));
     }
     for (const tableId of dropped) {
         changes.push(new DropTable({ table: main[tableId] }));
@@ -439,6 +382,17 @@ export function diffTables(ctx, main, branch) {
                         partitionNotNullChanged &&
                         parentBranchCol.not_null === branchCol.not_null);
                 }
+                case "identity": {
+                    const parentIdentityChanged = parentMainCol.is_identity !== parentBranchCol.is_identity ||
+                        parentMainCol.is_identity_always !==
+                            parentBranchCol.is_identity_always;
+                    const partitionIdentityChanged = mainCol.is_identity !== branchCol.is_identity ||
+                        mainCol.is_identity_always !== branchCol.is_identity_always;
+                    return (parentIdentityChanged &&
+                        partitionIdentityChanged &&
+                        parentBranchCol.is_identity === branchCol.is_identity &&
+                        parentBranchCol.is_identity_always === branchCol.is_identity_always);
+                }
             }
         };
         // Helper to check if parent has the same column add/drop
@@ -497,14 +451,39 @@ export function diffTables(ctx, main, branch) {
             const branchCol = branchCols.get(name);
             if (!branchCol)
                 continue;
+            const columnTypeChanged = mainCol.data_type_str !== branchCol.data_type_str;
+            const columnCollationChanged = mainCol.collation !== branchCol.collation;
+            const needsDefaultSafeFlow = columnTypeChanged && mainCol.default !== null;
             // TYPE or COLLATION change
-            if (mainCol.data_type_str !== branchCol.data_type_str ||
-                mainCol.collation !== branchCol.collation) {
+            if (columnTypeChanged || columnCollationChanged) {
                 // Skip if parent has the same type/collation change
                 if (!parentHasSameColumnPropertyChange(name, "type")) {
+                    if (needsDefaultSafeFlow) {
+                        changes.push(new AlterTableAlterColumnDropDefault({
+                            table: branchTable,
+                            column: branchCol,
+                        }));
+                    }
                     changes.push(new AlterTableAlterColumnType({
                         table: branchTable,
                         column: branchCol,
+                        previousColumn: mainCol,
+                    }));
+                    if (needsDefaultSafeFlow && branchCol.default !== null) {
+                        changes.push(new AlterTableAlterColumnSetDefault({
+                            table: branchTable,
+                            column: branchCol,
+                        }));
+                    }
+                }
+            }
+            // PostgreSQL rejects SET DEFAULT while the column still has identity metadata,
+            // so identity removal must lead the IDENTITY -> serial/default transition.
+            if (mainCol.is_identity && !branchCol.is_identity) {
+                if (!parentHasSameColumnPropertyChange(name, "identity")) {
+                    changes.push(new AlterTableAlterColumnDropIdentity({
+                        table: branchTable,
+                        column: branchCol,
                     }));
                 }
             }
@@ -512,6 +491,10 @@ export function diffTables(ctx, main, branch) {
             if (mainCol.default !== branchCol.default) {
                 // Skip if parent has the same default change
                 if (!parentHasSameColumnPropertyChange(name, "default")) {
+                    if (needsDefaultSafeFlow) {
+                        // Defaults were already dropped/re-set in the type-change flow above.
+                        continue;
+                    }
                     if (branchCol.default === null) {
                         // Drop default value
                         changes.push(new AlterTableAlterColumnDropDefault({
@@ -523,9 +506,14 @@ export function diffTables(ctx, main, branch) {
                         // Set new default value
                         const isGeneratedColumn = branchCol.is_generated;
                         const isPostgresLowerThan17 = ctx.version < 170000;
-                        if (isGeneratedColumn && isPostgresLowerThan17) {
+                        const generatedStatusChanged = mainCol.is_generated !== branchCol.is_generated;
+                        if (isGeneratedColumn &&
+                            (isPostgresLowerThan17 || generatedStatusChanged)) {
                             // For generated columns in < PostgreSQL 17, we need to drop and recreate
-                            // instead of using SET EXPRESSION AS for computed columns
+                            // instead of using SET EXPRESSION AS for computed columns. We also
+                            // need to recreate the column when switching between regular and
+                            // generated states because SET EXPRESSION only applies to existing
+                            // generated columns.
                             // cf: https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=5d06e99a3
                             // cf: https://www.postgresql.org/docs/release/17.0/
                             // > Allow ALTER TABLE to change a column's generation expression
@@ -548,6 +536,30 @@ export function diffTables(ctx, main, branch) {
                     }
                 }
             }
+            // Serial-like defaults have to be cleared before ADD GENERATED AS IDENTITY,
+            // while mode-only flips stay in-place on an existing identity column.
+            if ((!mainCol.is_identity && branchCol.is_identity) ||
+                (mainCol.is_identity &&
+                    branchCol.is_identity &&
+                    mainCol.is_identity_always !== branchCol.is_identity_always)) {
+                // Skip if parent has the same identity change
+                if (!parentHasSameColumnPropertyChange(name, "identity")) {
+                    if (!mainCol.is_identity && branchCol.is_identity) {
+                        changes.push(new AlterTableAlterColumnAddIdentity({
+                            table: branchTable,
+                            column: branchCol,
+                        }));
+                    }
+                    else if (mainCol.is_identity &&
+                        branchCol.is_identity &&
+                        mainCol.is_identity_always !== branchCol.is_identity_always) {
+                        changes.push(new AlterTableAlterColumnSetGenerated({
+                            table: branchTable,
+                            column: branchCol,
+                        }));
+                    }
+                }
+            }
             // NOT NULL change
             if (mainCol.not_null !== branchCol.not_null) {
                 // Skip if parent has the same NOT NULL change
@@ -584,85 +596,12 @@ export function diffTables(ctx, main, branch) {
         // PRIVILEGES (unified object and column privileges)
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use branch owner as the reference.
-        const privilegeResults = diffPrivileges(mainTable.privileges, branchTable.privileges, branchTable.owner, ctx.mainRoles);
-        for (const [grantee, result] of privilegeResults) {
-            // Generate grant changes
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantTablePrivileges({
-                            table: branchTable,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    // Collapse all grantable groups into a single revoke (grantable: false)
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeTablePrivileges({
-                        table: mainTable,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    // For revoke grant option, we need to find the columns from the original privilege
-                    const originalPriv = mainTable.privileges.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionTablePrivileges({
-                        table: mainTable,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(mainTable.privileges, branchTable.privileges, branchTable.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchTable, mainTable, "table", {
+            Grant: GrantTablePrivileges,
+            Revoke: RevokeTablePrivileges,
+            RevokeGrantOption: RevokeGrantOptionTablePrivileges,
+        }, mainTable.privileges, ctx.version));
     }
     return changes;
 }

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

@@ -3,18 +3,19 @@ import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.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 +23,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 +39,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,10 +80,10 @@ 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";
     }>;
     is_partition: z.ZodBoolean;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
@@ -112,10 +114,11 @@ declare const tablePropsSchema: z.ZodObject<{
     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 +126,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 +142,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;
@@ -204,7 +208,7 @@ 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";
         options: string[] | null;
         parent_schema: string | null;
         parent_name: string | null;
@@ -231,12 +235,13 @@ export declare class Table extends BasePgModel implements TableLikeObject {
         }[];
         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 +256,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;
@@ -292,12 +297,13 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             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 +318,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 +330,12 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 grantee: string;
                 privilege: string;
                 grantable: boolean;
+                columns: string[] | null | undefined;
             }[];
             persistence: "u" | "t" | "p";
             row_security: boolean;
             force_row_security: boolean;
-            replica_identity: "f" | "n" | "i" | "d";
+            replica_identity: "n" | "i" | "d" | "f";
             parent_schema: string | null;
             parent_name: string | null;
             partition_bound: string | null;

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

@@ -33,6 +33,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 +42,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(),
@@ -252,6 +254,7 @@ 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),
@@ -262,13 +265,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 +344,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
     ),
@@ -394,7 +402,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

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,