@pgsql/transform 18.6.0 → 18.8.0

package/esm/facts.js

@@ -154,7 +154,8 @@ function classifyOne(nodeTag, node) {
         bodyReferences: [],
         securityRelevant: SECURITY_TAGS.has(nodeTag),
         securityDefiner: false,
-        dynamicSql: false
+        dynamicSql: false,
+        span: { start: 0, len: 0 }
     };
     switch (nodeTag) {
         case 'CreateSchemaStmt':
@@ -348,6 +349,8 @@ export function classifyStatements(sql) {
             const nodeTag = stmtNode ? Object.keys(stmtNode)[0] : 'other';
             const node = stmtNode?.[nodeTag] ?? {};
             const facts = classifyOne(nodeTag, node);
+            const start = stmt?.stmt_location ?? 0;
+            facts.span = { start, len: stmt?.stmt_len ?? Math.max(0, sql.length - start) };
             if (stmtNode) {
                 walkSql(stmtNode, createFactsVisitor(facts));
             }

package/esm/router.js

@@ -20,6 +20,19 @@
  * `types` — matching `pg_class` / `pg_proc` / `pg_type`), mirroring the routing
  * model already used by {@link qualifyUnqualified}. Resolution is
  * object-route-first, then the schema-level default, then "leave unchanged".
+ *
+ * An object route may also *rebind* — change the object's **name**, not just
+ * the schema it lives in. Routing preserves identity (the same function, a new
+ * address); rebinding repoints a reference at a *different* object, which is
+ * what lets one implementation of a contract be substituted for another:
+ *
+ * ```ts
+ * { auth: { functions: { uid: { schema: null, name: 'current_user_id' } } } }
+ * // auth.uid()  ->  current_user_id()
+ * ```
+ *
+ * A `null` target schema de-qualifies the reference (relying on `search_path`),
+ * matching the convention used by the extension router.
  */
 const NS_BUCKET = {
     relation: 'relations',
@@ -71,6 +84,36 @@ export class SchemaRouter {
         }
         return false;
     }
+    /**
+     * True when any object route changes a name or de-qualifies (rather than
+     * only moving between schemas). Such rewrites cannot be expressed by the
+     * string-level passes at all, so callers use this to require the AST path.
+     */
+    hasNameRebinds() {
+        return this.nameRebinds().length > 0;
+    }
+    /**
+     * Every object route that rebinds a name or de-qualifies, keyed by source
+     * schema and namespace. Callers use this to report or verify substitutions.
+     */
+    nameRebinds() {
+        const out = [];
+        for (const [schema, route] of this.routes) {
+            for (const ns of ['relation', 'function', 'type']) {
+                const bucket = route[NS_BUCKET[ns]];
+                if (!bucket)
+                    continue;
+                for (const [from, target] of Object.entries(bucket)) {
+                    if (typeof target === 'string')
+                        continue;
+                    if (target.name === undefined && target.schema !== null)
+                        continue;
+                    out.push({ schema, ns, from, to: target });
+                }
+            }
+        }
+        return out;
+    }
     /** Every source schema this router may touch. */
     sourceSchemas() {
         return [...this.routes.keys()];
@@ -82,18 +125,39 @@ export class SchemaRouter {
      * to any object without a specific route.
      */
     resolve(sourceSchema, name, ns = 'unknown') {
+        // A `null` target de-qualifies the reference; the schema-only API cannot
+        // express that, so it reads as "unchanged" here.
+        return this.resolveObject(sourceSchema, name, ns)?.schema ?? undefined;
+    }
+    /**
+     * Resolve the full target for `(sourceSchema, name)` in namespace `ns` — both
+     * the schema the reference should live in and, when the route rebinds, the
+     * name it should be reached by. Returns `undefined` to leave it unchanged.
+     *
+     * In the result, `schema` is `null` when the reference should become
+     * unqualified and `undefined` when only the name changes; `name` is
+     * `undefined` when only the schema changes.
+     */
+    resolveObject(sourceSchema, name, ns = 'unknown') {
         if (!sourceSchema)
             return undefined;
         const route = this.routes.get(sourceSchema);
         if (!route)
             return undefined;
         if (name && (ns === 'relation' || ns === 'function' || ns === 'type')) {
-            const bucket = route[NS_BUCKET[ns]];
-            const mapped = bucket?.[name];
-            if (mapped !== undefined)
-                return mapped;
+            const target = route[NS_BUCKET[ns]]?.[name];
+            if (target !== undefined) {
+                if (typeof target === 'string')
+                    return { schema: target };
+                // An object route naming no schema inherits the schema-level default,
+                // so a pure rebind leaves placement alone.
+                return {
+                    schema: target.schema !== undefined ? target.schema : route.schema,
+                    name: target.name
+                };
+            }
         }
-        return route.schema;
+        return route.schema !== undefined ? { schema: route.schema } : undefined;
     }
     /**
      * Source schemas whose *every* object is guaranteed to move — i.e. those

package/esm/transform.js

@@ -47,6 +47,36 @@ function createResult() {
         errors: [],
     };
 }
+/**
+ * Routing claims: each routable site (a RangeVar, a qualified name list, a
+ * bare schema-name field) is resolved through the router at most once per
+ * transform result.
+ *
+ * The walker visits parents before children, so a statement-level handler
+ * with namespace context (e.g. `AlterFunctionStmt` routing its
+ * `ObjectWithArgs` as a `function`) claims the site before a generic child
+ * visitor (`ObjectWithArgs`, namespace `unknown`) reaches it — first (most
+ * contextual) visitor wins. Without claims a site is routed twice, which
+ * corrupts cyclic mappings (a→b, b→a swaps back) and applies the less precise
+ * namespace second.
+ */
+const routingClaims = new WeakMap();
+function claimSite(result, site, field = '*') {
+    let byNode = routingClaims.get(result);
+    if (!byNode) {
+        byNode = new WeakMap();
+        routingClaims.set(result, byNode);
+    }
+    let fields = byNode.get(site);
+    if (!fields) {
+        fields = new Set();
+        byNode.set(site, fields);
+    }
+    if (fields.has(field))
+        return false;
+    fields.add(field);
+    return true;
+}
 /**
  * Transform a schema name if it exists in the mapping
  */
@@ -75,17 +105,31 @@ export function shouldTransformSchema(schemaName, schemaMapping) {
 export function transformNameList(names, schemaMapping, result, ns = 'unknown') {
     if (!names || names.length < 2)
         return;
+    if (!claimSite(result, names))
+        return;
     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;
-        const objName = names[names.length - 1]?.String?.sval;
-        const newName = router.resolve(schemaName, objName, ns);
-        if (newName && newName !== schemaName) {
+        const last = names[names.length - 1];
+        const objName = last?.String?.sval;
+        const target = router.resolveObject(schemaName, objName, ns);
+        if (!target)
+            return;
+        if (target.name !== undefined && last?.String?.sval) {
             result.schemasFound.add(schemaName);
-            first.String.sval = newName;
-            result.schemasTransformed.set(schemaName, newName);
+            last.String.sval = target.name;
+        }
+        if (target.schema === null) {
+            // De-qualify: drop the schema element and rely on search_path.
+            result.schemasFound.add(schemaName);
+            names.splice(0, 1);
+        }
+        else if (target.schema && target.schema !== schemaName) {
+            result.schemasFound.add(schemaName);
+            first.String.sval = target.schema;
+            result.schemasTransformed.set(schemaName, target.schema);
         }
     }
 }
@@ -98,6 +142,8 @@ export function transformSchemaNameField(container, field, schemaMapping, result
     const schemaName = container?.[field];
     if (typeof schemaName !== 'string')
         return;
+    if (!claimSite(result, container, field))
+        return;
     // 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');
@@ -109,19 +155,35 @@ export function transformSchemaNameField(container, field, schemaMapping, result
 }
 /**
  * Transform a RangeVar-like relation object (has schemaname/relname fields).
- * Many statement nodes embed a relation that the walker does NOT auto-recurse into.
+ * The walker auto-recurses into embedded relations (concrete `RangeVar`
+ * fields are tag-synthesized), so the generic `RangeVar` visitor covers
+ * every occurrence; statement handlers call this directly only when they
+ * carry extra context, and the claim guard keeps each relation routed once.
  */
 export function transformRelation(relation, schemaMapping, result) {
     if (!relation?.schemaname)
         return;
+    if (!claimSite(result, relation))
+        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) {
+    const target = asRouter(schemaMapping).resolveObject(oldName, relation.relname, 'relation');
+    if (!target)
+        return;
+    if (target.name !== undefined && relation.relname) {
         result.schemasFound.add(oldName);
-        relation.schemaname = newName;
-        result.schemasTransformed.set(oldName, newName);
+        relation.relname = target.name;
+    }
+    if (target.schema === null) {
+        // De-qualify: drop the schema qualifier and rely on search_path.
+        result.schemasFound.add(oldName);
+        delete relation.schemaname;
+    }
+    else if (target.schema && target.schema !== oldName) {
+        result.schemasFound.add(oldName);
+        relation.schemaname = target.schema;
+        result.schemasTransformed.set(oldName, target.schema);
     }
 }
 /**
@@ -162,6 +224,8 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         const schemaName = container?.[key];
         if (typeof schemaName !== 'string')
             return;
+        if (!claimSite(result, container, key))
+            return;
         const newName = router.resolve(schemaName, undefined, 'schema');
         if (newName && newName !== schemaName) {
             result.schemasFound.add(schemaName);
@@ -219,15 +283,6 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
             const node = path.node;
             transformNameList(node.funcname, router, result, 'function');
         },
-        // Transform CallStmt (CALL schema.procedure(...)).
-        // Note: The walker does NOT auto-recurse into CallStmt.funccall,
-        // so the FuncCall visitor above never sees it.
-        CallStmt: (path) => {
-            const node = path.node;
-            if (node.funccall?.funcname) {
-                transformNameList(node.funccall.funcname, router, result, 'function');
-            }
-        },
         // Transform TypeName nodes (type references with schema-qualified names)
         TypeName: (path) => {
             const node = path.node;
@@ -285,8 +340,9 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
             }
         },
         // Transform DropStmt (DROP SCHEMA name; DROP TABLE/INDEX/POLICY/TRIGGER/
-        // TYPE/FUNCTION schema.obj). The walker does NOT auto-recurse into
-        // DropStmt.objects.
+        // TYPE/FUNCTION schema.obj) with the namespace derived from removeType,
+        // so object routes apply; claims stop the generic List/ObjectWithArgs
+        // visitors from re-routing the same names with namespace `unknown`.
         DropStmt: (path) => {
             const node = path.node;
             if (node.removeType !== 'OBJECT_SCHEMA' && Array.isArray(node.objects)) {
@@ -320,79 +376,10 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
                 }
             }
         },
-        // Transform InsertStmt (INSERT INTO schema.table)
-        // Note: The walker does NOT auto-recurse into InsertStmt.relation.
-        InsertStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform CreateStmt (CREATE TABLE schema.table)
-        // Note: The walker does NOT auto-recurse into CreateStmt.relation.
-        CreateStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform UpdateStmt (UPDATE schema.table SET ...)
-        // Note: The walker does NOT auto-recurse into UpdateStmt.relation.
-        UpdateStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform DeleteStmt (DELETE FROM schema.table)
-        // Note: The walker does NOT auto-recurse into DeleteStmt.relation.
-        DeleteStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform MergeStmt (MERGE INTO schema.table USING ...)
-        // Note: The walker does NOT auto-recurse into MergeStmt.relation.
-        MergeStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform IndexStmt (CREATE INDEX ... ON schema.table)
-        // Note: The walker does NOT auto-recurse into IndexStmt.relation.
-        IndexStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform Constraint (REFERENCES schema.table for foreign keys)
-        // Note: The walker does NOT auto-recurse into Constraint.pktable.
-        Constraint: (path) => {
-            const node = path.node;
-            if (node.contype === 'CONSTR_FOREIGN' && node.pktable) {
-                transformRelation(node.pktable, schemaMapping, result);
-            }
-        },
-        // Transform CompositeTypeStmt (CREATE TYPE schema.name AS (...))
-        // Note: The walker does NOT auto-recurse into CompositeTypeStmt.typevar.
-        CompositeTypeStmt: (path) => {
-            transformRelation(path.node.typevar, schemaMapping, result);
-        },
-        // Transform ColumnDef (column definitions with schema-qualified types)
-        // Note: The walker does NOT auto-recurse into ColumnDef.typeName.
-        ColumnDef: (path) => {
-            const node = path.node;
-            if (node.typeName?.names) {
-                transformNameList(node.typeName.names, schemaMapping, result, 'type');
-            }
-        },
-        // Transform ViewStmt (CREATE VIEW schema.viewname AS ...)
-        // Note: The walker does NOT auto-recurse into ViewStmt.view.
-        ViewStmt: (path) => {
-            transformRelation(path.node.view, schemaMapping, result);
-        },
-        // Transform AlterTableStmt (ALTER TABLE schema.table ...)
-        // Note: The walker does NOT auto-recurse into AlterTableStmt.relation.
-        AlterTableStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform CreateSeqStmt (CREATE SEQUENCE schema.seqname)
-        // Note: The walker does NOT auto-recurse into CreateSeqStmt.sequence.
-        CreateSeqStmt: (path) => {
-            transformRelation(path.node.sequence, schemaMapping, result);
-        },
-        // Transform AlterSeqStmt (ALTER SEQUENCE schema.seqname [OWNED BY schema.table.col])
-        // Note: The walker does NOT auto-recurse into AlterSeqStmt.sequence.
-        // Also handles OWNED BY clause where the schema name is in DefElem.arg.List.items.
+        // Transform AlterSeqStmt OWNED BY (schema name in DefElem.arg.List.items;
+        // a bare name list no generic visitor covers)
         AlterSeqStmt: (path) => {
             const node = path.node;
-            transformRelation(node.sequence, schemaMapping, result);
-            // Handle OWNED BY option: schema name is in the name list
             if (node.options) {
                 for (const opt of node.options) {
                     if (opt?.DefElem?.defname === 'owned_by' && opt.DefElem?.arg?.List?.items) {
@@ -401,67 +388,12 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
                 }
             }
         },
-        // Transform CreatePolicyStmt (CREATE POLICY ... ON schema.table)
-        // Note: The walker does NOT auto-recurse into CreatePolicyStmt.table.
-        CreatePolicyStmt: (path) => {
-            transformRelation(path.node.table, schemaMapping, result);
-        },
-        // Transform RuleStmt (CREATE RULE ... ON schema.table)
-        // Note: The walker does NOT auto-recurse into RuleStmt.relation.
-        RuleStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform CopyStmt (COPY schema.table ...)
-        // Note: The walker does NOT auto-recurse into CopyStmt.relation.
-        CopyStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform ClusterStmt (CLUSTER schema.table USING index)
-        // Note: The walker does NOT auto-recurse into ClusterStmt.relation.
-        ClusterStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform VacuumRelation (VACUUM/ANALYZE schema.table)
-        // Note: The walker visits VacuumRelation but does NOT recurse into its relation.
-        VacuumRelation: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform RefreshMatViewStmt (REFRESH MATERIALIZED VIEW schema.view)
-        // Note: The walker does NOT auto-recurse into RefreshMatViewStmt.relation.
-        RefreshMatViewStmt: (path) => {
-            transformRelation(path.node.relation, schemaMapping, result);
-        },
-        // Transform CreateTableAsStmt (CREATE MATERIALIZED VIEW schema.viewname AS ...)
-        // Note: The walker does NOT auto-recurse into CreateTableAsStmt.into.rel.
-        CreateTableAsStmt: (path) => {
-            transformRelation(path.node.into?.rel, schemaMapping, result);
-        },
-        // Transform TypeCast nodes (type casts like NULL::schema.type)
-        // Note: The walker visits TypeCast but does NOT recurse into the TypeName node.
-        TypeCast: (path) => {
-            const node = path.node;
-            if (node.typeName?.names) {
-                transformNameList(node.typeName.names, schemaMapping, result, 'type');
-            }
-        },
-        // Transform CreateFunctionStmt (CREATE FUNCTION schema.funcname)
-        // Also handles RETURNS [SETOF] schema.type via returnType.names
+        // Transform CreateFunctionStmt (CREATE FUNCTION schema.funcname).
+        // funcname is a bare name list (no generic visitor); return and parameter
+        // types are TypeName nodes the walker reaches on its own.
         CreateFunctionStmt: (path) => {
             const node = path.node;
             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, '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, 'type');
-                    }
-                }
-            }
             // Transform schema-qualified references inside the function body
             // (AS $$...$$ is a String under the 'as' DefElem, which the walker
             // does not parse as SQL). LANGUAGE plpgsql bodies are additionally
@@ -488,12 +420,11 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
             }
         },
         // Transform CreateTrigStmt (CREATE TRIGGER ... EXECUTE PROCEDURE schema.func)
-        // Note: The walker does NOT auto-recurse into CreateTrigStmt.relation,
-        // so we must explicitly transform the RangeVar here.
+        // funcname is a bare name list; the ON relation is a RangeVar the walker
+        // reaches on its own.
         CreateTrigStmt: (path) => {
             const node = path.node;
             transformNameList(node.funcname, schemaMapping, result, 'function');
-            transformRelation(node.relation, schemaMapping, result);
         },
         // Transform CommentStmt (COMMENT ON TABLE/COLUMN/FUNCTION schema.obj,
         // COMMENT ON SCHEMA schema)
@@ -504,13 +435,14 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
             // For functions, object is { ObjectWithArgs: { objname: [...] } }
             // For schemas, object is a bare { String: { sval } }
             if (node.object) {
+                const ns = namespaceOfObjectType(node.objtype);
                 // Handle List-wrapped objects (COMMENT ON TABLE schema.tbl, COMMENT ON COLUMN schema.tbl.col)
                 if (node.object?.List?.items) {
-                    transformNameList(node.object.List.items, schemaMapping, result);
+                    transformNameList(node.object.List.items, schemaMapping, result, ns);
                 }
                 // Handle ObjectWithArgs-style objects (COMMENT ON FUNCTION schema.func(args))
                 else if (node.object?.ObjectWithArgs?.objname) {
-                    transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result);
+                    transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result, ns);
                 }
                 // Handle bare schema names (COMMENT ON SCHEMA schema)
                 else if (node.object?.String && node.objtype === 'OBJECT_SCHEMA') {
@@ -567,41 +499,41 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
             const node = path.node;
             transformNameList(node.objname, schemaMapping, result);
         },
-        // Transform AlterObjectSchemaStmt (ALTER ... SET SCHEMA newschema)
-        // The walker does NOT auto-recurse into AlterObjectSchemaStmt.relation
-        // or .object, so we must transform relation, object names, and newschema.
+        // Transform AlterObjectSchemaStmt (ALTER ... SET SCHEMA newschema):
+        // object name lists and the destination schema. The relation form is a
+        // RangeVar the walker reaches on its own.
         AlterObjectSchemaStmt: (path) => {
             const node = path.node;
-            transformRelation(node.relation, schemaMapping, result);
+            const ns = namespaceOfObjectType(node.objectType);
             // Non-relation objects (ALTER TYPE/FUNCTION ... SET SCHEMA)
             if (node.object?.List?.items) {
-                transformNameList(node.object.List.items, schemaMapping, result);
+                transformNameList(node.object.List.items, schemaMapping, result, ns);
             }
             else if (node.object?.ObjectWithArgs?.objname) {
-                transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result);
+                transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result, ns);
             }
             else if (node.object?.TypeName?.names) {
-                transformNameList(node.object.TypeName.names, schemaMapping, result);
+                transformNameList(node.object.TypeName.names, schemaMapping, result, ns);
             }
             // Transform the newschema (destination schema)
             transformSchemaNameField(node, 'newschema', schemaMapping, result);
         },
         // Transform RenameStmt (ALTER SCHEMA old RENAME TO new;
-        // ALTER TABLE schema.tbl RENAME ...). The walker does NOT auto-recurse
-        // into RenameStmt.relation or .object.
+        // ALTER TABLE schema.tbl RENAME ...). The relation form is a RangeVar
+        // the walker reaches on its own.
         RenameStmt: (path) => {
             const node = path.node;
-            transformRelation(node.relation, schemaMapping, result);
             if (node.renameType === 'OBJECT_SCHEMA') {
                 // subname is the old schema name; newname is the target
                 transformSchemaNameField(node, 'subname', schemaMapping, result);
                 transformSchemaNameField(node, 'newname', schemaMapping, result);
             }
+            const ns = namespaceOfObjectType(node.renameType);
             if (node.object?.List?.items) {
-                transformNameList(node.object.List.items, schemaMapping, result);
+                transformNameList(node.object.List.items, schemaMapping, result, ns);
             }
             else if (node.object?.ObjectWithArgs?.objname) {
-                transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result);
+                transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result, ns);
             }
         },
         // Transform AlterFunctionStmt (ALTER FUNCTION schema.fn(...) SET ...)
@@ -614,46 +546,26 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         // Transform AlterOwnerStmt (ALTER ... OWNER TO role)
         AlterOwnerStmt: (path) => {
             const node = path.node;
-            transformRelation(node.relation, schemaMapping, result);
+            const ns = namespaceOfObjectType(node.objectType);
             if (node.object?.List?.items) {
-                transformNameList(node.object.List.items, schemaMapping, result);
+                transformNameList(node.object.List.items, schemaMapping, result, ns);
             }
             else if (node.object?.ObjectWithArgs?.objname) {
-                transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result);
+                transformNameList(node.object.ObjectWithArgs.objname, schemaMapping, result, ns);
             }
             else if (node.object?.String && node.objectType === 'OBJECT_SCHEMA') {
                 transformSchemaNameField(node.object.String, 'sval', schemaMapping, result);
             }
         },
-        // Transform CreateCastStmt (CREATE CAST (src AS tgt) WITH FUNCTION fn)
+        // Transform CreateCastStmt (CREATE CAST (src AS tgt) WITH FUNCTION fn).
+        // The function name gets its `function` namespace here; the cast's
+        // source/target/argument types are TypeName nodes the walker reaches on
+        // its own.
         CreateCastStmt: (path) => {
             const node = path.node;
-            if (node.sourcetype?.names) {
-                transformNameList(node.sourcetype.names, schemaMapping, result, 'type');
-            }
-            if (node.targettype?.names) {
-                transformNameList(node.targettype.names, schemaMapping, result, 'type');
-            }
             if (node.func?.objname) {
                 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, 'type');
-                    }
-                    else if (arg?.names) {
-                        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, 'type');
-                    }
-                }
-            }
         },
         // Transform CreateEventTrigStmt (CREATE EVENT TRIGGER ... EXECUTE FUNCTION schema.fn())
         CreateEventTrigStmt: (path) => {

package/facts.d.ts

@@ -94,6 +94,21 @@ export interface StatementFacts {
      * are incomplete and slicing should treat it conservatively.
      */
     dynamicSql: boolean;
+    /**
+     * The statement's source span in the classified script, as reported by the
+     * parser: `start` is the byte offset of the statement's first token, `len`
+     * runs to the end of the statement (the parser excludes the trailing `;`;
+     * for the final statement the span extends to the end of the script).
+     * `sql.slice(span.start, span.start + span.len)` is the statement's
+     * verbatim source, so consumers can carry original text alongside the
+     * facts without a second parse.
+     */
+    span: StatementSpan;
+}
+/** A statement's location in the source script (byte offsets). */
+export interface StatementSpan {
+    start: number;
+    len: number;
 }
 /**
  * Classify each top-level statement in a SQL script into {@link StatementFacts}.

package/facts.js

@@ -157,7 +157,8 @@ function classifyOne(nodeTag, node) {
         bodyReferences: [],
         securityRelevant: SECURITY_TAGS.has(nodeTag),
         securityDefiner: false,
-        dynamicSql: false
+        dynamicSql: false,
+        span: { start: 0, len: 0 }
     };
     switch (nodeTag) {
         case 'CreateSchemaStmt':
@@ -351,6 +352,8 @@ function classifyStatements(sql) {
             const nodeTag = stmtNode ? Object.keys(stmtNode)[0] : 'other';
             const node = stmtNode?.[nodeTag] ?? {};
             const facts = classifyOne(nodeTag, node);
+            const start = stmt?.stmt_location ?? 0;
+            facts.span = { start, len: stmt?.stmt_len ?? Math.max(0, sql.length - start) };
             if (stmtNode) {
                 (0, traverse_1.walk)(stmtNode, createFactsVisitor(facts));
             }

package/index.d.ts

@@ -10,7 +10,7 @@ export type { RoleTransformResult } from './role-transform';
 export { createRoleResult, createRoleVisitor, transformRoles, } from './role-transform';
 export type { ObjectInventory, QualifyResult, QualifyRoutes, QualifyTargetSelector, QualifyUnqualifiedOptions, } from './qualify';
 export { collectCreatedObjects, createQualifyVisitor, mergeInventories, qualifyUnqualified, } from './qualify';
-export type { ObjectNamespace, RouteNamespace, RouteSpec, SchemaRoute, } from './router';
+export type { ObjectNamespace, ObjectRoute, ObjectRouteTarget, RouteNamespace, RouteSpec, SchemaRoute, } from './router';
 export { SchemaRouter } from './router';
 export type { CapturedAsts } from './round-trip';
 export { captureAstsFromSql, captureTransformAsts, firstDifference, normalizeParseTree, validateRoundTrip, } from './round-trip';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgsql/transform",
-  "version": "18.6.0",
+  "version": "18.8.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "AST-based SQL transformation, qualification, classification and closure analysis for PostgreSQL",
   "main": "index.js",
@@ -33,8 +33,8 @@
   },
   "dependencies": {
     "@pgsql/quotes": "18.1.0",
-    "@pgsql/traverse": "18.3.0",
-    "plpgsql-parser": "18.2.1"
+    "@pgsql/traverse": "18.4.0",
+    "plpgsql-parser": "18.2.2"
   },
   "devDependencies": {
     "makage": "^0.1.8"
@@ -49,5 +49,5 @@
     "classify",
     "plpgsql"
   ],
-  "gitHead": "6d3c28348fab5cace76f7c0167f3b73e8f9f67c8"
+  "gitHead": "979608121bc1e7daf2bd11473b2b894266e21bc7"
 }