@supabase/pg-delta 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/core/objects/foreign-data-wrapper/user-mapping/changes/user-mapping.alter.js

@@ -1,4 +1,5 @@
 import { quoteLiteral } from "../../../base.change.js";
+import { redactOptionValue } from "../../sensitive-options.js";
 import { AlterUserMappingChange } from "./user-mapping.base.js";
 /**
  * ALTER USER MAPPING ... OPTIONS ( ADD | SET | DROP ... )
@@ -22,7 +23,9 @@ export class AlterUserMappingSetOptions extends AlterUserMappingChange {
                 optionParts.push(`DROP ${opt.option}`);
             }
             else {
-                const value = opt.value !== undefined ? quoteLiteral(opt.value) : "''";
+                const value = opt.value !== undefined
+                    ? quoteLiteral(redactOptionValue(opt.option, opt.value))
+                    : "''";
                 optionParts.push(`${opt.action} ${opt.option} ${value}`);
             }
         }

package/dist/core/objects/foreign-data-wrapper/user-mapping/changes/user-mapping.create.js

@@ -1,5 +1,6 @@
 import { quoteLiteral } from "../../../base.change.js";
 import { stableId } from "../../../utils.js";
+import { redactOptionValue } from "../../sensitive-options.js";
 import { CreateUserMappingChange } from "./user-mapping.base.js";
 /**
  * Create a user mapping.
@@ -39,9 +40,11 @@ export class CreateUserMapping extends CreateUserMappingChange {
         if (this.userMapping.options && this.userMapping.options.length > 0) {
             const optionPairs = [];
             for (let i = 0; i < this.userMapping.options.length; i += 2) {
-                if (i + 1 < this.userMapping.options.length) {
-                    optionPairs.push(`${this.userMapping.options[i]} ${quoteLiteral(this.userMapping.options[i + 1])}`);
-                }
+                const key = this.userMapping.options[i];
+                const value = this.userMapping.options[i + 1];
+                if (key === undefined || value === undefined)
+                    continue;
+                optionPairs.push(`${key} ${quoteLiteral(redactOptionValue(key, value))}`);
             }
             if (optionPairs.length > 0) {
                 parts.push(`OPTIONS (${optionPairs.join(", ")})`);

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.d.ts

@@ -32,5 +32,15 @@ export declare class UserMapping extends BasePgModel {
         options: string[] | null;
     };
 }
+/**
+ * Extract `pg_user_mapping` rows into `UserMapping` models.
+ *
+ * The returned models carry option values **verbatim** from
+ * `pg_user_mapping.umoptions`, which means cleartext secrets like
+ * `password` are present in memory. Always route through
+ * `extractCatalog` (which calls `normalizeCatalog`) before emitting
+ * options to any output channel — see CLI-1467 and
+ * `packages/pg-delta/src/core/objects/foreign-data-wrapper/sensitive-options.ts`.
+ */
 export declare function extractUserMappings(pool: Pool): Promise<UserMapping[]>;
 export {};

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.js

@@ -44,6 +44,16 @@ export class UserMapping extends BasePgModel {
         };
     }
 }
+/**
+ * Extract `pg_user_mapping` rows into `UserMapping` models.
+ *
+ * The returned models carry option values **verbatim** from
+ * `pg_user_mapping.umoptions`, which means cleartext secrets like
+ * `password` are present in memory. Always route through
+ * `extractCatalog` (which calls `normalizeCatalog`) before emitting
+ * options to any output channel — see CLI-1467 and
+ * `packages/pg-delta/src/core/objects/foreign-data-wrapper/sensitive-options.ts`.
+ */
 export async function extractUserMappings(pool) {
     const { rows: mappingRows } = await pool.query(sql `
       select

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

@@ -3,9 +3,9 @@ import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 declare const rlsPolicyReferencedRelationSchema: z.ZodObject<{
     kind: z.ZodEnum<{
+        table: "table";
         foreign_table: "foreign_table";
         materialized_view: "materialized_view";
-        table: "table";
         view: "view";
     }>;
     schema: z.ZodString;
@@ -37,9 +37,9 @@ declare const rlsPolicyPropsSchema: z.ZodObject<{
     comment: z.ZodNullable<z.ZodString>;
     referenced_relations: z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
+            table: "table";
             foreign_table: "foreign_table";
             materialized_view: "materialized_view";
-            table: "table";
             view: "view";
         }>;
         schema: z.ZodString;

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

@@ -292,8 +292,13 @@ select
           '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,

package/dist/core/post-diff-normalization.d.ts

@@ -15,6 +15,13 @@ import type { Table } from "./objects/table/table.model.ts";
  *   `DropTable(T) + CreateTable(T)` pair. Without this, the apply phase
  *   would try to drop a column that no longer exists in the freshly
  *   recreated table.
+ * - Prunes `DropSequence(S)` changes when `S` is `OWNED BY` a column on a
+ *   table promoted to `DropTable + CreateTable` by the expander. The
+ *   `DROP TABLE` cascade drops the sequence at apply time; emitting an
+ *   explicit `DROP SEQUENCE` in the same drop phase both duplicates the
+ *   cascade and forms an unbreakable `DropSequence ↔ DropTable` cycle on
+ *   the bidirectional pg_depend edges between the sequence and the
+ *   owning column.
  * - Dedupes duplicate `AlterTableAddConstraint` /
  *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
  *   produced when `diffTables()` and `expandReplaceDependencies()` both

package/dist/core/post-diff-normalization.js

@@ -1,5 +1,6 @@
 import { CreateIndex } from "./objects/index/changes/index.create.js";
 import { DropIndex } from "./objects/index/changes/index.drop.js";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.js";
 import { AlterTableAddConstraint, AlterTableDropColumn, AlterTableDropConstraint, AlterTableSetReplicaIdentity, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
 import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
 import { stableId } from "./objects/utils.js";
@@ -7,11 +8,32 @@ function constraintStableId(table, constraintName) {
     return stableId.constraint(table.schema, table.name, constraintName);
 }
 function isSupersededByTableReplacement(change, replacedTableIds) {
-    if (!(change instanceof AlterTableDropColumn) &&
-        !(change instanceof AlterTableDropConstraint)) {
-        return false;
+    if (change instanceof AlterTableDropColumn ||
+        change instanceof AlterTableDropConstraint) {
+        return replacedTableIds.has(change.table.stableId);
     }
-    return replacedTableIds.has(change.table.stableId);
+    // `DropSequence(S)` is superseded when S is OWNED BY a column on a table
+    // that `expandReplaceDependencies` has promoted to `DropTable + CreateTable`
+    // in the same plan. PostgreSQL cascade-drops the OWNED BY sequence as part
+    // of the DROP TABLE, so the explicit DROP SEQUENCE is redundant and — more
+    // importantly — closes an unbreakable `DropSequence ↔ DropTable` cycle in
+    // the drop phase via the bidirectional pg_depend edges between the
+    // sequence and its owning column (`column → sequence` for the DEFAULT
+    // nextval reference, `sequence → column` for the OWNED BY auto-dependency).
+    // The alpha.15 short-circuit in `diffSequences.dropped` only suppresses
+    // `DropSequence` when the owning table itself is gone from `branchTables`;
+    // here the table survives in branch and the replacement is added later by
+    // the expander, so this whole-plan rewrite has to happen post-diff.
+    if (change instanceof DropSequence) {
+        if (!change.sequence.owned_by_schema ||
+            !change.sequence.owned_by_table ||
+            !change.sequence.owned_by_column) {
+            return false;
+        }
+        const ownedByTableId = stableId.table(change.sequence.owned_by_schema, change.sequence.owned_by_table);
+        return replacedTableIds.has(ownedByTableId);
+    }
+    return false;
 }
 /**
  * Drop earlier duplicates of `AlterTableAddConstraint` /
@@ -179,6 +201,13 @@ function restoreReplicaIdentityAfterIndexReplace(changes, branchTables) {
  *   `DropTable(T) + CreateTable(T)` pair. Without this, the apply phase
  *   would try to drop a column that no longer exists in the freshly
  *   recreated table.
+ * - Prunes `DropSequence(S)` changes when `S` is `OWNED BY` a column on a
+ *   table promoted to `DropTable + CreateTable` by the expander. The
+ *   `DROP TABLE` cascade drops the sequence at apply time; emitting an
+ *   explicit `DROP SEQUENCE` in the same drop phase both duplicates the
+ *   cascade and forms an unbreakable `DropSequence ↔ DropTable` cycle on
+ *   the bidirectional pg_depend edges between the sequence and the
+ *   owning column.
  * - Dedupes duplicate `AlterTableAddConstraint` /
  *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
  *   produced when `diffTables()` and `expandReplaceDependencies()` both

package/dist/core/sort/cycle-breakers.js

@@ -66,6 +66,32 @@ export function tryBreakCycleByChangeInjection(cycleNodeIndexes, phaseChanges) {
     const pubColBroken = tryBreakPublicationColumnCycle(cycleNodeIndexes, phaseChanges);
     if (pubColBroken)
         return pubColBroken;
+    // ─── Branch C: Publication ↔ dropped FK chain ↔ constraint drop ──────
+    // Triggered when publication membership is being removed for tables in
+    // the same drop phase as a FK chain, and the chain ends at a separately
+    // emitted `AlterTableDropConstraint` on a table that is also being
+    // removed from the publication.
+    //
+    // Example (4-change cycle):
+    //   AlterPublicationDropTables(p, [labs, posts, post_attachments])
+    //   DropTable(post_attachments)
+    //   DropTable(posts)
+    //   AlterTableDropConstraint(labs.unique_lab_id)
+    //
+    // Cycle:
+    //   publication:p → table:post_attachments
+    //   post_attachments.post_id_fkey → column:posts.id
+    //   posts.lab_id_fkey → constraint:labs.unique_lab_id
+    //   constraint:labs.unique_lab_id → table:labs
+    //
+    // Fix: inject explicit FK drops for the FK constraints claimed by the
+    // DropTables in the cycle, including FKs that point at the terminal
+    // dropped constraint. The publication and terminal constraint changes
+    // stay unchanged; only the intermediate FK ownership is reassigned from
+    // DropTable to dedicated AlterTableDropConstraint changes.
+    const pubFkConstraintBroken = tryBreakPublicationFkConstraintDropCycle(cycleNodeIndexes, phaseChanges);
+    if (pubFkConstraintBroken)
+        return pubFkConstraintBroken;
     // No known pattern. Returning null lets sortPhaseChanges throw the
     // formatted CycleError with full diagnostic — better a clear bug
     // report than silently shipping a broken plan.
@@ -90,6 +116,19 @@ function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
         cycleDropTables.push(change);
     }
     const cycleTableIds = new Set(cycleDropTables.map((change) => change.table.stableId));
+    return injectFkConstraintDropsForDropTables({
+        phaseChanges,
+        dropTables: cycleDropTables,
+        shouldInject: (fk, tableId) => isCrossCycleFkConstraint(fk, tableId, cycleTableIds),
+    });
+}
+/**
+ * Shared FK-drop injection used by Branch A and Branch C. The caller owns
+ * the cycle-specific matcher; this helper only handles the mechanical
+ * rewrite: add dedicated `AlterTableDropConstraint` changes and rebuild
+ * affected `DropTable`s with updated `externallyDroppedConstraints`.
+ */
+function injectFkConstraintDropsForDropTables({ phaseChanges, dropTables, shouldInject, }) {
     // For each DropTable in the cycle, find every FK whose referenced table
     // is also in the cycle. Each such FK becomes one injected
     // `AlterTableDropConstraint` and one entry on the source table's
@@ -100,11 +139,13 @@ function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
     const injectedDropsByTableId = new Map();
     const updatedExternalsByTableId = new Map();
     let didMutate = false;
-    for (const dropTable of cycleDropTables) {
+    for (const dropTable of dropTables) {
         const tableId = dropTable.table.stableId;
         const existingExternals = new Set(dropTable.externallyDroppedConstraints);
         let tableMutated = false;
-        for (const fk of iterCrossCycleFkConstraints(dropTable.table.constraints, tableId, cycleTableIds)) {
+        for (const fk of iterFkConstraints(dropTable.table.constraints)) {
+            if (!shouldInject(fk, tableId))
+                continue;
             // Skip if a same-table `AlterTableDropConstraint` is already in the
             // change list — could happen if a previous breaker iteration
             // injected one, or the diff layer emitted one explicitly.
@@ -159,31 +200,37 @@ function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
     return rewritten;
 }
 /**
- * Yield FK constraints on `constraints` whose referenced table is also a
- * member of the cycle (i.e. an FK strictly between two cycle DropTables).
+ * Yield FK constraints on `constraints`.
  *
- * Self-referencing FKs are skipped — they create a self-loop in the
- * dependency graph which the existing sort-phase handler resolves on its
- * own; injecting an `AlterTableDropConstraint` for a self-FK would just
- * add noise.
+ * Partition clones are skipped because PostgreSQL drops them when the
+ * parent constraint is dropped.
  */
-function* iterCrossCycleFkConstraints(constraints, ownTableId, cycleTableIds) {
+function* iterFkConstraints(constraints) {
     for (const constraint of constraints) {
         if (constraint.constraint_type !== "f")
             continue;
         if (constraint.is_partition_clone)
             continue;
-        if (!constraint.foreign_key_schema || !constraint.foreign_key_table) {
-            continue;
-        }
-        const referencedId = stableId.table(constraint.foreign_key_schema, constraint.foreign_key_table);
-        if (referencedId === ownTableId)
-            continue;
-        if (!cycleTableIds.has(referencedId))
-            continue;
         yield constraint;
     }
 }
+/**
+ * True when `constraint` references another DropTable in the cycle.
+ *
+ * Self-referencing FKs are skipped — they create a self-loop in the
+ * dependency graph which the existing sort-phase handler resolves on its
+ * own; injecting an `AlterTableDropConstraint` for a self-FK would just
+ * add noise.
+ */
+function isCrossCycleFkConstraint(constraint, ownTableId, cycleTableIds) {
+    if (!constraint.foreign_key_schema || !constraint.foreign_key_table) {
+        return false;
+    }
+    const referencedId = stableId.table(constraint.foreign_key_schema, constraint.foreign_key_table);
+    if (referencedId === ownTableId)
+        return false;
+    return cycleTableIds.has(referencedId);
+}
 /**
  * True iff `phaseChanges` already contains an explicit
  * `AlterTableDropConstraint(table, constraint)` for the given pair —
@@ -267,3 +314,78 @@ function tryBreakPublicationColumnCycle(cycleNodeIndexes, phaseChanges) {
     });
     return rewritten;
 }
+/**
+ * Branch C worker — break a publication membership removal cycle where
+ * dropped tables form a FK chain ending at a separately dropped referenced
+ * constraint.
+ */
+function tryBreakPublicationFkConstraintDropCycle(cycleNodeIndexes, phaseChanges) {
+    let pubChange = null;
+    let terminalConstraintDrop = null;
+    const dropTables = [];
+    for (const nodeIndex of cycleNodeIndexes) {
+        const change = phaseChanges[nodeIndex];
+        if (change instanceof AlterPublicationDropTables) {
+            if (pubChange !== null)
+                return null;
+            pubChange = change;
+        }
+        else if (change instanceof AlterTableDropConstraint) {
+            if (terminalConstraintDrop !== null)
+                return null;
+            terminalConstraintDrop = change;
+        }
+        else if (change instanceof DropTable) {
+            dropTables.push(change);
+        }
+        else {
+            return null;
+        }
+    }
+    if (pubChange === null ||
+        terminalConstraintDrop === null ||
+        dropTables.length === 0) {
+        return null;
+    }
+    const publicationTableIds = new Set(pubChange.tables.map((table) => stableId.table(table.schema, table.name)));
+    if (!publicationTableIds.has(terminalConstraintDrop.table.stableId)) {
+        return null;
+    }
+    for (const dropTable of dropTables) {
+        if (!publicationTableIds.has(dropTable.table.stableId))
+            return null;
+    }
+    const cycleDropTableIds = new Set(dropTables.map((change) => change.table.stableId));
+    let hasFkToTerminalConstraint = false;
+    for (const dropTable of dropTables) {
+        for (const fk of iterFkConstraints(dropTable.table.constraints)) {
+            if (fkReferencesConstraint(fk, terminalConstraintDrop)) {
+                hasFkToTerminalConstraint = true;
+                break;
+            }
+        }
+        if (hasFkToTerminalConstraint)
+            break;
+    }
+    if (!hasFkToTerminalConstraint)
+        return null;
+    return injectFkConstraintDropsForDropTables({
+        phaseChanges,
+        dropTables,
+        shouldInject: (fk, tableId) => isCrossCycleFkConstraint(fk, tableId, cycleDropTableIds) ||
+            fkReferencesConstraint(fk, terminalConstraintDrop),
+    });
+}
+function fkReferencesConstraint(fk, constraintDrop) {
+    if (fk.foreign_key_schema !== constraintDrop.table.schema ||
+        fk.foreign_key_table !== constraintDrop.table.name ||
+        fk.foreign_key_columns === null) {
+        return false;
+    }
+    return sameOrderedStrings(fk.foreign_key_columns, constraintDrop.constraint.key_columns);
+}
+function sameOrderedStrings(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((value, index) => value === right[index]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.23",
+  "version": "1.0.0-alpha.25",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/core/catalog.model.ts

@@ -22,12 +22,13 @@ import {
 } from "./objects/extension/extension.model.ts";
 import {
   extractForeignDataWrappers,
-  type ForeignDataWrapper,
+  ForeignDataWrapper,
 } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.ts";
 import {
   extractForeignTables,
-  type ForeignTable,
+  ForeignTable,
 } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts";
+import { redactSensitiveOptionPairs } from "./objects/foreign-data-wrapper/sensitive-options.ts";
 import {
   extractServers,
   Server,
@@ -421,29 +422,56 @@ function listToRecord<T extends BasePgModel>(list: T[]) {
 }
 
 function normalizeCatalog(catalog: Catalog): Catalog {
+  const foreignDataWrappers = mapRecord(
+    catalog.foreignDataWrappers,
+    (fdw) =>
+      new ForeignDataWrapper({
+        name: fdw.name,
+        owner: fdw.owner,
+        handler: fdw.handler,
+        validator: fdw.validator,
+        options: redactSensitiveOptionPairs(fdw.options),
+        comment: fdw.comment,
+        privileges: fdw.privileges,
+      }),
+  );
+
   const servers = mapRecord(catalog.servers, (server) => {
-    const maskedOptions = maskOptions(server.options);
     return new Server({
       name: server.name,
       owner: server.owner,
       foreign_data_wrapper: server.foreign_data_wrapper,
       type: server.type,
       version: server.version,
-      options: maskedOptions,
+      options: redactSensitiveOptionPairs(server.options),
       comment: server.comment,
       privileges: server.privileges,
     });
   });
 
   const userMappings = mapRecord(catalog.userMappings, (mapping) => {
-    const maskedOptions = maskOptions(mapping.options);
     return new UserMapping({
       user: mapping.user,
       server: mapping.server,
-      options: maskedOptions,
+      options: redactSensitiveOptionPairs(mapping.options),
     });
   });
 
+  const foreignTables = mapRecord(
+    catalog.foreignTables,
+    (foreignTable) =>
+      new ForeignTable({
+        schema: foreignTable.schema,
+        name: foreignTable.name,
+        owner: foreignTable.owner,
+        server: foreignTable.server,
+        columns: foreignTable.columns,
+        options: redactSensitiveOptionPairs(foreignTable.options),
+        comment: foreignTable.comment,
+        privileges: foreignTable.privileges,
+      }),
+  );
+
   const subscriptions = mapRecord(catalog.subscriptions, (subscription) => {
     return new Subscription({
       name: subscription.name,
@@ -490,10 +518,10 @@ function normalizeCatalog(catalog: Catalog): Catalog {
     rules: catalog.rules,
     ranges: catalog.ranges,
     views: catalog.views,
-    foreignDataWrappers: catalog.foreignDataWrappers,
+    foreignDataWrappers,
     servers,
     userMappings,
-    foreignTables: catalog.foreignTables,
+    foreignTables,
     depends: catalog.depends,
     indexableObjects: catalog.indexableObjects,
     version: catalog.version,
@@ -501,18 +529,6 @@ function normalizeCatalog(catalog: Catalog): Catalog {
   });
 }
 
-function maskOptions(options: string[] | null): string[] | null {
-  if (!options || options.length === 0) return options;
-  const masked: string[] = [];
-  for (let i = 0; i < options.length; i += 2) {
-    const key = options[i];
-    const value = options[i + 1];
-    if (key === undefined || value === undefined) continue;
-    masked.push(key, `__OPTION_${key.toUpperCase()}__`);
-  }
-  return masked.length > 0 ? masked : null;
-}
-
 function mapRecord<TValue, TResult>(
   record: Record<string, TValue>,
   mapper: (value: TValue) => TResult,