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

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

@@ -1,10 +1,16 @@
 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 { buildCreateMaterializedViewChanges } from "./objects/materialized-view/materialized-view.diff.js";
 import { CreateProcedure } from "./objects/procedure/changes/procedure.create.js";
 import { DropProcedure } from "./objects/procedure/changes/procedure.drop.js";
-import { AlterTableAddConstraint, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
+import { CreateCommentOnRlsPolicy } from "./objects/rls-policy/changes/rls-policy.comment.js";
+import { CreateRlsPolicy } from "./objects/rls-policy/changes/rls-policy.create.js";
+import { DropRlsPolicy } from "./objects/rls-policy/changes/rls-policy.drop.js";
+import { AlterTableAddConstraint } from "./objects/table/changes/table.alter.js";
 import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
 import { CreateTable } from "./objects/table/changes/table.create.js";
 import { DropTable } from "./objects/table/changes/table.drop.js";
@@ -14,16 +20,11 @@ import { CreateEnum } from "./objects/type/enum/changes/enum.create.js";
 import { DropEnum } from "./objects/type/enum/changes/enum.drop.js";
 import { CreateRange } from "./objects/type/range/changes/range.create.js";
 import { DropRange } from "./objects/type/range/changes/range.drop.js";
+import { stableId } from "./objects/utils.js";
 import { CreateView } from "./objects/view/changes/view.create.js";
 import { DropView } from "./objects/view/changes/view.drop.js";
-/**
- * For objects we are replacing (drop + create), ensure that any dependents are also
- * replaced so that destructive drops succeed. Uses dependency edges from pg_depend
- * (already captured in Catalog.depends) plus change metadata (creates/drops/requires).
- *
- * New changes are appended; ordering is handled later by the sorter.
- */
-export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog, }) {
+import { buildCreateViewChanges } from "./objects/view/view.diff.js";
+export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog, diffContext, }) {
     const createdIds = new Set();
     const droppedIds = new Set();
     for (const change of changes) {
@@ -38,8 +39,62 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
             replaceRoots.add(id);
         }
     }
-    if (replaceRoots.size === 0) {
-        return changes;
+    const promotedRlsPolicyIds = new Set();
+    const additions = collectInvalidatedRlsPolicyReplacements({
+        changes,
+        mainCatalog,
+        branchCatalog,
+        createdIds,
+        droppedIds,
+        promotedRlsPolicyIds,
+    });
+    // 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);
+        }
+    }
+    // Drop-only objects (no matching create — typically a renamed-away table or
+    // type) are also expansion roots: anything in main that depends on them via
+    // pg_depend must drop before the parent does. Without this seed, a renamed
+    // table whose dependent view stays in the branch catalog (with an updated
+    // definition that no longer references the old name) would still try to
+    // run DROP TABLE old_name while old_name is referenced by the view, which
+    // PostgreSQL refuses without CASCADE. The walk below promotes the surviving
+    // dependent to DROP+CREATE so its drop is sequenced before the parent drop.
+    for (const id of droppedIds) {
+        if (createdIds.has(id))
+            continue;
+        if (replaceRoots.has(id))
+            continue;
+        // Only seed for object kinds that can have catalog dependents we know
+        // how to recreate via buildReplaceChanges.
+        if (id.startsWith("table:") ||
+            id.startsWith("view:") ||
+            id.startsWith("materializedView:") ||
+            id.startsWith("type:") ||
+            id.startsWith("domain:")) {
+            replaceRoots.add(id);
+        }
+    }
+    if (replaceRoots.size === 0 && additions.length === 0) {
+        return {
+            changes,
+            replacedTableIds: new Set(),
+        };
     }
     // Build referenced -> dependents adjacency from main catalog dependencies.
     const dependentsByReferenced = new Map();
@@ -51,16 +106,24 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
         }
         list.add(dep.dependent_stable_id);
     }
-    const additions = [];
     const visitedTargets = new Set();
     const visitedRefs = new Set(replaceRoots);
     const queue = [...replaceRoots];
+    // Tables being replaced by an expansion-added DropTable+CreateTable pair.
+    // Any pre-existing targeted AlterTable*(T) object-scope change is superseded
+    // by the replacement and must be removed to avoid contradictions (e.g. an
+    // AlterTableDropColumn on a table that is about to be dropped) and the
+    // associated drop-phase cycle with the catalog constraint→column edge.
+    const tablesReplacedByExpansion = new Set();
     while (queue.length > 0) {
         const refId = queue.shift();
         const dependents = dependentsByReferenced.get(refId);
         if (!dependents)
             continue;
         for (const dependentRaw of dependents) {
+            if (isOwnedSequenceColumnDependency(refId, dependentRaw, mainCatalog, branchCatalog)) {
+                continue;
+            }
             // Continue traversing the dependency graph from the raw dependent id.
             if (!visitedRefs.has(dependentRaw)) {
                 visitedRefs.add(dependentRaw);
@@ -94,10 +157,20 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
             const replacementChanges = buildReplaceChanges(resolved, {
                 addDrop,
                 addCreate,
+                diffContext,
             });
             if (!replacementChanges)
                 continue;
             additions.push(...replacementChanges);
+            if (resolved.kind === "rls_policy") {
+                promotedRlsPolicyIds.add(targetId);
+            }
+            // If we added a DropTable(T) for an existing table, mark T so any
+            // pre-existing object-scope AlterTable*(T) changes get dropped below —
+            // the DropTable+CreateTable pair supersedes all structural alterations.
+            if (resolved.kind === "table" && addDrop) {
+                tablesReplacedByExpansion.add(targetId);
+            }
             // Track new creates/drops so we don't duplicate work for downstream dependents.
             for (const change of replacementChanges) {
                 for (const id of change.creates ?? [])
@@ -108,9 +181,102 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
         }
     }
     if (additions.length === 0) {
+        return {
+            changes,
+            replacedTableIds: tablesReplacedByExpansion,
+        };
+    }
+    return {
+        changes: [
+            ...removeSupersededRlsPolicyAlters(changes, promotedRlsPolicyIds),
+            ...additions,
+        ],
+        replacedTableIds: tablesReplacedByExpansion,
+    };
+}
+function collectInvalidatedRlsPolicyReplacements({ changes, mainCatalog, branchCatalog, createdIds, droppedIds, promotedRlsPolicyIds, }) {
+    // In-place rewrites report stable ids through `invalidates`: the referenced
+    // object keeps its identity, but dependents bound to the old definition must
+    // be torn down first. RLS policy expressions are tracked in pg_depend, so use
+    // those catalog edges to promote only policies that depend on an invalidated
+    // id, without coupling this expansion pass to a concrete table-change class.
+    const invalidatedIds = new Set();
+    for (const change of changes) {
+        for (const invalidatedId of change.invalidates) {
+            invalidatedIds.add(invalidatedId);
+        }
+    }
+    if (invalidatedIds.size === 0)
+        return [];
+    const replacements = [];
+    for (const dep of mainCatalog.depends) {
+        if (!invalidatedIds.has(dep.referenced_stable_id))
+            continue;
+        const targetId = normalizeDependentId(dep.dependent_stable_id);
+        if (!targetId?.startsWith("rlsPolicy:"))
+            continue;
+        if (promotedRlsPolicyIds.has(targetId))
+            continue;
+        if (createdIds.has(targetId) && droppedIds.has(targetId))
+            continue;
+        const resolved = resolveObjectForStableId(targetId, mainCatalog, branchCatalog);
+        if (!resolved || resolved.kind !== "rls_policy")
+            continue;
+        const addDrop = !droppedIds.has(targetId);
+        const addCreate = !createdIds.has(targetId);
+        const replacementChanges = buildReplaceChanges(resolved, {
+            addDrop,
+            addCreate,
+        });
+        if (!replacementChanges)
+            continue;
+        replacements.push(...replacementChanges);
+        promotedRlsPolicyIds.add(targetId);
+        for (const change of replacementChanges) {
+            for (const id of change.creates ?? [])
+                createdIds.add(id);
+            for (const id of change.drops ?? [])
+                droppedIds.add(id);
+        }
+    }
+    return replacements;
+}
+function removeSupersededRlsPolicyAlters(changes, promotedRlsPolicyIds) {
+    if (promotedRlsPolicyIds.size === 0)
         return changes;
+    return changes.filter((change) => {
+        if (change.objectType !== "rls_policy" || change.operation !== "alter") {
+            return true;
+        }
+        return !promotedRlsPolicyIds.has(change.policy.stableId);
+    });
+}
+function isOwnedSequenceColumnDependency(referencedId, dependentId, mainCatalog, branchCatalog) {
+    // When a sequence replace root is still OWNED BY the same column, the
+    // sequence->column pg_depend edge is bookkeeping for ownership, not a signal
+    // that the whole owning table needs to be replaced. Skipping that edge keeps
+    // expandReplaceDependencies focused on recreating the sequence itself.
+    if (!referencedId.startsWith("sequence:") ||
+        !dependentId.startsWith("column:")) {
+        return false;
     }
-    return [...changes, ...additions];
+    const sequence = branchCatalog.sequences[referencedId] ??
+        mainCatalog.sequences[referencedId];
+    if (!sequence?.owned_by_schema ||
+        !sequence.owned_by_table ||
+        !sequence.owned_by_column) {
+        return false;
+    }
+    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;
@@ -158,11 +324,28 @@ 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];
         return main && branch ? { kind: "procedure", main, branch } : null;
     }
+    if (stableId.startsWith("rlsPolicy:")) {
+        const main = mainCatalog.rlsPolicies[stableId];
+        const branch = branchCatalog.rlsPolicies[stableId];
+        return main && branch ? { kind: "rls_policy", main, branch } : null;
+    }
     if (stableId.startsWith("domain:")) {
         const main = mainCatalog.domains[stableId];
         const branch = branchCatalog.domains[stableId];
@@ -192,7 +375,7 @@ function resolveObjectForStableId(stableId, mainCatalog, branchCatalog) {
     return null;
 }
 function buildReplaceChanges(resolved, options) {
-    const { addDrop, addCreate } = options;
+    const { addDrop, addCreate, diffContext } = options;
     if (!addDrop && !addCreate)
         return null;
     switch (resolved.kind) {
@@ -211,12 +394,6 @@ function buildReplaceChanges(resolved, options) {
                                     constraint,
                                 }),
                             ];
-                            if (!constraint.validated) {
-                                items.push(new AlterTableValidateConstraint({
-                                    table: resolved.branch,
-                                    constraint,
-                                }));
-                            }
                             if (constraint.comment !== null &&
                                 constraint.comment !== undefined) {
                                 items.push(new CreateCommentOnConstraint({
@@ -232,7 +409,9 @@ function buildReplaceChanges(resolved, options) {
         case "view":
             return [
                 ...(addDrop ? [new DropView({ view: resolved.main })] : []),
-                ...(addCreate ? [new CreateView({ view: resolved.branch })] : []),
+                ...(addCreate
+                    ? buildCreateViewReplacementChanges(resolved.branch, diffContext)
+                    : []),
             ];
         case "materialized_view":
             return [
@@ -240,7 +419,41 @@ function buildReplaceChanges(resolved, options) {
                     ? [new DropMaterializedView({ materializedView: resolved.main })]
                     : []),
                 ...(addCreate
-                    ? [new CreateMaterializedView({ materializedView: resolved.branch })]
+                    ? diffContext
+                        ? buildCreateMaterializedViewChanges(diffContext, resolved.branch)
+                        : [
+                            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":
@@ -250,6 +463,18 @@ function buildReplaceChanges(resolved, options) {
                     ? [new CreateProcedure({ procedure: resolved.branch })]
                     : []),
             ];
+        case "rls_policy":
+            return [
+                ...(addDrop ? [new DropRlsPolicy({ policy: resolved.main })] : []),
+                ...(addCreate
+                    ? [
+                        new CreateRlsPolicy({ policy: resolved.branch }),
+                        ...(resolved.branch.comment !== null
+                            ? [new CreateCommentOnRlsPolicy({ policy: resolved.branch })]
+                            : []),
+                    ]
+                    : []),
+            ];
         case "enum":
             return [
                 ...(addDrop ? [new DropEnum({ enum: resolved.main })] : []),
@@ -278,3 +503,11 @@ function buildReplaceChanges(resolved, options) {
             return null;
     }
 }
+function buildCreateViewReplacementChanges(view, diffContext) {
+    // Dependency-closure replacements synthesize a create without going through
+    // `diffViews`, so replay the same owner/comment/security-label/ACL metadata
+    // that a normal non-alterable view replacement would emit.
+    return diffContext
+        ? buildCreateViewChanges(diffContext, view)
+        : [new CreateView({ view })];
+}

package/dist/core/export/file-mapper.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Map changes to declarative schema file paths.
+ */
+import type { Change } from "../change.types.ts";
+import type { FilePath, Grouping, GroupingPattern } from "./types.ts";
+export declare function getFilePath(change: Change): FilePath;
+/** A compiled grouping pattern: pre-built RegExp + group name. */
+export interface CompiledPattern {
+    regex: RegExp;
+    name: string;
+}
+/** Result of compilePatterns: valid compiled patterns plus warnings for skipped/invalid regexes. */
+interface CompilePatternsResult {
+    compiled: CompiledPattern[];
+    warnings: string[];
+}
+/**
+ * Compile user-facing `GroupingPattern[]` into `CompiledPattern[]`.
+ * Strings are turned into `new RegExp(str)`. Invalid regex strings are skipped
+ * (no throw), so the returned `compiled` array may be shorter than the input.
+ * Any skipped patterns are reported in `warnings`.
+ */
+export declare function compilePatterns(patterns: GroupingPattern[]): CompilePatternsResult;
+/**
+ * Create a file mapper that applies regex-based grouping on top of the
+ * default `getFilePath` mapping.
+ *
+ * When no grouping config is provided (or it is undefined), the plain
+ * `getFilePath` function is returned unchanged.
+ */
+export declare function createFileMapper(grouping?: Grouping, onWarning?: (message: string) => void): (change: Change) => FilePath;
+/**
+ * Flatten a schema-scoped file path into one file per category.
+ *
+ * e.g. `schemas/partman/tables/template_public_events.sql`
+ *    → `schemas/partman/tables.sql`
+ *
+ * `schema.sql` is left unchanged (it is already flat).
+ */
+export declare function flattenSchema(filePath: FilePath): FilePath;
+/**
+ * Determine the group name for a change, or `null` if it should not be
+ * grouped.
+ *
+ * Resolution order:
+ *  1. Automatic partition detection -- resolve the parent table name.
+ *  2. Regex patterns -- first match wins (user controls priority by ordering).
+ *
+ * The resolved name from step 1 is fed through step 2 so that a partition
+ * parent name can itself be matched by a broader pattern (e.g. parent
+ * "kubernetes_resource_events" matches `/^kubernetes/`).
+ *
+ * If auto-detect resolved a parent but no pattern matched, the parent name
+ * is used as-is.
+ */
+export declare function resolveGroupName(change: Change, filePath: FilePath, patterns: CompiledPattern[], autoPartitions: boolean): string | null;
+/**
+ * Rewrite a `FilePath` according to the chosen grouping mode.
+ *
+ * - **single-file**: the filename becomes `{prefix}.sql` inside the original
+ *   category directory.
+ *   e.g. `schemas/public/tables/wal_verification_results_p20260107.sql`
+ *     → `schemas/public/tables/wal_verification_results.sql`
+ *
+ * - **subdirectory**: the file is moved to a prefix-named directory under the
+ *   schema root, with the category as the filename.
+ *   e.g. `schemas/public/tables/wal_verification_results_p20260107.sql`
+ *     → `schemas/public/wal_verification_results/tables.sql`
+ */
+export declare function applyGrouping(filePath: FilePath, prefix: string, mode: Grouping["mode"]): FilePath;
+export {};