@supabase/pg-delta 1.0.0-alpha.17 → 1.0.0-alpha.19

package/dist/core/expand-replace-dependencies.js

@@ -1,5 +1,7 @@
 import { CreateDomain } from "./objects/domain/changes/domain.create.js";
 import { DropDomain } from "./objects/domain/changes/domain.drop.js";
+import { CreateIndex } from "./objects/index/changes/index.create.js";
+import { DropIndex } from "./objects/index/changes/index.drop.js";
 import { CreateMaterializedView } from "./objects/materialized-view/changes/materialized-view.create.js";
 import { DropMaterializedView } from "./objects/materialized-view/changes/materialized-view.drop.js";
 import { CreateProcedure } from "./objects/procedure/changes/procedure.create.js";
@@ -32,6 +34,25 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
             replaceRoots.add(id);
         }
     }
+    // Procedure stableIds are signature-qualified
+    // (`procedure:schema.name(argtypes)`), so a function whose parameter types
+    // change has different ids in `createdIds` and `droppedIds` and would not
+    // appear in the intersection above. Treat any dropped procedure whose
+    // `(schema, name)` matches a created procedure as a replace root so
+    // dependents referencing the old signature via pg_depend get promoted to
+    // DROP+CREATE.
+    const createdProcedureNames = new Set();
+    for (const id of createdIds) {
+        const key = parseProcedureSchemaName(id);
+        if (key)
+            createdProcedureNames.add(key);
+    }
+    for (const id of droppedIds) {
+        const key = parseProcedureSchemaName(id);
+        if (key && createdProcedureNames.has(key)) {
+            replaceRoots.add(id);
+        }
+    }
     if (replaceRoots.size === 0) {
         return {
             changes,
@@ -149,6 +170,14 @@ function isOwnedSequenceColumnDependency(referencedId, dependentId, mainCatalog,
     return (dependentId ===
         stableId.column(sequence.owned_by_schema, sequence.owned_by_table, sequence.owned_by_column));
 }
+function parseProcedureSchemaName(stableId) {
+    if (!stableId.startsWith("procedure:"))
+        return null;
+    const paren = stableId.indexOf("(");
+    if (paren === -1)
+        return null;
+    return stableId.slice("procedure:".length, paren);
+}
 function normalizeDependentId(dependentId) {
     let id = dependentId;
     while (id.startsWith("comment:")) {
@@ -195,6 +224,18 @@ function resolveObjectForStableId(stableId, mainCatalog, branchCatalog) {
         const branch = branchCatalog.materializedViews[stableId];
         return main && branch ? { kind: "materialized_view", main, branch } : null;
     }
+    if (stableId.startsWith("index:")) {
+        const main = mainCatalog.indexes[stableId];
+        const branch = branchCatalog.indexes[stableId];
+        return main && branch
+            ? {
+                kind: "index",
+                main,
+                branch,
+                branchIndexableObject: branchCatalog.indexableObjects[branch.tableStableId],
+            }
+            : null;
+    }
     if (stableId.startsWith("procedure:")) {
         const main = mainCatalog.procedures[stableId];
         const branch = branchCatalog.procedures[stableId];
@@ -280,6 +321,34 @@ function buildReplaceChanges(resolved, options) {
                     ? [new CreateMaterializedView({ materializedView: resolved.branch })]
                     : []),
             ];
+        case "index":
+            // Constraint-owned, primary, and partition-attached indexes are managed
+            // by the owning constraint or parent-index DDL, not standalone
+            // CREATE INDEX / DROP INDEX. The `case "table":` branch above already
+            // recreates constraints via AlterTableAddConstraint; emitting a
+            // standalone drop/create here would fail in PostgreSQL
+            // ("cannot drop index ... because constraint ... requires it") or
+            // duplicate the index the constraint recreates. Skip matches
+            // diffIndexes (packages/pg-delta/src/core/objects/index/index.diff.ts).
+            if (resolved.main.is_owned_by_constraint ||
+                resolved.main.is_primary ||
+                resolved.main.is_index_partition ||
+                resolved.branch.is_owned_by_constraint ||
+                resolved.branch.is_primary ||
+                resolved.branch.is_index_partition) {
+                return null;
+            }
+            return [
+                ...(addDrop ? [new DropIndex({ index: resolved.main })] : []),
+                ...(addCreate
+                    ? [
+                        new CreateIndex({
+                            index: resolved.branch,
+                            indexableObject: resolved.branchIndexableObject,
+                        }),
+                    ]
+                    : []),
+            ];
         case "procedure":
             return [
                 ...(addDrop ? [new DropProcedure({ procedure: resolved.main })] : []),

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

@@ -36,6 +36,15 @@ const indexPropsSchema = z.object({
     comment: z.string().nullable(),
     owner: z.string(),
 });
+// pg_get_indexdef(oid, colno, pretty) invokes pg_get_indexdef_worker with
+// missing_ok = true, so it can return NULL when any internal system-cache lookup
+// fails (race with concurrent DROP, role visibility edge cases, orphaned index
+// metadata, recovery transients). An unreadable index cannot be diffed, so we
+// accept NULL here and filter the row out with a debug log instead of crashing
+// the whole catalog extraction.
+const indexRowSchema = indexPropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class Index extends BasePgModel {
     schema;
     table_name;
@@ -332,7 +341,8 @@ export async function extractIndexes(pool) {
 
       order by 1, 2
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = indexRows.map((row) => indexPropsSchema.parse(row));
+    const validatedRows = indexRows
+        .map((row) => indexRowSchema.parse(row))
+        .filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Index(row));
 }

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

@@ -17,8 +17,7 @@ import { GrantProcedurePrivileges, RevokeGrantOptionProcedurePrivileges, RevokeP
 export function diffProcedures(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
-    for (const procedureId of created) {
-        const proc = branch[procedureId];
+    const appendCreateProcedureChanges = (proc) => {
         changes.push(new CreateProcedure({ procedure: proc }));
         // OWNER: If the procedure should be owned by someone other than the current user,
         // emit ALTER FUNCTION/PROCEDURE ... OWNER TO after creation
@@ -53,6 +52,9 @@ export function diffProcedures(ctx, main, branch) {
             Revoke: RevokeProcedurePrivileges,
             RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
         }, ctx.version));
+    };
+    for (const procedureId of created) {
+        appendCreateProcedureChanges(branch[procedureId]);
     }
     for (const procedureId of dropped) {
         changes.push(new DropProcedure({ procedure: main[procedureId] }));
@@ -60,22 +62,18 @@ export function diffProcedures(ctx, main, branch) {
     for (const procedureId of altered) {
         const mainProcedure = main[procedureId];
         const branchProcedure = branch[procedureId];
-        // Check if non-alterable properties have changed
-        // These require dropping and recreating the procedure
-        const NON_ALTERABLE_FIELDS = [
+        // Fields that are part of the function's identity/signature. PostgreSQL
+        // rejects `CREATE OR REPLACE FUNCTION` for any of these changes with
+        // errors such as:
+        //   - cannot change return type of existing function
+        //   - cannot change name of input parameter "..."
+        //   - cannot change whether a procedure has output parameters
+        //   - cannot remove parameter defaults from existing function
+        // These require `DROP FUNCTION` followed by `CREATE FUNCTION`.
+        const SIGNATURE_BREAKING_FIELDS = [
             "kind",
             "return_type",
             "return_type_schema",
-            "language",
-            // The following properties are alterable in SQL, but our generator may choose
-            // to replace on changes not covered by explicit ALTER actions. Keep them out here
-            // to allow ALTER for those we implement below.
-            // security_definer,
-            // volatility,
-            // parallel_safety,
-            // is_strict,
-            // leakproof,
-            // Returns-set is part of the signature and not alterable
             "returns_set",
             "argument_count",
             "argument_default_count",
@@ -84,20 +82,35 @@ export function diffProcedures(ctx, main, branch) {
             "all_argument_types",
             "argument_modes",
             "argument_defaults",
+        ];
+        // Fields where `CREATE OR REPLACE` is sufficient - body replacement only.
+        // Other fields (security_definer, volatility, parallel_safety, is_strict,
+        // leakproof, config) are alterable via dedicated ALTER actions below.
+        const OR_REPLACEABLE_NON_ALTERABLE_FIELDS = [
+            "language",
             "source_code",
             "binary_path",
             "sql_body",
-            // config is alterable via SET/RESET
         ];
-        const nonAlterablePropsChanged = hasNonAlterableChanges(mainProcedure, branchProcedure, NON_ALTERABLE_FIELDS, {
+        const signatureChanged = hasNonAlterableChanges(mainProcedure, branchProcedure, SIGNATURE_BREAKING_FIELDS, {
             argument_names: deepEqual,
             argument_types: deepEqual,
             all_argument_types: deepEqual,
             argument_modes: deepEqual,
-            config: deepEqual,
         });
-        if (nonAlterablePropsChanged) {
-            // Replace the entire procedure
+        const nonAlterablePropsChanged = signatureChanged ||
+            hasNonAlterableChanges(mainProcedure, branchProcedure, OR_REPLACEABLE_NON_ALTERABLE_FIELDS);
+        if (signatureChanged) {
+            // PostgreSQL cannot change an existing function's signature via
+            // `CREATE OR REPLACE`. Drop the old signature, then recreate.
+            // `expandReplaceDependencies` will cascade the replacement to dependent
+            // objects (views, triggers, column defaults) via pg_depend edges.
+            changes.push(new DropProcedure({ procedure: mainProcedure }));
+            appendCreateProcedureChanges(branchProcedure);
+        }
+        else if (nonAlterablePropsChanged) {
+            // Body-only non-alterable change - `CREATE OR REPLACE` preserves the
+            // function OID and keeps dependent objects attached.
             changes.push(new CreateProcedure({ procedure: branchProcedure, orReplace: true }));
             if (mainProcedure.comment !== branchProcedure.comment) {
                 if (branchProcedure.comment === null) {

package/dist/core/objects/rls-policy/changes/rls-policy.create.js

@@ -33,6 +33,29 @@ export class CreateRlsPolicy extends CreateRlsPolicyChange {
         dependencies.add(stableId.table(this.policy.schema, this.policy.table_name));
         // Owner dependency
         dependencies.add(stableId.role(this.policy.owner));
+        // Relations and functions referenced inside USING / WITH CHECK
+        // expressions must exist before the policy is created. These come from
+        // pg_depend (populated by PostgreSQL's recordDependencyOnExpr at policy
+        // creation), not from re-parsing the expression text.
+        for (const ref of this.policy.referenced_relations) {
+            switch (ref.kind) {
+                case "table":
+                    dependencies.add(stableId.table(ref.schema, ref.name));
+                    break;
+                case "view":
+                    dependencies.add(stableId.view(ref.schema, ref.name));
+                    break;
+                case "materialized_view":
+                    dependencies.add(stableId.materializedView(ref.schema, ref.name));
+                    break;
+                case "foreign_table":
+                    dependencies.add(stableId.foreignTable(ref.schema, ref.name));
+                    break;
+            }
+        }
+        for (const ref of this.policy.referenced_procedures) {
+            dependencies.add(stableId.procedure(ref.schema, ref.name, ref.argument_types.join(",")));
+        }
         return Array.from(dependencies);
     }
     serialize(_options) {

package/dist/core/objects/rls-policy/rls-policy.model.d.ts

@@ -1,6 +1,23 @@
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+declare const rlsPolicyReferencedRelationSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        foreign_table: "foreign_table";
+        materialized_view: "materialized_view";
+        table: "table";
+        view: "view";
+    }>;
+    schema: z.ZodString;
+    name: z.ZodString;
+}, z.z.core.$strip>;
+export type RlsPolicyReferencedRelation = z.infer<typeof rlsPolicyReferencedRelationSchema>;
+declare const rlsPolicyReferencedProcedureSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    argument_types: z.ZodArray<z.ZodString>;
+}, z.z.core.$strip>;
+export type RlsPolicyReferencedProcedure = z.infer<typeof rlsPolicyReferencedProcedureSchema>;
 declare const rlsPolicyPropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
@@ -18,6 +35,21 @@ declare const rlsPolicyPropsSchema: z.ZodObject<{
     with_check_expression: z.ZodNullable<z.ZodString>;
     owner: z.ZodString;
     comment: z.ZodNullable<z.ZodString>;
+    referenced_relations: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            foreign_table: "foreign_table";
+            materialized_view: "materialized_view";
+            table: "table";
+            view: "view";
+        }>;
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.z.core.$strip>>;
+    referenced_procedures: z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+        argument_types: z.ZodArray<z.ZodString>;
+    }, z.z.core.$strip>>;
 }, z.z.core.$strip>;
 export type RlsPolicyProps = z.infer<typeof rlsPolicyPropsSchema>;
 export declare class RlsPolicy extends BasePgModel {
@@ -31,6 +63,23 @@ export declare class RlsPolicy extends BasePgModel {
     readonly with_check_expression: RlsPolicyProps["with_check_expression"];
     readonly owner: RlsPolicyProps["owner"];
     readonly comment: RlsPolicyProps["comment"];
+    /**
+     * Tables / views / materialized views / foreign tables that
+     * `using_expression` / `with_check_expression` reference, sourced from
+     * `pg_depend` (`recordDependencyOnExpr` at policy creation). Drives
+     * ordering dependencies in `CreateRlsPolicy.requires`. Intentionally
+     * excluded from `dataFields` — it's derived from the expression text
+     * and changes lockstep with it.
+     */
+    readonly referenced_relations: RlsPolicyProps["referenced_relations"];
+    /**
+     * Functions / procedures that `using_expression` / `with_check_expression`
+     * reference, sourced from `pg_depend` (refclassid = `pg_proc`). The
+     * argument-type signature comes straight from `pg_proc.proargtypes` via
+     * `format_type`, so it matches the signature the procedure extractor
+     * embeds in `stableId.procedure(...)`. Not part of `dataFields`.
+     */
+    readonly referenced_procedures: RlsPolicyProps["referenced_procedures"];
     constructor(props: RlsPolicyProps);
     get stableId(): `rlsPolicy:${string}`;
     get identityFields(): {

package/dist/core/objects/rls-policy/rls-policy.model.js

@@ -8,6 +8,22 @@ const RlsPolicyCommandSchema = z.enum([
     "d", // DELETE command
     "*", // ALL commands
 ]);
+const RlsPolicyReferencedRelationKindSchema = z.enum([
+    "table",
+    "view",
+    "materialized_view",
+    "foreign_table",
+]);
+const rlsPolicyReferencedRelationSchema = z.object({
+    kind: RlsPolicyReferencedRelationKindSchema,
+    schema: z.string(),
+    name: z.string(),
+});
+const rlsPolicyReferencedProcedureSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    argument_types: z.array(z.string()),
+});
 const rlsPolicyPropsSchema = z.object({
     schema: z.string(),
     name: z.string(),
@@ -19,6 +35,8 @@ const rlsPolicyPropsSchema = z.object({
     with_check_expression: z.string().nullable(),
     owner: z.string(),
     comment: z.string().nullable(),
+    referenced_relations: z.array(rlsPolicyReferencedRelationSchema),
+    referenced_procedures: z.array(rlsPolicyReferencedProcedureSchema),
 });
 export class RlsPolicy extends BasePgModel {
     schema;
@@ -31,6 +49,23 @@ export class RlsPolicy extends BasePgModel {
     with_check_expression;
     owner;
     comment;
+    /**
+     * Tables / views / materialized views / foreign tables that
+     * `using_expression` / `with_check_expression` reference, sourced from
+     * `pg_depend` (`recordDependencyOnExpr` at policy creation). Drives
+     * ordering dependencies in `CreateRlsPolicy.requires`. Intentionally
+     * excluded from `dataFields` — it's derived from the expression text
+     * and changes lockstep with it.
+     */
+    referenced_relations;
+    /**
+     * Functions / procedures that `using_expression` / `with_check_expression`
+     * reference, sourced from `pg_depend` (refclassid = `pg_proc`). The
+     * argument-type signature comes straight from `pg_proc.proargtypes` via
+     * `format_type`, so it matches the signature the procedure extractor
+     * embeds in `stableId.procedure(...)`. Not part of `dataFields`.
+     */
+    referenced_procedures;
     constructor(props) {
         super();
         // Identity fields
@@ -45,6 +80,9 @@ export class RlsPolicy extends BasePgModel {
         this.with_check_expression = props.with_check_expression;
         this.owner = props.owner;
         this.comment = props.comment;
+        // Derived metadata (not part of equality)
+        this.referenced_relations = props.referenced_relations;
+        this.referenced_procedures = props.referenced_procedures;
     }
     get stableId() {
         return `rlsPolicy:${this.schema}.${this.table_name}.${this.name}`;
@@ -88,6 +126,59 @@ extension_table_oids as (
     d.refclassid = 'pg_extension'::regclass
     and d.classid = 'pg_class'::regclass
     and d.deptype = 'e'
+),
+policy_relation_deps as (
+  -- Relations referenced inside polqual / polwithcheck. PostgreSQL records
+  -- these via recordDependencyOnExpr(..., DEPENDENCY_NORMAL = 'n') at
+  -- CREATE POLICY time, so pg_depend is authoritative and we don't need to
+  -- re-parse the expression text. Covers regular tables, partitioned
+  -- tables, views, materialized views, and foreign tables — any relation
+  -- kind the policy can reference in a subquery.
+  select distinct
+    d.objid                 as policy_oid,
+    case ref_c.relkind
+      when 'r' then 'table'
+      when 'p' then 'table'
+      when 'v' then 'view'
+      when 'm' then 'materialized_view'
+      when 'f' then 'foreign_table'
+    end                     as ref_kind,
+    ref_ns.nspname          as ref_schema,
+    ref_c.relname           as ref_name
+  from
+    pg_depend d
+    join pg_policy p on p.oid = d.objid
+    join pg_class ref_c on ref_c.oid = d.refobjid
+    join pg_namespace ref_ns on ref_ns.oid = ref_c.relnamespace
+  where
+    d.classid = 'pg_policy'::regclass
+    and d.refclassid = 'pg_class'::regclass
+    and d.deptype = 'n'
+    and ref_c.relkind in ('r', 'p', 'v', 'm', 'f')
+    and d.refobjid <> p.polrelid
+),
+policy_procedure_deps as (
+  -- Functions / procedures referenced inside polqual / polwithcheck. Same
+  -- pg_depend mechanism as above, just refclassid = pg_proc. proargtypes
+  -- formatted via format_type(oid, null) matches the signature produced by
+  -- the procedure extractor (see procedure.model.ts), so stableId.procedure
+  -- on both sides of the diff lines up exactly.
+  select distinct
+    d.objid            as policy_oid,
+    ref_ns.nspname     as ref_schema,
+    ref_p.proname      as ref_name,
+    array(
+      select format_type(oid, null)
+      from unnest(ref_p.proargtypes) as oid
+    )                  as ref_argument_types
+  from
+    pg_depend d
+    join pg_proc ref_p on ref_p.oid = d.refobjid
+    join pg_namespace ref_ns on ref_ns.oid = ref_p.pronamespace
+  where
+    d.classid = 'pg_policy'::regclass
+    and d.refclassid = 'pg_proc'::regclass
+    and d.deptype = 'n'
 )
 select
   tc.relnamespace::regnamespace::text as schema,
@@ -107,7 +198,37 @@ select
   pg_get_expr(p.polqual, p.polrelid) as using_expression,
   pg_get_expr(p.polwithcheck, p.polrelid) as with_check_expression,
   tc.relowner::regrole::text as owner,
-  obj_description(p.oid, 'pg_policy') as comment
+  obj_description(p.oid, 'pg_policy') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'kind', prd.ref_kind,
+          'schema', prd.ref_schema,
+          'name', prd.ref_name
+        )
+        order by prd.ref_schema, prd.ref_name
+      )
+      from policy_relation_deps prd
+      where prd.policy_oid = p.oid
+    ),
+    '[]'
+  ) as referenced_relations,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'schema', ppd.ref_schema,
+          'name', ppd.ref_name,
+          'argument_types', ppd.ref_argument_types
+        )
+        order by ppd.ref_schema, ppd.ref_name, ppd.ref_argument_types
+      )
+      from policy_procedure_deps ppd
+      where ppd.policy_oid = p.oid
+    ),
+    '[]'
+  ) as referenced_procedures
 from
   pg_catalog.pg_policy p
   inner join pg_catalog.pg_class tc on tc.oid = p.polrelid

package/dist/core/objects/table/table.diff.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) !==

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

@@ -23,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>;
@@ -125,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>;
@@ -239,6 +241,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             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;
@@ -300,6 +303,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 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;

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

@@ -42,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(),
@@ -253,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),

package/dist/core/plan/sql-format/fixtures.js

@@ -294,6 +294,7 @@ const pkConstraint = {
     validated: true,
     is_local: true,
     no_inherit: false,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -324,6 +325,7 @@ const uniqueConstraint = {
     validated: true,
     is_local: true,
     no_inherit: false,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -353,6 +355,7 @@ const fkConstraint = {
     validated: true,
     is_local: true,
     no_inherit: false,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -382,6 +385,7 @@ const checkConstraint = {
     validated: true,
     is_local: true,
     no_inherit: true,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -692,6 +696,8 @@ const rlsPolicy = new RlsPolicy({
     with_check_expression: null,
     owner: "owner1",
     comment: "rls policy comment",
+    referenced_relations: [],
+    referenced_procedures: [],
 });
 const rlsPolicyRestrictive = new RlsPolicy({
     schema: "public",
@@ -704,6 +710,8 @@ const rlsPolicyRestrictive = new RlsPolicy({
     with_check_expression: "status <> 'locked'",
     owner: "owner1",
     comment: null,
+    referenced_relations: [],
+    referenced_procedures: [],
 });
 const index = new Index({
     schema: "public",

package/dist/core/post-diff-cycle-breaking.d.ts

@@ -8,6 +8,13 @@ import type { Change } from "./change.types.ts";
  * - If replace expansion added `DropTable(T)+CreateTable(T)`, targeted
  *   `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)` changes are
  *   redundant and create an unbreakable drop-phase cycle, so we elide them.
+ * - When the same `DropTable+CreateTable` pair is present, the expansion
+ *   also emits one `AlterTableAddConstraint` / `AlterTableValidateConstraint`
+ *   / `CreateCommentOnConstraint` per branch constraint, which may collide
+ *   with the same change already emitted by `diffTables()` (for example on a
+ *   shape flip or a new constraint). We dedupe these keeping only the last
+ *   occurrence so the expansion's emission survives and the diffTables
+ *   duplicate is removed.
  * - If two dropped tables reference each other via FK, we insert dedicated
  *   `AlterTableDropConstraint` changes and teach the paired `DropTable`
  *   changes not to claim those FK stable IDs.