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

package/dist/cli/commands/catalog-export.js

@@ -3,6 +3,7 @@
  */
 import { writeFile } from "node:fs/promises";
 import { buildCommand } from "@stricli/core";
+import { filterCatalog } from "../../core/catalog.filter.js";
 import { extractCatalog } from "../../core/catalog.model.js";
 import { serializeCatalog, stringifyCatalogSnapshot, } from "../../core/catalog.snapshot.js";
 import { createManagedPool } from "../../core/postgres-config.js";
@@ -25,6 +26,19 @@ export const catalogExportCommand = buildCommand({
                 parse: String,
                 optional: true,
             },
+            filter: {
+                kind: "parsed",
+                brief: 'Filter DSL as inline JSON to filter changes (e.g., \'{"*/schema": "app"}\').',
+                parse: (value) => {
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (error) {
+                        throw new Error(`Invalid filter JSON: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                },
+                optional: true,
+            },
         },
         aliases: {
             t: "target",
@@ -43,6 +57,10 @@ Use cases:
   - Snapshot template1 for use as an empty-database baseline
   - Snapshot a production database to generate revert migrations
   - Snapshot any state for reproducible offline diffs
+
+Pass --filter to scope the snapshot to a subset of the catalog (same
+Filter DSL accepted by plan/sync). Useful when committing a baseline
+snapshot to a repo and only one schema's drift is interesting.
     `.trim(),
     },
     async func(flags) {
@@ -52,7 +70,10 @@ Use cases:
         });
         try {
             const catalog = await extractCatalog(pool);
-            const snapshot = serializeCatalog(catalog);
+            const scoped = flags.filter
+                ? await filterCatalog(catalog, flags.filter)
+                : catalog;
+            const snapshot = serializeCatalog(scoped);
             const json = stringifyCatalogSnapshot(snapshot);
             await writeFile(flags.output, json, "utf-8");
             this.process.stdout.write(`Catalog snapshot written to ${flags.output}\n`);

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.js

@@ -93,7 +93,7 @@ export class Catalog {
 let _pg1516Baseline = null;
 let _pg17Baseline = null;
 async function loadBaselineJson() {
-    const mod = await import("./fixtures/empty-catalogs/postgres-15-16-baseline.json");
+    const mod = await import("./fixtures/empty-catalogs/postgres-15-16-baseline.json", { with: { type: "json" } });
     return mod.default;
 }
 async function getPg1516Baseline() {
@@ -147,10 +147,12 @@ async function getPg17Baseline() {
 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({
@@ -284,6 +286,8 @@ function normalizeCatalog(catalog) {
             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) => {
@@ -291,6 +295,8 @@ function normalizeCatalog(catalog) {
             user: mapping.user,
             server: mapping.server,
             options: redactSensitiveOptionPairs(mapping.options),
+            wrapper_handler: mapping.wrapper_handler,
+            wrapper_validator: mapping.wrapper_validator,
         });
     });
     const foreignTables = mapRecord(catalog.foreignTables, (foreignTable) => new ForeignTable({
@@ -302,6 +308,8 @@ function normalizeCatalog(catalog) {
         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({

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

@@ -6,7 +6,7 @@ import { CreateMaterializedView } from "./objects/materialized-view/changes/mate
 import { DropMaterializedView } from "./objects/materialized-view/changes/materialized-view.drop.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 { 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";
@@ -312,12 +312,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({

package/dist/core/integrations/supabase.js

@@ -120,6 +120,30 @@ export const supabase = {
                             "trigger/function_schema": [...SUPABASE_SYSTEM_SCHEMAS],
                         },
                     },
+                    // Defensive fallback for dynamically-created pgmq queue /
+                    // archive tables. `pgmq.q_<name>` and `pgmq.a_<name>` are
+                    // materialized by `select pgmq.create('<name>')`, NOT by
+                    // `CREATE EXTENSION pgmq`, so emitting a user trigger against
+                    // them fails locally with
+                    // `relation "pgmq.q_<name>" does not exist`. On a healthy
+                    // install the trigger extractor's `extension_table_oids` join
+                    // (packages/pg-delta/src/core/objects/trigger/trigger.model.ts)
+                    // already drops these via the `pg_depend deptype='e'` row pgmq
+                    // records during `pgmq.create()`; this rule covers projects
+                    // where that row is missing (older pgmq, manual table
+                    // rewrites, `pg_dump`/restore that loses extension deps, ...).
+                    // pgmq 1.4.4 — the version Supabase Cloud currently ships —
+                    // does not record the dependency at all.
+                    {
+                        not: {
+                            and: [
+                                { "trigger/schema": "pgmq" },
+                                {
+                                    "trigger/table_name": { op: "regex", value: "^[qa]_" },
+                                },
+                            ],
+                        },
+                    },
                 ],
             },
             // Exclude system objects
@@ -180,15 +204,25 @@ export const supabase = {
                             ],
                         },
                         // Platform-managed foreign data wrappers — Wasm-based FDWs
-                        // (e.g. `clerk`, `clerk_oauth`) whose handler/validator live in
-                        // the `extensions` schema. `CREATE FOREIGN DATA WRAPPER`
-                        // requires superuser, and Supabase Cloud provisions these via
-                        // `supabase_admin` at project creation; replaying the DDL
-                        // against a local image fails because the local environment
-                        // has no equivalent pre-step. We can't rely on the FDW owner
-                        // alone — after a dump/restore the owner is often rewritten
-                        // away from `supabase_admin` — so match on the function
-                        // reference instead.
+                        // (e.g. `clerk`, `clerk_oauth`) provisioned via the `wrappers`
+                        // extension. Supabase Cloud creates these as
+                        // `CREATE FOREIGN DATA WRAPPER clerk_oauth HANDLER
+                        // extensions.wasm_fdw_handler VALIDATOR
+                        // extensions.wasm_fdw_validator` at project creation; replaying
+                        // the DDL against a local image fails because the local
+                        // environment has no equivalent pre-step. We can't rely on the
+                        // FDW owner alone — after a dump/restore the owner is often
+                        // rewritten away from `supabase_admin` — so match on the shared
+                        // Wasm handler/validator (`extensions.wasm_fdw_handler` /
+                        // `extensions.wasm_fdw_validator`) instead.
+                        //
+                        // Matching the bare `extensions.*` namespace would be too broad:
+                        // contrib FDWs like `postgres_fdw` also install their
+                        // handler/validator into `extensions` on Supabase, and those ARE
+                        // available in the local image, so a user-created `postgres_fdw`
+                        // wrapper (and its servers/foreign tables/user mappings) must
+                        // still roundtrip. Keying on the `wasm_fdw_*` function names
+                        // targets only the platform Wasm wrappers.
                         {
                             and: [
                                 { objectType: "foreign_data_wrapper" },
@@ -197,13 +231,70 @@ export const supabase = {
                                         {
                                             "foreign_data_wrapper/handler": {
                                                 op: "regex",
-                                                value: "^extensions\\.",
+                                                value: "^extensions\\.wasm_fdw_handler$",
                                             },
                                         },
                                         {
                                             "foreign_data_wrapper/validator": {
                                                 op: "regex",
-                                                value: "^extensions\\.",
+                                                value: "^extensions\\.wasm_fdw_validator$",
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        // Platform-managed Wasm FDW dependents (CLI-1470 follow-up).
+                        // Suppressing the wrapper DDL alone leaves `CREATE SERVER` /
+                        // `CREATE FOREIGN TABLE` / `CREATE USER MAPPING` that reference
+                        // a wrapper local Docker never provisions (`clerk_oauth`, etc.).
+                        // Match on the parent wrapper's Wasm handler/validator
+                        // (`extensions.wasm_fdw_handler` / `extensions.wasm_fdw_validator`,
+                        // joined at extract time) — the same discriminator used for the
+                        // wrapper itself above. A bare `extensions.*` match would also
+                        // drop user-created `postgres_fdw` servers/foreign tables/user
+                        // mappings (whose handler installs into `extensions` but which
+                        // the local image CAN provision), so keep it scoped to the Wasm
+                        // function names. Server _privilege_ scope is excluded here —
+                        // `GRANT/REVOKE ON SERVER` does not require superuser and remains
+                        // user-declarative state (see CLI-1469 companion test).
+                        {
+                            and: [
+                                { objectType: "server" },
+                                { not: { scope: "privilege" } },
+                                {
+                                    or: [
+                                        {
+                                            "{server,foreign_table,user_mapping}/wrapper_handler": {
+                                                op: "regex",
+                                                value: "^extensions\\.wasm_fdw_handler$",
+                                            },
+                                        },
+                                        {
+                                            "{server,foreign_table,user_mapping}/wrapper_validator": {
+                                                op: "regex",
+                                                value: "^extensions\\.wasm_fdw_validator$",
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            and: [
+                                { objectType: ["foreign_table", "user_mapping"] },
+                                {
+                                    or: [
+                                        {
+                                            "{server,foreign_table,user_mapping}/wrapper_handler": {
+                                                op: "regex",
+                                                value: "^extensions\\.wasm_fdw_handler$",
+                                            },
+                                        },
+                                        {
+                                            "{server,foreign_table,user_mapping}/wrapper_validator": {
+                                                op: "regex",
+                                                value: "^extensions\\.wasm_fdw_validator$",
                                             },
                                         },
                                     ],

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

@@ -52,6 +52,8 @@ declare const foreignTablePropsSchema: z.ZodObject<{
         provider: z.ZodString;
         label: z.ZodString;
     }, z.z.core.$strip>>>>;
+    wrapper_handler: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wrapper_validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 type ForeignTablePrivilegeProps = PrivilegeProps;
 export type ForeignTableProps = z.infer<typeof foreignTablePropsSchema>;
@@ -65,6 +67,8 @@ export declare class ForeignTable extends BasePgModel implements TableLikeObject
     readonly columns: ForeignTableProps["columns"];
     readonly privileges: ForeignTablePrivilegeProps[];
     readonly security_labels: SecurityLabelProps[];
+    readonly wrapper_handler: ForeignTableProps["wrapper_handler"];
+    readonly wrapper_validator: ForeignTableProps["wrapper_validator"];
     constructor(props: ForeignTableProps);
     get stableId(): `foreignTable:${string}`;
     get identityFields(): {

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

@@ -23,6 +23,9 @@ const foreignTablePropsSchema = z.object({
     columns: z.array(columnPropsSchema),
     privileges: z.array(privilegePropsSchema),
     security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+    // Parent FDW handler/validator — filter metadata only, not in dataFields.
+    wrapper_handler: z.string().nullable().optional(),
+    wrapper_validator: z.string().nullable().optional(),
 });
 export class ForeignTable extends BasePgModel {
     schema;
@@ -34,6 +37,8 @@ export class ForeignTable extends BasePgModel {
     columns;
     privileges;
     security_labels;
+    wrapper_handler;
+    wrapper_validator;
     constructor(props) {
         super();
         // Identity fields
@@ -47,6 +52,8 @@ export class ForeignTable extends BasePgModel {
         this.columns = props.columns;
         this.privileges = props.privileges;
         this.security_labels = props.security_labels ?? [];
+        this.wrapper_handler = props.wrapper_handler ?? null;
+        this.wrapper_validator = props.wrapper_validator ?? null;
     }
     get stableId() {
         return `foreignTable:${this.schema}.${this.name}`;
@@ -114,12 +121,22 @@ export async function extractForeignTables(pool) {
           c.relowner::regrole::text as owner,
           quote_ident(srv.srvname) as server,
           coalesce(ft.ftoptions, array[]::text[]) as options,
-          c.oid as oid
+          c.oid as oid,
+          case
+            when fdw.fdwhandler = 0 then null
+            else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+          end as wrapper_handler,
+          case
+            when fdw.fdwvalidator = 0 then null
+            else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+          end as wrapper_validator
         from
           pg_class c
           inner join pg_foreign_table ft on ft.ftrelid = c.oid
           inner join pg_foreign_server srv on srv.oid = ft.ftserver
           inner join pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+          left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+          left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
           left outer join extension_oids e1 on c.oid = e1.objid
         where
           c.relkind = 'f'
@@ -133,6 +150,8 @@ export async function extractForeignTables(pool) {
         ft.owner,
         ft.server,
         ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator,
         obj_description(ft.oid, 'pg_class') as comment,
         coalesce(json_agg(
           case when a.attname is not null then
@@ -218,7 +237,14 @@ export async function extractForeignTables(pool) {
         left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
         left join pg_type ty on ty.oid = a.atttypid
       group by
-        ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
+        ft.oid,
+        ft.schema,
+        ft.name,
+        ft.owner,
+        ft.server,
+        ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator
       order by
         ft.schema, ft.name
   `);

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

@@ -26,6 +26,8 @@ declare const serverPropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    wrapper_handler: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wrapper_validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 type ServerPrivilegeProps = PrivilegeProps;
 export type ServerProps = z.infer<typeof serverPropsSchema>;
@@ -38,6 +40,8 @@ export declare class Server extends BasePgModel {
     readonly options: ServerProps["options"];
     readonly comment: ServerProps["comment"];
     readonly privileges: ServerPrivilegeProps[];
+    readonly wrapper_handler: ServerProps["wrapper_handler"];
+    readonly wrapper_validator: ServerProps["wrapper_validator"];
     constructor(props: ServerProps);
     get stableId(): `server:${string}`;
     get identityFields(): {

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

@@ -21,6 +21,9 @@ const serverPropsSchema = z.object({
     options: z.array(z.string()).nullable(),
     comment: z.string().nullable(),
     privileges: z.array(privilegePropsSchema),
+    // Parent FDW handler/validator — filter metadata only, not in dataFields.
+    wrapper_handler: z.string().nullable().optional(),
+    wrapper_validator: z.string().nullable().optional(),
 });
 export class Server extends BasePgModel {
     name;
@@ -31,6 +34,8 @@ export class Server extends BasePgModel {
     options;
     comment;
     privileges;
+    wrapper_handler;
+    wrapper_validator;
     constructor(props) {
         super();
         // Identity fields
@@ -43,6 +48,8 @@ export class Server extends BasePgModel {
         this.options = props.options;
         this.comment = props.comment;
         this.privileges = props.privileges;
+        this.wrapper_handler = props.wrapper_handler ?? null;
+        this.wrapper_validator = props.wrapper_validator ?? null;
     }
     get stableId() {
         return `server:${this.name}`;
@@ -96,10 +103,20 @@ export async function extractServers(pool) {
             )
             from lateral aclexplode(srv.srvacl) as x(grantor, grantee, privilege_type, is_grantable)
           ), '[]'
-        ) as privileges
+        ) as privileges,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_foreign_server srv
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

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

@@ -16,12 +16,16 @@ declare const userMappingPropsSchema: z.ZodObject<{
     user: z.ZodString;
     server: z.ZodString;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    wrapper_handler: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wrapper_validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 export type UserMappingProps = z.infer<typeof userMappingPropsSchema>;
 export declare class UserMapping extends BasePgModel {
     readonly user: UserMappingProps["user"];
     readonly server: UserMappingProps["server"];
     readonly options: UserMappingProps["options"];
+    readonly wrapper_handler: UserMappingProps["wrapper_handler"];
+    readonly wrapper_validator: UserMappingProps["wrapper_validator"];
     constructor(props: UserMappingProps);
     get stableId(): `userMapping:${string}:${string}`;
     get identityFields(): {

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

@@ -16,11 +16,16 @@ const userMappingPropsSchema = z.object({
     user: z.string(),
     server: z.string(),
     options: z.array(z.string()).nullable(),
+    // Parent FDW handler/validator — filter metadata only, not in dataFields.
+    wrapper_handler: z.string().nullable().optional(),
+    wrapper_validator: z.string().nullable().optional(),
 });
 export class UserMapping extends BasePgModel {
     user;
     server;
     options;
+    wrapper_handler;
+    wrapper_validator;
     constructor(props) {
         super();
         // Identity fields
@@ -28,6 +33,8 @@ export class UserMapping extends BasePgModel {
         this.server = props.server;
         // Data fields
         this.options = props.options;
+        this.wrapper_handler = props.wrapper_handler ?? null;
+        this.wrapper_validator = props.wrapper_validator ?? null;
     }
     get stableId() {
         return `userMapping:${this.server}:${this.user}`;
@@ -62,11 +69,21 @@ export async function extractUserMappings(pool) {
           else um.umuser::regrole::text
         end as user,
         quote_ident(srv.srvname) as server,
-        coalesce(um.umoptions, array[]::text[]) as options
+        coalesce(um.umoptions, array[]::text[]) as options,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_user_mapping um
         inner join pg_catalog.pg_foreign_server srv on srv.oid = um.umserver
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by