@pgsql/transform 18.3.1 → 18.5.0

package/esm/transform.js

@@ -28,6 +28,15 @@ import { walk as walkSql } from '@pgsql/traverse';
 import { Deparser, parseSql, transformSync, walk as walkPlpgsql } from 'plpgsql-parser';
 import { qualifyUnqualified } from './qualify';
 import { captureTransformAsts, validateRoundTrip } from './round-trip';
+import { SchemaRouter } from './router';
+/** Coerce any accepted mapping form into a {@link SchemaRouter}. */
+function asRouter(mapping) {
+    return SchemaRouter.from(mapping);
+}
+/** Flat schema-level view for string-level passes that operate per source schema. */
+function schemaLevelMap(mapping) {
+    return mapping instanceof SchemaRouter ? mapping.schemaLevelMap() : mapping;
+}
 /**
  * Create a fresh result object
  */
@@ -57,21 +66,26 @@ export function shouldTransformSchema(schemaName, schemaMapping) {
 /**
  * Transform schema names in a String node array (used for funcname, names, etc.)
  * These arrays contain String nodes like { String: { sval: 'schema_name' } }
+ *
+ * `ns` names the namespace of the referenced object so object-level routes can
+ * apply; the object's own name is the last element of the list. When `ns` is
+ * `unknown` (the default) only the schema-level default applies — identical to
+ * the historic whole-schema behaviour.
  */
-export function transformNameList(names, schemaMapping, result) {
+export function transformNameList(names, schemaMapping, result, ns = 'unknown') {
     if (!names || names.length < 2)
         return;
-    // For schema-qualified names, the first element is the schema
+    const router = asRouter(schemaMapping);
+    // For schema-qualified names, the first element is the schema.
     const first = names[0];
     if (first?.String?.sval) {
         const schemaName = first.String.sval;
-        if (shouldTransformSchema(schemaName, schemaMapping)) {
+        const objName = names[names.length - 1]?.String?.sval;
+        const newName = router.resolve(schemaName, objName, ns);
+        if (newName && newName !== schemaName) {
             result.schemasFound.add(schemaName);
-            const newName = schemaMapping.get(schemaName);
-            if (newName) {
-                first.String.sval = newName;
-                result.schemasTransformed.set(schemaName, newName);
-            }
+            first.String.sval = newName;
+            result.schemasTransformed.set(schemaName, newName);
         }
     }
 }
@@ -84,13 +98,13 @@ export function transformSchemaNameField(container, field, schemaMapping, result
     const schemaName = container?.[field];
     if (typeof schemaName !== 'string')
         return;
-    if (shouldTransformSchema(schemaName, schemaMapping)) {
+    // A bare schema name is an operation on the schema itself: only the
+    // schema-level default applies.
+    const newName = asRouter(schemaMapping).resolve(schemaName, undefined, 'schema');
+    if (newName && newName !== schemaName) {
         result.schemasFound.add(schemaName);
-        const newName = schemaMapping.get(schemaName);
-        if (newName) {
-            container[field] = newName;
-            result.schemasTransformed.set(schemaName, newName);
-        }
+        container[field] = newName;
+        result.schemasTransformed.set(schemaName, newName);
     }
 }
 /**
@@ -98,14 +112,16 @@ export function transformSchemaNameField(container, field, schemaMapping, result
  * Many statement nodes embed a relation that the walker does NOT auto-recurse into.
  */
 export function transformRelation(relation, schemaMapping, result) {
-    if (relation?.schemaname && shouldTransformSchema(relation.schemaname, schemaMapping)) {
-        const oldName = relation.schemaname;
+    if (!relation?.schemaname)
+        return;
+    const oldName = relation.schemaname;
+    // A RangeVar names a relation (table/view/sequence/matview); route by the
+    // relation name so object-level routes can send it to its own schema.
+    const newName = asRouter(schemaMapping).resolve(oldName, relation.relname, 'relation');
+    if (newName && newName !== oldName) {
         result.schemasFound.add(oldName);
-        const newName = schemaMapping.get(oldName);
-        if (newName) {
-            relation.schemaname = newName;
-            result.schemasTransformed.set(oldName, newName);
-        }
+        relation.schemaname = newName;
+        result.schemasTransformed.set(oldName, newName);
     }
 }
 /**
@@ -116,7 +132,9 @@ export function transformRelation(relation, schemaMapping, result) {
  */
 export function transformSchemaRefsInString(str, schemaMapping, result) {
     let out = str;
-    for (const [oldSchema, newSchema] of schemaMapping) {
+    // References embedded in opaque strings carry no object identity, so only
+    // whole-schema (schema-level default) routes can be applied here.
+    for (const [oldSchema, newSchema] of schemaLevelMap(schemaMapping)) {
         const pattern = new RegExp(`(?<![\\w-])("?)${escapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
         const before = out;
         out = out.replace(pattern, `$1${newSchema}$1`);
@@ -136,30 +154,59 @@ export function transformSchemaRefsInString(str, schemaMapping, result) {
  * that require explicit handlers.
  */
 export function createSqlVisitor(schemaMapping, result, visitorOptions) {
+    const router = asRouter(schemaMapping);
     const assumeSchemasExist = visitorOptions?.assumeSchemasExist;
+    const useAstBodies = router.hasObjectRoutes();
+    // Rewrite a bare schema-name string field in place (schema-level default).
+    const rewriteSchemaField = (container, key) => {
+        const schemaName = container?.[key];
+        if (typeof schemaName !== 'string')
+            return;
+        const newName = router.resolve(schemaName, undefined, 'schema');
+        if (newName && newName !== schemaName) {
+            result.schemasFound.add(schemaName);
+            container[key] = newName;
+            result.schemasTransformed.set(schemaName, newName);
+        }
+    };
+    // Namespace of the object a DROP/ALTER targets, from its removeType, so
+    // object routes apply to DROP TABLE/FUNCTION/TYPE (e.g. revert scripts).
+    const namespaceOfObjectType = (objType) => {
+        switch (objType) {
+            case 'OBJECT_TABLE':
+            case 'OBJECT_VIEW':
+            case 'OBJECT_SEQUENCE':
+            case 'OBJECT_MATVIEW':
+            case 'OBJECT_FOREIGN_TABLE':
+            case 'OBJECT_INDEX':
+                return 'relation';
+            case 'OBJECT_FUNCTION':
+            case 'OBJECT_PROCEDURE':
+            case 'OBJECT_AGGREGATE':
+            case 'OBJECT_ROUTINE':
+                return 'function';
+            case 'OBJECT_TYPE':
+            case 'OBJECT_DOMAIN':
+                return 'type';
+            default:
+                return 'unknown';
+        }
+    };
     return {
         // Transform RangeVar nodes (table references)
         RangeVar: (path) => {
-            const node = path.node;
-            if (node.schemaname && shouldTransformSchema(node.schemaname, schemaMapping)) {
-                const oldName = node.schemaname;
-                result.schemasFound.add(oldName);
-                const newName = schemaMapping.get(oldName);
-                if (newName) {
-                    node.schemaname = newName;
-                    result.schemasTransformed.set(oldName, newName);
-                }
-            }
+            transformRelation(path.node, router, result);
         },
         // Transform CreateSchemaStmt nodes
         CreateSchemaStmt: (path) => {
             const node = path.node;
-            if (node.schemaname && shouldTransformSchema(node.schemaname, schemaMapping)) {
+            if (node.schemaname) {
                 const oldName = node.schemaname;
-                result.schemasFound.add(oldName);
-                const newName = schemaMapping.get(oldName);
-                if (newName) {
+                // The schema object itself: schema-level default only.
+                const newName = router.resolve(oldName, undefined, 'schema');
+                if (newName && newName !== oldName) {
                     node.schemaname = newName;
+                    result.schemasFound.add(oldName);
                     result.schemasTransformed.set(oldName, newName);
                 }
             }
@@ -170,7 +217,7 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         // Transform FuncCall nodes (function calls with schema-qualified names)
         FuncCall: (path) => {
             const node = path.node;
-            transformNameList(node.funcname, schemaMapping, result);
+            transformNameList(node.funcname, router, result, 'function');
         },
         // Transform CallStmt (CALL schema.procedure(...)).
         // Note: The walker does NOT auto-recurse into CallStmt.funccall,
@@ -178,18 +225,21 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         CallStmt: (path) => {
             const node = path.node;
             if (node.funccall?.funcname) {
-                transformNameList(node.funccall.funcname, schemaMapping, result);
+                transformNameList(node.funccall.funcname, router, result, 'function');
             }
         },
         // Transform TypeName nodes (type references with schema-qualified names)
         TypeName: (path) => {
             const node = path.node;
-            transformNameList(node.names, schemaMapping, result);
+            transformNameList(node.names, router, result, 'type');
         },
-        // Transform ColumnRef nodes (column references with schema-qualified names)
+        // Transform ColumnRef nodes (column references with schema-qualified names).
+        // A qualified column is schema.table.column — the routed object is the
+        // table, which we cannot disambiguate from the schema here, so only the
+        // schema-level default applies.
         ColumnRef: (path) => {
             const node = path.node;
-            transformNameList(node.fields, schemaMapping, result);
+            transformNameList(node.fields, router, result);
         },
         // Transform GrantStmt objects (GRANT ON SCHEMA schema;
         // GRANT ... ON ALL TABLES/FUNCTIONS/SEQUENCES IN SCHEMA schema)
@@ -211,26 +261,10 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
                 for (const arg of node.args) {
                     // search_path args can be String nodes or A_Const with sval
                     if (arg?.String?.sval) {
-                        const schemaName = arg.String.sval;
-                        if (shouldTransformSchema(schemaName, schemaMapping)) {
-                            result.schemasFound.add(schemaName);
-                            const newName = schemaMapping.get(schemaName);
-                            if (newName) {
-                                arg.String.sval = newName;
-                                result.schemasTransformed.set(schemaName, newName);
-                            }
-                        }
+                        rewriteSchemaField(arg.String, 'sval');
                     }
                     else if (arg?.A_Const?.sval?.sval) {
-                        const schemaName = arg.A_Const.sval.sval;
-                        if (shouldTransformSchema(schemaName, schemaMapping)) {
-                            result.schemasFound.add(schemaName);
-                            const newName = schemaMapping.get(schemaName);
-                            if (newName) {
-                                arg.A_Const.sval.sval = newName;
-                                result.schemasTransformed.set(schemaName, newName);
-                            }
-                        }
+                        rewriteSchemaField(arg.A_Const.sval, 'sval');
                     }
                 }
             }
@@ -243,15 +277,7 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
                     if (opt?.DefElem?.defname === 'schemas' && opt.DefElem.arg?.List?.items) {
                         for (const item of opt.DefElem.arg.List.items) {
                             if (item?.String?.sval) {
-                                const schemaName = item.String.sval;
-                                if (shouldTransformSchema(schemaName, schemaMapping)) {
-                                    result.schemasFound.add(schemaName);
-                                    const newName = schemaMapping.get(schemaName);
-                                    if (newName) {
-                                        item.String.sval = newName;
-                                        result.schemasTransformed.set(schemaName, newName);
-                                    }
-                                }
+                                rewriteSchemaField(item.String, 'sval');
                             }
                         }
                     }
@@ -264,15 +290,16 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         DropStmt: (path) => {
             const node = path.node;
             if (node.removeType !== 'OBJECT_SCHEMA' && Array.isArray(node.objects)) {
+                const ns = namespaceOfObjectType(node.removeType);
                 for (const obj of node.objects) {
                     if (obj?.List?.items) {
-                        transformNameList(obj.List.items, schemaMapping, result);
+                        transformNameList(obj.List.items, router, result, ns);
                     }
                     else if (obj?.ObjectWithArgs?.objname) {
-                        transformNameList(obj.ObjectWithArgs.objname, schemaMapping, result);
+                        transformNameList(obj.ObjectWithArgs.objname, router, result, ns);
                     }
                     else if (obj?.TypeName?.names) {
-                        transformNameList(obj.TypeName.names, schemaMapping, result);
+                        transformNameList(obj.TypeName.names, router, result, ns);
                     }
                 }
                 return;
@@ -283,28 +310,12 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
                     if (obj?.List?.items) {
                         for (const item of obj.List.items) {
                             if (item?.String?.sval) {
-                                const schemaName = item.String.sval;
-                                if (shouldTransformSchema(schemaName, schemaMapping)) {
-                                    result.schemasFound.add(schemaName);
-                                    const newName = schemaMapping.get(schemaName);
-                                    if (newName) {
-                                        item.String.sval = newName;
-                                        result.schemasTransformed.set(schemaName, newName);
-                                    }
-                                }
+                                rewriteSchemaField(item.String, 'sval');
                             }
                         }
                     }
                     else if (obj?.String?.sval) {
-                        const schemaName = obj.String.sval;
-                        if (shouldTransformSchema(schemaName, schemaMapping)) {
-                            result.schemasFound.add(schemaName);
-                            const newName = schemaMapping.get(schemaName);
-                            if (newName) {
-                                obj.String.sval = newName;
-                                result.schemasTransformed.set(schemaName, newName);
-                            }
-                        }
+                        rewriteSchemaField(obj.String, 'sval');
                     }
                 }
             }
@@ -357,7 +368,7 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         ColumnDef: (path) => {
             const node = path.node;
             if (node.typeName?.names) {
-                transformNameList(node.typeName.names, schemaMapping, result);
+                transformNameList(node.typeName.names, schemaMapping, result, 'type');
             }
         },
         // Transform ViewStmt (CREATE VIEW schema.viewname AS ...)
@@ -430,24 +441,24 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         TypeCast: (path) => {
             const node = path.node;
             if (node.typeName?.names) {
-                transformNameList(node.typeName.names, schemaMapping, result);
+                transformNameList(node.typeName.names, schemaMapping, result, 'type');
             }
         },
         // Transform CreateFunctionStmt (CREATE FUNCTION schema.funcname)
         // Also handles RETURNS [SETOF] schema.type via returnType.names
         CreateFunctionStmt: (path) => {
             const node = path.node;
-            transformNameList(node.funcname, schemaMapping, result);
+            transformNameList(node.funcname, schemaMapping, result, 'function');
             // Transform the return type (e.g., RETURNS SETOF schema.tablename)
             if (node.returnType?.names) {
-                transformNameList(node.returnType.names, schemaMapping, result);
+                transformNameList(node.returnType.names, schemaMapping, result, 'type');
             }
             // Transform parameter types (the walker does NOT auto-recurse into
             // FunctionParameter.argType TypeName nodes)
             if (Array.isArray(node.parameters)) {
                 for (const param of node.parameters) {
                     if (param?.FunctionParameter?.argType?.names) {
-                        transformNameList(param.FunctionParameter.argType.names, schemaMapping, result);
+                        transformNameList(param.FunctionParameter.argType.names, schemaMapping, result, 'type');
                     }
                 }
             }
@@ -460,8 +471,16 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
                 for (const opt of node.options) {
                     if (opt?.DefElem?.defname === 'as' && opt.DefElem.arg?.List?.items) {
                         for (const item of opt.DefElem.arg.List.items) {
-                            if (typeof item?.String?.sval === 'string' && item.String.sval.includes('.')) {
-                                item.String.sval = transformSchemaRefsInString(item.String.sval, schemaMapping, result);
+                            if (typeof item?.String?.sval !== 'string')
+                                continue;
+                            // With object routes, references inside a LANGUAGE sql body must
+                            // be rewritten AST-precisely; whole-schema routes keep the
+                            // cheaper (and quoting-preserving) string pass.
+                            if (useAstBodies) {
+                                item.String.sval = transformSqlBodyString(item.String.sval, router, result);
+                            }
+                            else if (item.String.sval.includes('.')) {
+                                item.String.sval = transformSchemaRefsInString(item.String.sval, router, result);
                             }
                         }
                     }
@@ -473,7 +492,7 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         // so we must explicitly transform the RangeVar here.
         CreateTrigStmt: (path) => {
             const node = path.node;
-            transformNameList(node.funcname, schemaMapping, result);
+            transformNameList(node.funcname, schemaMapping, result, 'function');
             transformRelation(node.relation, schemaMapping, result);
         },
         // Transform CommentStmt (COMMENT ON TABLE/COLUMN/FUNCTION schema.obj,
@@ -519,29 +538,29 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         // Transform CreateDomainStmt (CREATE DOMAIN schema.domname)
         CreateDomainStmt: (path) => {
             const node = path.node;
-            transformNameList(node.domainname, schemaMapping, result);
+            transformNameList(node.domainname, schemaMapping, result, 'type');
         },
         // Transform CreateEnumStmt (CREATE TYPE schema.enumname AS ENUM)
         CreateEnumStmt: (path) => {
             const node = path.node;
-            transformNameList(node.typeName, schemaMapping, result);
+            transformNameList(node.typeName, schemaMapping, result, 'type');
         },
         // Transform AlterEnumStmt (ALTER TYPE schema.enumname ADD VALUE)
         AlterEnumStmt: (path) => {
             const node = path.node;
-            transformNameList(node.typeName, schemaMapping, result);
+            transformNameList(node.typeName, schemaMapping, result, 'type');
         },
         // Transform AlterDomainStmt (ALTER DOMAIN schema.domname)
         AlterDomainStmt: (path) => {
             const node = path.node;
-            transformNameList(node.typeName, schemaMapping, result);
+            transformNameList(node.typeName, schemaMapping, result, 'type');
         },
         // Transform AlterTypeStmt (ALTER TYPE schema.typename)
         // Note: composite type alters use RangeVar (handled by RangeVar visitor),
         // but some ALTER TYPE statements use typeName as a name list
         AlterTypeStmt: (path) => {
             const node = path.node;
-            transformNameList(node.typeName, schemaMapping, result);
+            transformNameList(node.typeName, schemaMapping, result, 'type');
         },
         // Transform ObjectWithArgs (used in ALTER FUNCTION, DROP FUNCTION with args, etc.)
         ObjectWithArgs: (path) => {
@@ -589,7 +608,7 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         AlterFunctionStmt: (path) => {
             const node = path.node;
             if (node.func?.objname) {
-                transformNameList(node.func.objname, schemaMapping, result);
+                transformNameList(node.func.objname, schemaMapping, result, 'function');
             }
         },
         // Transform AlterOwnerStmt (ALTER ... OWNER TO role)
@@ -610,28 +629,28 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         CreateCastStmt: (path) => {
             const node = path.node;
             if (node.sourcetype?.names) {
-                transformNameList(node.sourcetype.names, schemaMapping, result);
+                transformNameList(node.sourcetype.names, schemaMapping, result, 'type');
             }
             if (node.targettype?.names) {
-                transformNameList(node.targettype.names, schemaMapping, result);
+                transformNameList(node.targettype.names, schemaMapping, result, 'type');
             }
             if (node.func?.objname) {
-                transformNameList(node.func.objname, schemaMapping, result);
+                transformNameList(node.func.objname, schemaMapping, result, 'function');
             }
             if (Array.isArray(node.func?.objargs)) {
                 for (const arg of node.func.objargs) {
                     if (arg?.TypeName?.names) {
-                        transformNameList(arg.TypeName.names, schemaMapping, result);
+                        transformNameList(arg.TypeName.names, schemaMapping, result, 'type');
                     }
                     else if (arg?.names) {
-                        transformNameList(arg.names, schemaMapping, result);
+                        transformNameList(arg.names, schemaMapping, result, 'type');
                     }
                 }
             }
             if (Array.isArray(node.func?.objfuncargs)) {
                 for (const param of node.func.objfuncargs) {
                     if (param?.FunctionParameter?.argType?.names) {
-                        transformNameList(param.FunctionParameter.argType.names, schemaMapping, result);
+                        transformNameList(param.FunctionParameter.argType.names, schemaMapping, result, 'type');
                     }
                 }
             }
@@ -639,7 +658,7 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         // Transform CreateEventTrigStmt (CREATE EVENT TRIGGER ... EXECUTE FUNCTION schema.fn())
         CreateEventTrigStmt: (path) => {
             const node = path.node;
-            transformNameList(node.funcname, schemaMapping, result);
+            transformNameList(node.funcname, schemaMapping, result, 'function');
         },
         // Transform IndexElem opclass (CREATE INDEX ... (col schema.opclass))
         IndexElem: (path) => {
@@ -680,10 +699,14 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
  * indicating that the AST visitor is missing a handler for that node type.
  */
 export function validateNoUntransformedSchemas(content, schemaMapping) {
-    if (schemaMapping.size === 0) {
+    // Only schemas with a schema-level default are guaranteed to move entirely;
+    // partially (object-only) routed schemas may legitimately keep some
+    // references, so they are excluded from the strict leftover check.
+    const moved = schemaMapping instanceof SchemaRouter ? schemaMapping.fullyMovedSchemas() : schemaMapping;
+    if (moved.size === 0) {
         return;
     }
-    for (const [oldSchema, newSchema] of schemaMapping) {
+    for (const [oldSchema, newSchema] of moved) {
         const escapedSchema = escapeRegexp(oldSchema);
         // Pattern 1: quoted or unquoted schema name followed by dot (schema-qualified)
         const dotPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
@@ -718,11 +741,12 @@ export function validateNoUntransformedSchemas(content, schemaMapping) {
  * Create a PL/pgSQL visitor that transforms schema names in PL/pgSQL-specific nodes.
  */
 export function createPlpgsqlVisitor(schemaMapping, result) {
+    const schemaMap = schemaLevelMap(schemaMapping);
     return {
         PLpgSQL_type: (path) => {
             const node = path.node;
             if (node.typname) {
-                for (const [oldSchema, newSchema] of schemaMapping.entries()) {
+                for (const [oldSchema, newSchema] of schemaMap.entries()) {
                     if (node.typname.startsWith(oldSchema + '.')) {
                         const typeName = node.typname.substring(oldSchema.length + 1);
                         result.schemasFound.add(oldSchema);
@@ -736,7 +760,7 @@ export function createPlpgsqlVisitor(schemaMapping, result) {
         PLpgSQL_var: (path) => {
             const node = path.node;
             if (node.refname) {
-                for (const [oldSchema, newSchema] of schemaMapping.entries()) {
+                for (const [oldSchema, newSchema] of schemaMap.entries()) {
                     if (node.refname.startsWith(oldSchema + '.')) {
                         const rest = node.refname.substring(oldSchema.length + 1);
                         result.schemasFound.add(oldSchema);
@@ -753,6 +777,7 @@ export function createPlpgsqlVisitor(schemaMapping, result) {
  * Transform a PLpgSQL_type typname using proper AST parsing.
  */
 export function transformPlpgsqlTypeAst(typname, schemaMapping, result) {
+    const schemaMap = schemaLevelMap(schemaMapping);
     let suffix = '';
     let baseTypname = typname;
     const rowtypeMatch = typname.match(/(%rowtype|%type)$/i);
@@ -761,7 +786,7 @@ export function transformPlpgsqlTypeAst(typname, schemaMapping, result) {
         baseTypname = typname.substring(0, typname.length - suffix.length);
     }
     let needsTransform = false;
-    for (const oldSchema of schemaMapping.keys()) {
+    for (const oldSchema of schemaMap.keys()) {
         if (baseTypname.startsWith(oldSchema + '.') || baseTypname.startsWith('"' + oldSchema + '".')) {
             needsTransform = true;
             break;
@@ -780,7 +805,7 @@ export function transformPlpgsqlTypeAst(typname, schemaMapping, result) {
             TypeName: (path) => {
                 const typeNode = path.node;
                 if (typeNode.names && Array.isArray(typeNode.names)) {
-                    transformNameList(typeNode.names, schemaMapping, result);
+                    transformNameList(typeNode.names, schemaMapping, result, 'type');
                 }
             }
         };
@@ -802,7 +827,7 @@ export function transformPlpgsqlTypeAst(typname, schemaMapping, result) {
  * Uses @pgsql/quotes QuoteUtils for proper identifier quoting.
  */
 export function transformPlpgsqlTypeString(typname, schemaMapping, result) {
-    for (const [oldSchema, newSchema] of schemaMapping.entries()) {
+    for (const [oldSchema, newSchema] of schemaLevelMap(schemaMapping).entries()) {
         // Unquoted schema: old_schema.rest
         if (typname.startsWith(oldSchema + '.')) {
             const rest = typname.substring(oldSchema.length + 1);
@@ -873,7 +898,7 @@ export function walkPlpgsqlForSchemas(node, schemaMapping, result) {
                 // We cannot use walkSql here because the raw typeNameNode is not
                 // wrapped in the expected AST envelope that the traverse walker needs.
                 if (plType.typname.typeNameNode?.names) {
-                    transformNameList(plType.typname.typeNameNode.names, schemaMapping, result);
+                    transformNameList(plType.typname.typeNameNode.names, schemaMapping, result, 'type');
                 }
                 // The deparser can fall back to the 'original' string to render
                 // DECLARE types, so update it as well. Rewrite only the schema
@@ -892,6 +917,35 @@ export function walkPlpgsqlForSchemas(node, schemaMapping, result) {
         walkPlpgsqlForSchemas(value, schemaMapping, result);
     }
 }
+/**
+ * Rewrite a `LANGUAGE sql` function-body string using the full AST visitor so
+ * object-level routes reach references inside the body (the body is an opaque
+ * String node the outer walker never parses). Parses each statement, walks it
+ * with the router-aware SQL visitor, and deparses. Falls back to the
+ * schema-level string pass for anything that does not parse standalone (e.g.
+ * PL/pgSQL blocks or C symbol names).
+ */
+function transformSqlBodyString(body, router, result) {
+    try {
+        const parseResult = parseSql(body);
+        const stmts = parseResult?.stmts ?? [];
+        if (stmts.length === 0) {
+            return body.includes('.') ? transformSchemaRefsInString(body, router, result) : body;
+        }
+        const visitor = createSqlVisitor(router, result);
+        const pieces = [];
+        for (const stmt of stmts) {
+            if (!stmt?.stmt)
+                continue;
+            walkSql(stmt.stmt, visitor);
+            pieces.push(Deparser.deparse(stmt.stmt));
+        }
+        return pieces.join(';\n');
+    }
+    catch {
+        return body.includes('.') ? transformSchemaRefsInString(body, router, result) : body;
+    }
+}
 /**
  * Escape a string for use in a regular expression
  */
@@ -1040,11 +1094,13 @@ export function transformSql(content, schemaMapping, options, result) {
     if (schemaMapping.size === 0) {
         return { content, result: r };
     }
+    // String-level passes operate on whole schemas; give them the flat view.
+    const passMap = schemaLevelMap(schemaMapping);
     let newContent = content;
     // Run pre-passes (app-specific string-level transforms)
     if (opts.prePasses) {
         for (const pass of opts.prePasses) {
-            newContent = pass(newContent, schemaMapping, r);
+            newContent = pass(newContent, passMap, r);
         }
     }
     // Main pass: AST transformation with header handling
@@ -1052,7 +1108,7 @@ export function transformSql(content, schemaMapping, options, result) {
     // Run post-passes (app-specific string-level transforms)
     if (opts.postPasses) {
         for (const pass of opts.postPasses) {
-            newContent = pass(newContent, schemaMapping, r);
+            newContent = pass(newContent, passMap, r);
         }
     }
     return { content: newContent, result: r };
@@ -1109,7 +1165,8 @@ function transformSqlContentAst(content, schemaMapping, result, options) {
     const { header, body } = extractPgpmHeader(content);
     let transformedHeader = header;
     if (header.length > 0) {
-        transformedHeader = transformComments(header, schemaMapping, result);
+        // Header/path rewrites (-- Deploy: schemas/<schema>/...) are whole-schema.
+        transformedHeader = transformComments(header, schemaLevelMap(schemaMapping), result);
     }
     let transformedBody = body;
     if (options?.qualifyUnqualified && transformedBody.trim().length > 0) {

package/facts.js

@@ -244,6 +244,43 @@ function classifyOne(nodeTag, node) {
     collectRoles(node, facts.roles);
     return facts;
 }
+/** Read a `CreateFunctionStmt` DefElem option's scalar/list value. */
+function functionOption(node, defname) {
+    for (const opt of node.options ?? []) {
+        if (opt?.DefElem?.defname === defname)
+            return opt.DefElem.arg;
+    }
+    return undefined;
+}
+/**
+ * Collect references from a `LANGUAGE sql` function body supplied as a string
+ * literal (`AS $$ ... $$`). That body is an opaque String node the AST walker
+ * never parses, so — mirroring the schema transformer's body rewrite — parse
+ * it standalone and walk each statement with the facts visitor. The standard
+ * `BEGIN ATOMIC` / `RETURN` `sql_body` form is already part of the AST and is
+ * covered by the outer walk, so only the string form needs this.
+ */
+function collectSqlBodyReferences(node, facts) {
+    const language = functionOption(node, 'language')?.String?.sval;
+    if (typeof language !== 'string' || language.toLowerCase() !== 'sql')
+        return;
+    const asArg = functionOption(node, 'as');
+    const items = asArg?.List?.items ?? [];
+    const body = items[0]?.String?.sval;
+    if (typeof body !== 'string')
+        return;
+    try {
+        const stmts = (0, plpgsql_parser_1.parseSql)(body)?.stmts ?? [];
+        const visitor = createFactsVisitor(facts, facts.bodyReferences);
+        for (const stmt of stmts) {
+            if (stmt?.stmt)
+                (0, traverse_1.walk)(stmt.stmt, visitor);
+        }
+    }
+    catch {
+        // A non-parseable body (C symbol name, etc.) contributes no references.
+    }
+}
 /**
  * Classify each top-level statement in a SQL script into {@link StatementFacts}.
  *
@@ -263,6 +300,9 @@ function classifyStatements(sql) {
             if (stmtNode) {
                 (0, traverse_1.walk)(stmtNode, createFactsVisitor(facts));
             }
+            if (nodeTag === 'CreateFunctionStmt') {
+                collectSqlBodyReferences(node, facts);
+            }
             allFacts.push(facts);
         }
         for (const fn of ctx.functions ?? []) {