@supabase/pg-delta 0.0.0 → 1.0.0-alpha.1

package/dist/cli/formatters/tree/tree.js

@@ -0,0 +1,161 @@
+/**
+ * Tree formatter for displaying plans hierarchically (compact mode).
+ */
+import chalk from "chalk";
+import { buildPlanTree } from "./tree-builder.js";
+import { renderTree } from "./tree-renderer.js";
+/**
+ * Format a plan as a tree structure (compact mode).
+ */
+export function formatTree(plan) {
+    const lines = [];
+    // Summary
+    const total = countTotalChanges(plan);
+    lines.push(chalk.bold(`📋 Migration Plan: ${total} change${total !== 1 ? "s" : ""}`));
+    const summary = buildSummaryLine(plan);
+    if (summary) {
+        lines.push("");
+        lines.push(summary);
+    }
+    lines.push("");
+    // Build generic tree structure and render it
+    const tree = buildPlanTree(plan);
+    const treeOutput = renderTree(tree);
+    lines.push(treeOutput);
+    // Legend
+    lines.push("");
+    lines.push(`${chalk.green("+")} create   ${chalk.yellow("~")} alter   ${chalk.red("-")} drop`);
+    return lines.join("\n");
+}
+function countTotalChanges(plan) {
+    const byType = {};
+    countFromHierarchy(plan, byType);
+    let total = 0;
+    for (const counts of Object.values(byType)) {
+        total += counts.create + counts.alter + counts.drop;
+    }
+    return total;
+}
+/**
+ * Build summary as a table showing counts by entity type and operation.
+ */
+function buildSummaryLine(plan) {
+    // Count by object type
+    const byType = {};
+    countFromHierarchy(plan, byType);
+    // Filter to only types with changes
+    const entries = Object.entries(byType).filter(([, counts]) => counts.create + counts.alter + counts.drop > 0);
+    if (entries.length === 0) {
+        return "";
+    }
+    // Calculate column widths
+    let maxNameWidth = 0;
+    let maxCreateWidth = 0;
+    let maxAlterWidth = 0;
+    let maxDropWidth = 0;
+    for (const [type, counts] of entries) {
+        const typeStr = type.replace(/_/g, "-");
+        maxNameWidth = Math.max(maxNameWidth, typeStr.length);
+        // For width calculation, use "1" instead of "0" since we'll show "-" for zeros
+        maxCreateWidth = Math.max(maxCreateWidth, counts.create > 0 ? counts.create.toString().length : 1);
+        maxAlterWidth = Math.max(maxAlterWidth, counts.alter > 0 ? counts.alter.toString().length : 1);
+        maxDropWidth = Math.max(maxDropWidth, counts.drop > 0 ? counts.drop.toString().length : 1);
+    }
+    // Ensure minimum widths for headers
+    maxNameWidth = Math.max(maxNameWidth, "Entity".length);
+    maxCreateWidth = Math.max(maxCreateWidth, "Create".length);
+    maxAlterWidth = Math.max(maxAlterWidth, "Alter".length);
+    maxDropWidth = Math.max(maxDropWidth, "Drop".length);
+    const lines = [];
+    // Header
+    lines.push(`${chalk.bold("Entity".padEnd(maxNameWidth))}  ${chalk.bold("Create".padStart(maxCreateWidth))}  ${chalk.bold("Alter".padStart(maxAlterWidth))}  ${chalk.bold("Drop".padStart(maxDropWidth))}`);
+    lines.push(`${chalk.dim("-".repeat(maxNameWidth))}  ${chalk.dim("-".repeat(maxCreateWidth))}  ${chalk.dim("-".repeat(maxAlterWidth))}  ${chalk.dim("-".repeat(maxDropWidth))}`);
+    // Rows
+    for (const [type, counts] of entries.sort(([a], [b]) => a.localeCompare(b))) {
+        const typeStr = type.replace(/_/g, "-");
+        // Format numbers: show "-" for 0, pad and colorize
+        const createDisplay = counts.create > 0 ? counts.create.toString() : "-";
+        const alterDisplay = counts.alter > 0 ? counts.alter.toString() : "-";
+        const dropDisplay = counts.drop > 0 ? counts.drop.toString() : "-";
+        const createStr = counts.create > 0
+            ? chalk.green(createDisplay.padStart(maxCreateWidth))
+            : chalk.dim(createDisplay.padStart(maxCreateWidth));
+        const alterStr = counts.alter > 0
+            ? chalk.yellow(alterDisplay.padStart(maxAlterWidth))
+            : chalk.dim(alterDisplay.padStart(maxAlterWidth));
+        const dropStr = counts.drop > 0
+            ? chalk.red(dropDisplay.padStart(maxDropWidth))
+            : chalk.dim(dropDisplay.padStart(maxDropWidth));
+        lines.push(`${typeStr.padEnd(maxNameWidth)}  ${createStr}  ${alterStr}  ${dropStr}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Count changes by type from hierarchy.
+ */
+function countFromHierarchy(plan, byType) {
+    const addCounts = (target, source) => {
+        target.create += source.create;
+        target.alter += source.alter;
+        target.drop += source.drop;
+    };
+    function countGroup(group, type) {
+        if (!byType[type]) {
+            byType[type] = { create: 0, alter: 0, drop: 0 };
+        }
+        byType[type].create += group.create.length;
+        byType[type].alter += group.alter.length;
+        byType[type].drop += group.drop.length;
+    }
+    // Cluster
+    countGroup(plan.cluster.roles, "role");
+    countGroup(plan.cluster.extensions, "extension");
+    countGroup(plan.cluster.eventTriggers, "event-trigger");
+    countGroup(plan.cluster.publications, "publication");
+    countGroup(plan.cluster.subscriptions, "subscription");
+    // Schemas
+    for (const schema of Object.values(plan.schemas)) {
+        countGroup(schema.changes, "schema");
+        countGroup(schema.functions, "function");
+        countGroup(schema.procedures, "procedure");
+        countGroup(schema.aggregates, "aggregate");
+        countGroup(schema.sequences, "sequence");
+        countGroup(schema.collations, "collation");
+        // Tables
+        for (const table of Object.values(schema.tables)) {
+            const tableCounts = {
+                create: table.changes.create.length,
+                alter: table.changes.alter.length,
+                drop: table.changes.drop.length,
+            };
+            // Roll column counts into table totals (no separate column row)
+            addCounts(tableCounts, {
+                create: table.columns.create.length,
+                alter: table.columns.alter.length,
+                drop: table.columns.drop.length,
+            });
+            // Apply rolled-up counts to table totals
+            if (!byType.table) {
+                byType.table = { create: 0, alter: 0, drop: 0 };
+            }
+            addCounts(byType.table, tableCounts);
+            countGroup(table.indexes, "index");
+            countGroup(table.triggers, "trigger");
+            countGroup(table.rules, "rule");
+            countGroup(table.policies, "policy");
+        }
+        // Views
+        for (const view of Object.values(schema.views)) {
+            countGroup(view.changes, "view");
+        }
+        // Materialized views
+        for (const matview of Object.values(schema.materializedViews)) {
+            countGroup(matview.changes, "materialized-view");
+        }
+        // Types
+        countGroup(schema.types.enums, "enum");
+        countGroup(schema.types.composites, "composite-type");
+        countGroup(schema.types.ranges, "range");
+        countGroup(schema.types.domains, "domain");
+    }
+}

package/dist/cli/utils/integrations.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Utilities for loading integrations from files.
+ */
+import type { IntegrationDSL } from "../../core/integrations/integration-dsl.ts";
+/**
+ * Load an integration DSL from a file or core integration.
+ * If the path ends with .json, treats it as a JSON file path directly.
+ * Otherwise, tries to load from core integrations (TypeScript) first,
+ * then falls back to treating as a JSON file path.
+ *
+ * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
+ * @returns The loaded IntegrationDSL
+ */
+export declare function loadIntegrationDSL(nameOrPath: string): Promise<IntegrationDSL>;

package/dist/cli/utils/integrations.js

@@ -0,0 +1,44 @@
+/**
+ * Utilities for loading integrations from files.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFile } from "node:fs/promises";
+/**
+ * Load an integration DSL from a file or core integration.
+ * If the path ends with .json, treats it as a JSON file path directly.
+ * Otherwise, tries to load from core integrations (TypeScript) first,
+ * then falls back to treating as a JSON file path.
+ *
+ * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
+ * @returns The loaded IntegrationDSL
+ */
+export async function loadIntegrationDSL(nameOrPath) {
+    // If path ends with .json, treat it as a JSON file path directly
+    if (nameOrPath.endsWith(".json")) {
+        const content = await readFile(nameOrPath, "utf-8");
+        return JSON.parse(content);
+    }
+    // Try loading from core integrations (TypeScript) first
+    try {
+        const module = await import(__rewriteRelativeImportExtension(`../../core/integrations/${nameOrPath}.ts`));
+        // Core integrations export using the integration name directly (e.g., "supabase")
+        const integrationName = nameOrPath;
+        if (integrationName in module) {
+            return module[integrationName];
+        }
+        // If no matching export, fall through to JSON file loading
+    }
+    catch {
+        // Module not found or not a core integration, fall through to JSON file loading
+    }
+    // Fallback to treating as JSON file path
+    const content = await readFile(nameOrPath, "utf-8");
+    return JSON.parse(content);
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared utility functions for CLI commands.
+ */
+import type { CommandContext } from "@stricli/core";
+import type { Change } from "../core/change.types.ts";
+import type { DiffContext } from "../core/context.ts";
+import { type Plan } from "../core/plan/index.ts";
+type ApplyPlanResult = {
+    status: "invalid_plan";
+    message: string;
+} | {
+    status: "fingerprint_mismatch";
+    current: string;
+    expected: string;
+} | {
+    status: "already_applied";
+} | {
+    status: "applied";
+    statements: number;
+    warnings?: string[];
+} | {
+    status: "failed";
+    error: unknown;
+    script: string;
+};
+type PlanResult = {
+    plan: Plan;
+    sortedChanges: Change[];
+    ctx: DiffContext;
+};
+interface FormatPlanOptions {
+    disableColors?: boolean;
+    showUnsafeFlagSuggestion?: boolean;
+}
+/**
+ * Formats a plan result for display in various formats.
+ */
+export declare function formatPlanForDisplay(planResult: PlanResult, format: "tree" | "json" | "sql", options?: FormatPlanOptions): {
+    content: string;
+    label: string;
+};
+/**
+ * Validates plan risk and handles unsafe operations.
+ * Returns validation result with optional exit code.
+ */
+export declare function validatePlanRisk(plan: Plan, unsafe: boolean, context: CommandContext, options?: {
+    suppressWarning?: boolean;
+}): {
+    valid: boolean;
+    exitCode?: number;
+};
+/**
+ * Handles applyPlan results and writes appropriate output.
+ * Returns the exit code that should be set.
+ */
+export declare function handleApplyResult(result: ApplyPlanResult, context: CommandContext): {
+    exitCode: number;
+};
+/**
+ * Prompts user for confirmation using readline.
+ * Returns true for 'y'/'yes', false otherwise.
+ */
+export declare function promptConfirmation(question: string, context: CommandContext): Promise<boolean>;
+export {};

package/dist/cli/utils.js

@@ -0,0 +1,160 @@
+/**
+ * Shared utility functions for CLI commands.
+ */
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { groupChangesHierarchically } from "../core/plan/hierarchy.js";
+import { serializePlan } from "../core/plan/index.js";
+import { classifyChangesRisk } from "../core/plan/risk.js";
+import { formatSqlScript } from "../core/plan/statements.js";
+import { formatTree } from "./formatters/index.js";
+/**
+ * Formats a plan result for display in various formats.
+ */
+export function formatPlanForDisplay(planResult, format, options = {}) {
+    const { plan, sortedChanges, ctx } = planResult;
+    const risk = plan.risk ?? classifyChangesRisk(sortedChanges);
+    const planWithRisk = plan.risk ? plan : { ...plan, risk };
+    switch (format) {
+        case "sql": {
+            const content = [
+                `-- Risk: ${risk.level === "data_loss" ? `data-loss (${risk.statements.length})` : "safe"}`,
+                formatSqlScript(plan.statements),
+            ].join("\n");
+            return { content, label: "Migration script" };
+        }
+        case "json": {
+            const content = serializePlan(planWithRisk);
+            return { content, label: "Plan" };
+        }
+        default: {
+            const hierarchy = groupChangesHierarchically(ctx, sortedChanges);
+            const previousLevel = chalk.level;
+            if (options.disableColors) {
+                chalk.level = 0;
+            }
+            try {
+                let treeContent = formatTree(hierarchy);
+                if (risk.level === "data_loss") {
+                    const warningLines = [
+                        "",
+                        chalk.yellow("⚠ Data-loss operations detected:"),
+                        ...risk.statements.map((statement) => chalk.yellow(`- ${statement}`)),
+                    ];
+                    if (options.showUnsafeFlagSuggestion !== false) {
+                        warningLines.push(chalk.yellow("Use `--unsafe` to allow applying these operations."));
+                    }
+                    const treeLines = treeContent.split("\n");
+                    // Insert warning after the legend (at the end of the output)
+                    // Find the legend line which contains "create", "alter", and "drop"
+                    let insertIndex = treeLines.length;
+                    const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+                    // Search from the end backwards for the legend
+                    for (let i = treeLines.length - 1; i >= 0; i--) {
+                        const line = treeLines[i];
+                        const stripped = line.replace(ansiPattern, "").trim();
+                        // Legend format: "+ create   ~ alter   - drop" (or variations)
+                        if (stripped.includes("create") &&
+                            stripped.includes("alter") &&
+                            stripped.includes("drop")) {
+                            insertIndex = i + 1;
+                            break;
+                        }
+                    }
+                    // Fallback: if legend not found, append at the end
+                    if (insertIndex === treeLines.length) {
+                        insertIndex = treeLines.length;
+                    }
+                    treeLines.splice(insertIndex, 0, ...warningLines);
+                    treeContent = treeLines.join("\n");
+                }
+                // add newline for nicer stdout when in tree mode
+                if (!treeContent.endsWith("\n")) {
+                    treeContent = `${treeContent}\n`;
+                }
+                return { content: treeContent, label: "Human-readable plan" };
+            }
+            finally {
+                if (options.disableColors) {
+                    chalk.level = previousLevel;
+                }
+            }
+        }
+    }
+}
+/**
+ * Validates plan risk and handles unsafe operations.
+ * Returns validation result with optional exit code.
+ */
+export function validatePlanRisk(plan, unsafe, context, options) {
+    if (!unsafe) {
+        if (!plan.risk) {
+            context.process.stderr.write("Plan is missing risk metadata. Regenerate the plan with the current pgdelta or re-run with --unsafe to apply anyway.\n");
+            return { valid: false, exitCode: 1 };
+        }
+        if (plan.risk.level === "data_loss") {
+            if (!options?.suppressWarning) {
+                const warningLines = [
+                    chalk.yellow("⚠ Data-loss operations detected:"),
+                    ...plan.risk.statements.map((statement) => chalk.yellow(`- ${statement}`)),
+                    chalk.yellow("Use `--unsafe` to allow applying these operations."),
+                ];
+                context.process.stderr.write(`${warningLines.join("\n")}\n`);
+            }
+            return { valid: false, exitCode: 1 };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Handles applyPlan results and writes appropriate output.
+ * Returns the exit code that should be set.
+ */
+export function handleApplyResult(result, context) {
+    switch (result.status) {
+        case "invalid_plan":
+            context.process.stderr.write(`${result.message}\n`);
+            return { exitCode: 1 };
+        case "fingerprint_mismatch":
+            context.process.stderr.write("Target database does not match plan source fingerprint. Aborting.\n");
+            return { exitCode: 1 };
+        case "already_applied":
+            context.process.stdout.write("Plan already applied (target fingerprint matches desired state).\n");
+            return { exitCode: 0 };
+        case "failed": {
+            context.process.stderr.write(`Failed to apply changes: ${result.error instanceof Error ? result.error.message : String(result.error)}\n`);
+            context.process.stderr.write(`Migration script:\n${result.script}\n`);
+            return { exitCode: 1 };
+        }
+        case "applied": {
+            context.process.stdout.write(`Applying ${result.statements} changes to database...\n`);
+            context.process.stdout.write("Successfully applied all changes.\n");
+            if (result.warnings?.length) {
+                for (const warning of result.warnings) {
+                    context.process.stderr.write(`Warning: ${warning}\n`);
+                }
+            }
+            return { exitCode: 0 };
+        }
+    }
+}
+/**
+ * Prompts user for confirmation using readline.
+ * Returns true for 'y'/'yes', false otherwise.
+ */
+export function promptConfirmation(question, context) {
+    return new Promise((resolve) => {
+        // Access stdin/stdout from the process object
+        // Type assertion needed because CommandContext.process may not expose stdin in its type
+        const process = context.process;
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            resolve(normalized === "y" || normalized === "yes");
+        });
+    });
+}

package/dist/core/catalog.diff.d.ts

@@ -0,0 +1,5 @@
+import type { Catalog } from "./catalog.model.ts";
+import type { Change } from "./change.types.ts";
+export declare function diffCatalogs(main: Catalog, branch: Catalog, options?: {
+    role?: string;
+}): Change[];

package/dist/core/catalog.diff.js

@@ -0,0 +1,147 @@
+import debug from "debug";
+import { expandReplaceDependencies } from "./expand-replace-dependencies.js";
+const debugCatalog = debug("pg-delta:catalog");
+import { diffAggregates } from "./objects/aggregate/aggregate.diff.js";
+import { DefaultPrivilegeState } from "./objects/base.default-privileges.js";
+import { diffCollations } from "./objects/collation/collation.diff.js";
+import { diffDomains } from "./objects/domain/domain.diff.js";
+import { diffEventTriggers } from "./objects/event-trigger/event-trigger.diff.js";
+import { diffExtensions } from "./objects/extension/extension.diff.js";
+import { diffForeignDataWrappers } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.diff.js";
+import { diffForeignTables } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.diff.js";
+import { diffServers } from "./objects/foreign-data-wrapper/server/server.diff.js";
+import { diffUserMappings } from "./objects/foreign-data-wrapper/user-mapping/user-mapping.diff.js";
+import { diffIndexes } from "./objects/index/index.diff.js";
+import { diffMaterializedViews } from "./objects/materialized-view/materialized-view.diff.js";
+import { diffProcedures } from "./objects/procedure/procedure.diff.js";
+import { diffPublications } from "./objects/publication/publication.diff.js";
+import { diffRlsPolicies } from "./objects/rls-policy/rls-policy.diff.js";
+import { GrantRoleDefaultPrivileges, RevokeRoleDefaultPrivileges, } from "./objects/role/changes/role.privilege.js";
+import { diffRoles } from "./objects/role/role.diff.js";
+import { diffRules } from "./objects/rule/rule.diff.js";
+import { diffSchemas } from "./objects/schema/schema.diff.js";
+import { diffSequences } from "./objects/sequence/sequence.diff.js";
+import { diffSubscriptions } from "./objects/subscription/subscription.diff.js";
+import { diffTables } from "./objects/table/table.diff.js";
+import { diffTriggers } from "./objects/trigger/trigger.diff.js";
+import { diffCompositeTypes } from "./objects/type/composite-type/composite-type.diff.js";
+import { diffEnums } from "./objects/type/enum/enum.diff.js";
+import { diffRanges } from "./objects/type/range/range.diff.js";
+import { stringifyWithBigInt } from "./objects/utils.js";
+import { diffViews } from "./objects/view/view.diff.js";
+export function diffCatalogs(main, branch, options) {
+    const changes = [];
+    // Step 1: Diff roles first to get default privilege changes
+    const roleChanges = diffRoles({ version: main.version }, main.roles, branch.roles);
+    changes.push(...roleChanges);
+    // Step 2: Compute default privileges state from role changes
+    // This represents what defaults will be in effect after all ALTER DEFAULT PRIVILEGES
+    // Since ALTER DEFAULT PRIVILEGES runs before CREATE (via constraint spec),
+    // all created objects will use these final defaults.
+    const defaultPrivilegeState = new DefaultPrivilegeState(main.roles);
+    for (const change of roleChanges) {
+        if (change instanceof GrantRoleDefaultPrivileges) {
+            defaultPrivilegeState.applyGrant(change.role.name, change.objtype, change.inSchema, change.grantee, change.privileges);
+        }
+        else if (change instanceof RevokeRoleDefaultPrivileges) {
+            defaultPrivilegeState.applyRevoke(change.role.name, change.objtype, change.inSchema, change.grantee, change.privileges);
+        }
+    }
+    // Step 3: Create context with default privileges state for object diffing
+    // Use the specified role for both default privilege lookups and owner comparisons if provided,
+    // otherwise use the login role (main.currentUser). This ensures that when SET ROLE is used
+    // in the migration, both default privileges and owner comparisons match what will actually
+    // happen during execution (objects will be created with the effective role as owner).
+    const effectiveUser = options?.role ?? main.currentUser;
+    const diffContext = {
+        version: main.version,
+        currentUser: effectiveUser,
+        defaultPrivilegeState,
+        mainRoles: main.roles,
+    };
+    // Step 4: Diff all other objects with default privileges context
+    changes.push(...diffAggregates(diffContext, main.aggregates, branch.aggregates));
+    changes.push(...diffCollations({ currentUser: effectiveUser }, main.collations, branch.collations));
+    changes.push(...diffCompositeTypes(diffContext, main.compositeTypes, branch.compositeTypes));
+    changes.push(...diffDomains(diffContext, main.domains, branch.domains));
+    changes.push(...diffEnums(diffContext, main.enums, branch.enums));
+    changes.push(...diffExtensions(main.extensions, branch.extensions));
+    changes.push(...diffIndexes(main.indexes, branch.indexes, branch.indexableObjects));
+    changes.push(...diffMaterializedViews(diffContext, main.materializedViews, branch.materializedViews));
+    changes.push(...diffSubscriptions({ currentUser: effectiveUser }, main.subscriptions, branch.subscriptions));
+    changes.push(...diffPublications({ currentUser: effectiveUser }, main.publications, branch.publications));
+    changes.push(...diffProcedures(diffContext, main.procedures, branch.procedures));
+    changes.push(...diffRlsPolicies(main.rlsPolicies, branch.rlsPolicies));
+    changes.push(...diffSchemas(diffContext, main.schemas, branch.schemas));
+    changes.push(...diffSequences(diffContext, main.sequences, branch.sequences, branch.tables));
+    changes.push(...diffTables(diffContext, main.tables, branch.tables));
+    changes.push(...diffTriggers(main.triggers, branch.triggers, branch.indexableObjects));
+    changes.push(...diffEventTriggers({ currentUser: effectiveUser }, main.eventTriggers, branch.eventTriggers));
+    changes.push(...diffRules(main.rules, branch.rules));
+    changes.push(...diffRanges(diffContext, main.ranges, branch.ranges));
+    changes.push(...diffViews(diffContext, main.views, branch.views));
+    // Foreign Data Wrapper objects (in dependency order)
+    changes.push(...diffForeignDataWrappers(diffContext, main.foreignDataWrappers, branch.foreignDataWrappers));
+    changes.push(...diffServers(diffContext, main.servers, branch.servers));
+    changes.push(...diffUserMappings(main.userMappings, branch.userMappings));
+    changes.push(...diffForeignTables(diffContext, main.foreignTables, branch.foreignTables));
+    // Filter privilege REVOKEs for objects that are being dropped
+    // Avoid emitting redundant REVOKE statements for targets that will no longer exist.
+    const droppedObjectStableIds = new Set();
+    for (const change of changes) {
+        if (change.operation === "drop" && change.scope === "object") {
+            for (const dep of change.requires) {
+                droppedObjectStableIds.add(dep);
+            }
+        }
+    }
+    let filteredChanges = changes.filter((change) => {
+        if (change.operation === "alter" && change.scope === "privilege") {
+            switch (change.objectType) {
+                case "composite_type":
+                    return !droppedObjectStableIds.has(change.compositeType.stableId);
+                case "domain":
+                    return !droppedObjectStableIds.has(change.domain.stableId);
+                case "enum":
+                    return !droppedObjectStableIds.has(change.enum.stableId);
+                case "language":
+                    return !droppedObjectStableIds.has(change.language.stableId);
+                case "materialized_view":
+                    return !droppedObjectStableIds.has(change.materializedView.stableId);
+                case "aggregate":
+                    return !droppedObjectStableIds.has(change.aggregate.stableId);
+                case "procedure":
+                    return !droppedObjectStableIds.has(change.procedure.stableId);
+                case "range":
+                    return !droppedObjectStableIds.has(change.range.stableId);
+                case "schema":
+                    return !droppedObjectStableIds.has(change.schema.stableId);
+                case "sequence":
+                    return !droppedObjectStableIds.has(change.sequence.stableId);
+                case "table":
+                    return !droppedObjectStableIds.has(change.table.stableId);
+                case "view":
+                    return !droppedObjectStableIds.has(change.view.stableId);
+                case "foreign_data_wrapper":
+                    return !droppedObjectStableIds.has(change.foreignDataWrapper.stableId);
+                case "server":
+                    return !droppedObjectStableIds.has(change.server.stableId);
+                case "foreign_table":
+                    return !droppedObjectStableIds.has(change.foreignTable.stableId);
+                default: {
+                    // exhaustiveness check
+                    const _exhaustive = change;
+                    return _exhaustive;
+                }
+            }
+        }
+        return true;
+    });
+    filteredChanges = expandReplaceDependencies({
+        changes: filteredChanges,
+        mainCatalog: main,
+        branchCatalog: branch,
+    });
+    debugCatalog("changes catalog diff: %O", stringifyWithBigInt(filteredChanges, 2));
+    return filteredChanges;
+}