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

package/dist/core/catalog-export/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Catalog export – programmatic API for extracting a database catalog
+ * and serializing it to a JSON snapshot.
+ *
+ * Use this subpath when you only need catalog export (e.g. Supabase CLI
+ * edge-runtime templates) without pulling in the full pg-delta API.
+ */
+export { Catalog, createEmptyCatalog, extractCatalog, } from "../catalog.model.ts";
+export type { CatalogSnapshot } from "../catalog.snapshot.ts";
+export { deserializeCatalog, serializeCatalog, stringifyCatalogSnapshot, } from "../catalog.snapshot.ts";
+export { createManagedPool } from "../postgres-config.ts";

package/dist/core/catalog-export/index.js

@@ -0,0 +1,10 @@
+/**
+ * Catalog export – programmatic API for extracting a database catalog
+ * and serializing it to a JSON snapshot.
+ *
+ * Use this subpath when you only need catalog export (e.g. Supabase CLI
+ * edge-runtime templates) without pulling in the full pg-delta API.
+ */
+export { Catalog, createEmptyCatalog, extractCatalog, } from "../catalog.model.js";
+export { deserializeCatalog, serializeCatalog, stringifyCatalogSnapshot, } from "../catalog.snapshot.js";
+export { createManagedPool } from "../postgres-config.js";

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

@@ -2,4 +2,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;
+    skipDefaultPrivilegeSubtraction?: boolean;
 }): Change[];

package/dist/core/catalog.diff.js

@@ -1,5 +1,6 @@
 import debug from "debug";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.js";
+import { normalizePostDiffChanges } from "./post-diff-normalization.js";
 const debugCatalog = debug("pg-delta:catalog");
 import { diffAggregates } from "./objects/aggregate/aggregate.diff.js";
 import { DefaultPrivilegeState } from "./objects/base.default-privileges.js";
@@ -29,6 +30,48 @@ 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";
+/**
+ * Get the stableId of the target object for a privilege change.
+ * Used to filter out redundant REVOKE statements for dropped objects.
+ */
+function getPrivilegeTargetStableId(change) {
+    switch (change.objectType) {
+        case "composite_type":
+            return change.compositeType.stableId;
+        case "domain":
+            return change.domain.stableId;
+        case "enum":
+            return change.enum.stableId;
+        case "language":
+            return change.language.stableId;
+        case "materialized_view":
+            return change.materializedView.stableId;
+        case "aggregate":
+            return change.aggregate.stableId;
+        case "procedure":
+            return change.procedure.stableId;
+        case "range":
+            return change.range.stableId;
+        case "schema":
+            return change.schema.stableId;
+        case "sequence":
+            return change.sequence.stableId;
+        case "table":
+            return change.table.stableId;
+        case "view":
+            return change.view.stableId;
+        case "foreign_data_wrapper":
+            return change.foreignDataWrapper.stableId;
+        case "server":
+            return change.server.stableId;
+        case "foreign_table":
+            return change.foreignTable.stableId;
+        default: {
+            const _exhaustive = change;
+            return _exhaustive;
+        }
+    }
+}
 export function diffCatalogs(main, branch, options) {
     const changes = [];
     // Step 1: Diff roles first to get default privilege changes
@@ -38,13 +81,22 @@ export function diffCatalogs(main, branch, options) {
     // 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);
+    //
+    // When skipDefaultPrivilegeSubtraction is true, we use an empty state so that
+    // getEffectiveDefaults always returns [] -- no privileges are subtracted and
+    // every GRANT is emitted explicitly.  This is needed for declarative export
+    // where the output must be self-contained regardless of statement execution order.
+    const defaultPrivilegeState = options?.skipDefaultPrivilegeSubtraction
+        ? new DefaultPrivilegeState({})
+        : new DefaultPrivilegeState(main.roles);
+    if (!options?.skipDefaultPrivilegeSubtraction) {
+        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
@@ -58,25 +110,26 @@ export function diffCatalogs(main, branch, options) {
         currentUser: effectiveUser,
         defaultPrivilegeState,
         mainRoles: main.roles,
+        skipDefaultPrivilegeSubtraction: options?.skipDefaultPrivilegeSubtraction,
     };
     // 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(...diffCollations(diffContext, 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(...diffSubscriptions(diffContext, main.subscriptions, branch.subscriptions));
+    changes.push(...diffPublications(diffContext, 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(...diffSequences(diffContext, main.sequences, branch.sequences, branch.tables, main.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(...diffEventTriggers(diffContext, 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));
@@ -85,62 +138,50 @@ export function diffCatalogs(main, branch, options) {
     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.
+    // Filter privilege changes for objects that are only being dropped.
+    // Avoid emitting redundant ACL statements for targets that will no longer exist.
     const droppedObjectStableIds = new Set();
+    const createdStableIds = new Set();
     for (const change of changes) {
         if (change.operation === "drop" && change.scope === "object") {
             for (const dep of change.requires) {
                 droppedObjectStableIds.add(dep);
             }
         }
+        if (change.operation === "create" && change.scope === "object") {
+            for (const dep of change.creates) {
+                createdStableIds.add(dep);
+            }
+        }
     }
+    // A pure DROP does not need ACL cleanup: the target object is going away.
+    // A replacement is different: it has both DROP and CREATE for the same stable
+    // id, and its privilege ALTERs describe the ACL state of the newly created
+    // object. Keep all of them, including REVOKE/REVOKE GRANT OPTION generated to
+    // subtract privileges inherited from ALTER DEFAULT PRIVILEGES at create time.
+    const replacementStableIds = new Set([...droppedObjectStableIds].filter((id) => createdStableIds.has(id)));
     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;
-                }
+            const targetStableId = getPrivilegeTargetStableId(change);
+            // Checking only privilege creates would keep replacement GRANTs but drop
+            // replacement REVOKEs, so preserve by replacement target stable id instead.
+            if (replacementStableIds.has(targetStableId)) {
+                return true;
             }
+            return !droppedObjectStableIds.has(targetStableId);
         }
         return true;
     });
-    filteredChanges = expandReplaceDependencies({
+    const expandedDependencies = expandReplaceDependencies({
         changes: filteredChanges,
         mainCatalog: main,
         branchCatalog: branch,
+        diffContext,
+    });
+    filteredChanges = normalizePostDiffChanges({
+        changes: expandedDependencies.changes,
+        replacedTableIds: expandedDependencies.replacedTableIds,
+        branchTables: branch.tables,
     });
     debugCatalog("changes catalog diff: %O", stringifyWithBigInt(filteredChanges, 2));
     return filteredChanges;

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

@@ -0,0 +1,17 @@
+/**
+ * Prune a catalog to the objects that match a Filter DSL expression.
+ *
+ * The Filter DSL is defined over Change objects, so the catalog is
+ * diffed against an empty baseline first to materialize one CREATE
+ * change per object. The filter then evaluates against the same shape
+ * it would at plan time, and the surviving stableIds drive the prune.
+ *
+ * Dependency cascade is not applied. A scoped snapshot is partial by
+ * design: out-of-scope owners, roles, and types must exist on the
+ * target DB at apply time. Cascading would expand the filter beyond
+ * what the caller asked for and, in practice, collapse schema-scoped
+ * exports whose kept objects reference cluster-scoped owners.
+ */
+import { Catalog } from "./catalog.model.ts";
+import { type FilterDSL } from "./integrations/filter/dsl.ts";
+export declare function filterCatalog(catalog: Catalog, filter: FilterDSL): Promise<Catalog>;

package/dist/core/catalog.filter.js

@@ -0,0 +1,75 @@
+/**
+ * Prune a catalog to the objects that match a Filter DSL expression.
+ *
+ * The Filter DSL is defined over Change objects, so the catalog is
+ * diffed against an empty baseline first to materialize one CREATE
+ * change per object. The filter then evaluates against the same shape
+ * it would at plan time, and the surviving stableIds drive the prune.
+ *
+ * Dependency cascade is not applied. A scoped snapshot is partial by
+ * design: out-of-scope owners, roles, and types must exist on the
+ * target DB at apply time. Cascading would expand the filter beyond
+ * what the caller asked for and, in practice, collapse schema-scoped
+ * exports whose kept objects reference cluster-scoped owners.
+ */
+import { diffCatalogs } from "./catalog.diff.js";
+import { Catalog, createEmptyCatalog } from "./catalog.model.js";
+import { compileFilterDSL } from "./integrations/filter/dsl.js";
+export async function filterCatalog(catalog, filter) {
+    if (typeof filter === "object" &&
+        filter !== null &&
+        filter.cascade === true) {
+        throw new Error("Filter DSL `cascade: true` is not supported by catalog-export: " +
+            "scoped snapshots are intentionally partial. Out-of-scope owners, " +
+            "roles, and types must exist on the target DB at apply time.");
+    }
+    const empty = await createEmptyCatalog(catalog.version, catalog.currentUser);
+    const changes = diffCatalogs(empty, catalog);
+    const filterFn = compileFilterDSL(filter);
+    const keep = new Set();
+    for (const change of changes) {
+        if (!filterFn(change))
+            continue;
+        for (const id of change.creates ?? [])
+            keep.add(id);
+    }
+    return pruneCatalog(catalog, keep);
+}
+function filterRecord(record, keep) {
+    return Object.fromEntries(Object.entries(record).filter(([id]) => keep.has(id)));
+}
+function pruneCatalog(catalog, keep) {
+    const tables = filterRecord(catalog.tables, keep);
+    const materializedViews = filterRecord(catalog.materializedViews, keep);
+    return new Catalog({
+        aggregates: filterRecord(catalog.aggregates, keep),
+        collations: filterRecord(catalog.collations, keep),
+        compositeTypes: filterRecord(catalog.compositeTypes, keep),
+        domains: filterRecord(catalog.domains, keep),
+        enums: filterRecord(catalog.enums, keep),
+        extensions: filterRecord(catalog.extensions, keep),
+        procedures: filterRecord(catalog.procedures, keep),
+        indexes: filterRecord(catalog.indexes, keep),
+        materializedViews,
+        subscriptions: filterRecord(catalog.subscriptions, keep),
+        publications: filterRecord(catalog.publications, keep),
+        rlsPolicies: filterRecord(catalog.rlsPolicies, keep),
+        roles: filterRecord(catalog.roles, keep),
+        schemas: filterRecord(catalog.schemas, keep),
+        sequences: filterRecord(catalog.sequences, keep),
+        tables,
+        triggers: filterRecord(catalog.triggers, keep),
+        eventTriggers: filterRecord(catalog.eventTriggers, keep),
+        rules: filterRecord(catalog.rules, keep),
+        ranges: filterRecord(catalog.ranges, keep),
+        views: filterRecord(catalog.views, keep),
+        foreignDataWrappers: filterRecord(catalog.foreignDataWrappers, keep),
+        servers: filterRecord(catalog.servers, keep),
+        userMappings: filterRecord(catalog.userMappings, keep),
+        foreignTables: filterRecord(catalog.foreignTables, keep),
+        depends: catalog.depends.filter((d) => keep.has(d.dependent_stable_id) && keep.has(d.referenced_stable_id)),
+        indexableObjects: { ...tables, ...materializedViews },
+        version: catalog.version,
+        currentUser: catalog.currentUser,
+    });
+}

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

@@ -6,8 +6,8 @@ import { type Collation } from "./objects/collation/collation.model.ts";
 import type { Domain } from "./objects/domain/domain.model.ts";
 import { type EventTrigger } from "./objects/event-trigger/event-trigger.model.ts";
 import { type Extension } from "./objects/extension/extension.model.ts";
-import { type ForeignDataWrapper } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.ts";
-import { type ForeignTable } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts";
+import { ForeignDataWrapper } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.ts";
+import { ForeignTable } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts";
 import { Server } from "./objects/foreign-data-wrapper/server/server.model.ts";
 import { UserMapping } from "./objects/foreign-data-wrapper/user-mapping/user-mapping.model.ts";
 import { type Index } from "./objects/index/index.model.ts";
@@ -17,7 +17,7 @@ import { type Publication } from "./objects/publication/publication.model.ts";
 import { type RlsPolicy } from "./objects/rls-policy/rls-policy.model.ts";
 import { type Role } from "./objects/role/role.model.ts";
 import { type Rule } from "./objects/rule/rule.model.ts";
-import { type Schema } from "./objects/schema/schema.model.ts";
+import { Schema } from "./objects/schema/schema.model.ts";
 import { type Sequence } from "./objects/sequence/sequence.model.ts";
 import { Subscription } from "./objects/subscription/subscription.model.ts";
 import { type Table } from "./objects/table/table.model.ts";
@@ -89,5 +89,25 @@ export declare class Catalog {
     readonly currentUser: CatalogProps["currentUser"];
     constructor(props: CatalogProps);
 }
-export declare function extractCatalog(pool: Pool): Promise<Catalog>;
+/**
+ * Create a baseline catalog representing a fresh PostgreSQL database.
+ *
+ * For PG 15+ this deserializes a pre-extracted snapshot of an empty `template1`
+ * database, including the `plpgsql` extension, `postgres` role with default
+ * privileges, and the `public` schema with its default ACLs and depends.
+ *
+ * For PG < 15, falls back to a minimal inline catalog with only the `public`
+ * schema. For exact fidelity on older versions, snapshot a real reference
+ * database using `serializeCatalog` and pass the deserialized result as source
+ * to `createPlan`.
+ */
+export declare function createEmptyCatalog(version: number, currentUser: string): Promise<Catalog>;
+interface ExtractCatalogOptions {
+    /**
+     * Number of retry attempts for catalog extractors when `pg_get_*def()`
+     * returns NULL for at least one row. See `ExtractRetryOptions.retries`.
+     */
+    extractRetries?: number;
+}
+export declare function extractCatalog(pool: Pool, options?: ExtractCatalogOptions): Promise<Catalog>;
 export {};

package/dist/core/catalog.model.js

@@ -5,8 +5,9 @@ import { extractCollations, } from "./objects/collation/collation.model.js";
 import { extractDomains } from "./objects/domain/domain.model.js";
 import { extractEventTriggers, } from "./objects/event-trigger/event-trigger.model.js";
 import { extractExtensions, } from "./objects/extension/extension.model.js";
-import { extractForeignDataWrappers, } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.js";
-import { extractForeignTables, } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.js";
+import { extractForeignDataWrappers, ForeignDataWrapper, } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.js";
+import { extractForeignTables, ForeignTable, } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.js";
+import { redactSensitiveOptionPairs } from "./objects/foreign-data-wrapper/sensitive-options.js";
 import { extractServers, Server, } from "./objects/foreign-data-wrapper/server/server.model.js";
 import { extractUserMappings, UserMapping, } from "./objects/foreign-data-wrapper/user-mapping/user-mapping.model.js";
 import { extractIndexes } from "./objects/index/index.model.js";
@@ -16,7 +17,7 @@ import { extractPublications, } from "./objects/publication/publication.model.js
 import { extractRlsPolicies, } from "./objects/rls-policy/rls-policy.model.js";
 import { extractRoles } from "./objects/role/role.model.js";
 import { extractRules } from "./objects/rule/rule.model.js";
-import { extractSchemas } from "./objects/schema/schema.model.js";
+import { extractSchemas, Schema } from "./objects/schema/schema.model.js";
 import { extractSequences, } from "./objects/sequence/sequence.model.js";
 import { extractSubscriptions, Subscription, } from "./objects/subscription/subscription.model.js";
 import { extractTables } from "./objects/table/table.model.js";
@@ -88,7 +89,113 @@ export class Catalog {
         this.currentUser = props.currentUser;
     }
 }
-export async function extractCatalog(pool) {
+// Lazily cached deserialized baselines (shared across calls)
+let _pg1516Baseline = null;
+let _pg17Baseline = null;
+async function loadBaselineJson() {
+    const mod = await import("./fixtures/empty-catalogs/postgres-15-16-baseline.json", { with: { type: "json" } });
+    return mod.default;
+}
+async function getPg1516Baseline() {
+    if (!_pg1516Baseline) {
+        const { deserializeCatalog } = await import("./catalog.snapshot.js");
+        const json = await loadBaselineJson();
+        _pg1516Baseline = deserializeCatalog(json);
+    }
+    return _pg1516Baseline;
+}
+async function getPg17Baseline() {
+    if (!_pg17Baseline) {
+        const { deserializeCatalog } = await import("./catalog.snapshot.js");
+        // PG 17 is identical to PG 15-16 except for a single addition:
+        // the MAINTAIN privilege on default relation (objtype "r") privileges.
+        // We patch the 15-16 baseline to avoid shipping a second full JSON file.
+        const json = await loadBaselineJson();
+        const patched = structuredClone(json);
+        const roles = patched.roles;
+        const pgRole = roles?.["role:postgres"];
+        if (pgRole) {
+            const defaultPrivileges = pgRole.default_privileges;
+            const relPrivs = defaultPrivileges?.find((dp) => dp.objtype === "r" && dp.grantee === "postgres");
+            if (relPrivs) {
+                const insertIdx = relPrivs.privileges.findIndex((p) => p.privilege === "INSERT");
+                if (insertIdx === -1) {
+                    throw new Error("PG17 baseline patch failed: INSERT privilege not found in default relation privileges");
+                }
+                relPrivs.privileges.splice(insertIdx + 1, 0, {
+                    privilege: "MAINTAIN",
+                    grantable: false,
+                });
+            }
+        }
+        _pg17Baseline = deserializeCatalog(patched);
+    }
+    return _pg17Baseline;
+}
+/**
+ * Create a baseline catalog representing a fresh PostgreSQL database.
+ *
+ * For PG 15+ this deserializes a pre-extracted snapshot of an empty `template1`
+ * database, including the `plpgsql` extension, `postgres` role with default
+ * privileges, and the `public` schema with its default ACLs and depends.
+ *
+ * For PG < 15, falls back to a minimal inline catalog with only the `public`
+ * schema. For exact fidelity on older versions, snapshot a real reference
+ * database using `serializeCatalog` and pass the deserialized result as source
+ * to `createPlan`.
+ */
+export async function createEmptyCatalog(version, currentUser) {
+    if (version >= 170000) {
+        const baseline = await getPg17Baseline();
+        // oxlint-disable-next-line typescript/no-misused-spread
+        return new Catalog({ ...baseline, version, currentUser });
+    }
+    if (version >= 150000) {
+        const baseline = await getPg1516Baseline();
+        // oxlint-disable-next-line typescript/no-misused-spread
+        return new Catalog({ ...baseline, version, currentUser });
+    }
+    const publicSchema = new Schema({
+        name: "public",
+        owner: currentUser,
+        comment: "standard public schema",
+        privileges: [],
+        security_labels: [],
+    });
+    return new Catalog({
+        aggregates: {},
+        collations: {},
+        compositeTypes: {},
+        domains: {},
+        enums: {},
+        extensions: {},
+        procedures: {},
+        indexes: {},
+        materializedViews: {},
+        subscriptions: {},
+        publications: {},
+        rlsPolicies: {},
+        roles: {},
+        schemas: { [publicSchema.stableId]: publicSchema },
+        sequences: {},
+        tables: {},
+        triggers: {},
+        eventTriggers: {},
+        rules: {},
+        ranges: {},
+        views: {},
+        foreignDataWrappers: {},
+        servers: {},
+        userMappings: {},
+        foreignTables: {},
+        depends: [],
+        indexableObjects: {},
+        version,
+        currentUser,
+    });
+}
+export async function extractCatalog(pool, options = {}) {
+    const retryOptions = { retries: options.extractRetries };
     const [aggregates, collations, compositeTypes, domains, enums, extensions, indexes, materializedViews, subscriptions, publications, procedures, rlsPolicies, roles, schemas, sequences, tables, triggers, eventTriggers, rules, ranges, views, foreignDataWrappers, servers, userMappings, foreignTables, depends, version, currentUser,] = await Promise.all([
         extractAggregates(pool).then(listToRecord),
         extractCollations(pool).then(listToRecord),
@@ -96,21 +203,21 @@ export async function extractCatalog(pool) {
         extractDomains(pool).then(listToRecord),
         extractEnums(pool).then(listToRecord),
         extractExtensions(pool).then(listToRecord),
-        extractIndexes(pool).then(listToRecord),
-        extractMaterializedViews(pool).then(listToRecord),
+        extractIndexes(pool, retryOptions).then(listToRecord),
+        extractMaterializedViews(pool, retryOptions).then(listToRecord),
         extractSubscriptions(pool).then(listToRecord),
         extractPublications(pool).then(listToRecord),
-        extractProcedures(pool).then(listToRecord),
+        extractProcedures(pool, retryOptions).then(listToRecord),
         extractRlsPolicies(pool).then(listToRecord),
         extractRoles(pool).then(listToRecord),
         extractSchemas(pool).then(listToRecord),
         extractSequences(pool).then(listToRecord),
-        extractTables(pool).then(listToRecord),
-        extractTriggers(pool).then(listToRecord),
+        extractTables(pool, retryOptions).then(listToRecord),
+        extractTriggers(pool, retryOptions).then(listToRecord),
         extractEventTriggers(pool).then(listToRecord),
-        extractRules(pool).then(listToRecord),
+        extractRules(pool, retryOptions).then(listToRecord),
         extractRanges(pool).then(listToRecord),
-        extractViews(pool).then(listToRecord),
+        extractViews(pool, retryOptions).then(listToRecord),
         extractForeignDataWrappers(pool).then(listToRecord),
         extractServers(pool).then(listToRecord),
         extractUserMappings(pool).then(listToRecord),
@@ -160,27 +267,50 @@ function listToRecord(list) {
     return Object.fromEntries(list.map((item) => [item.stableId, item]));
 }
 function normalizeCatalog(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,
+            wrapper_handler: server.wrapper_handler,
+            wrapper_validator: server.wrapper_validator,
         });
     });
     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),
+            wrapper_handler: mapping.wrapper_handler,
+            wrapper_validator: mapping.wrapper_validator,
         });
     });
+    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,
+        wrapper_handler: foreignTable.wrapper_handler,
+        wrapper_validator: foreignTable.wrapper_validator,
+    }));
     const subscriptions = mapRecord(catalog.subscriptions, (subscription) => {
         return new Subscription({
             name: subscription.name,
@@ -226,29 +356,16 @@ function normalizeCatalog(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,
         currentUser: catalog.currentUser,
     });
 }
-function maskOptions(options) {
-    if (!options || options.length === 0)
-        return options;
-    const masked = [];
-    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(record, mapper) {
     return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, mapper(value)]));
 }