@pgsql/transform 18.3.1 → 18.5.0

package/esm/facts.js

@@ -1,5 +1,5 @@
 import { walk as walkSql } from '@pgsql/traverse';
-import { transformSync, walk as walkPlpgsql } from 'plpgsql-parser';
+import { parseSql, transformSync, walk as walkPlpgsql } from 'plpgsql-parser';
 const SECURITY_TAGS = new Set([
     'CreatePolicyStmt',
     'AlterPolicyStmt',
@@ -241,6 +241,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 = parseSql(body)?.stmts ?? [];
+        const visitor = createFactsVisitor(facts, facts.bodyReferences);
+        for (const stmt of stmts) {
+            if (stmt?.stmt)
+                walkSql(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}.
  *
@@ -260,6 +297,9 @@ export function classifyStatements(sql) {
             if (stmtNode) {
                 walkSql(stmtNode, createFactsVisitor(facts));
             }
+            if (nodeTag === 'CreateFunctionStmt') {
+                collectSqlBodyReferences(node, facts);
+            }
             allFacts.push(facts);
         }
         for (const fn of ctx.functions ?? []) {

package/esm/index.js

@@ -1,5 +1,6 @@
 export { classifyStatements } from './facts';
 export { collectCreatedObjects, createQualifyVisitor, mergeInventories, qualifyUnqualified, } from './qualify';
+export { SchemaRouter } from './router';
 export { captureAstsFromSql, captureTransformAsts, firstDifference, normalizeParseTree, validateRoundTrip, } from './round-trip';
 export { CLEAN_TREE_VOLATILE_KEYS, cleanTree, normalizeTree, trimDefElemBody, } from './round-trip-core';
 export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, shouldTransformSchema, transformComments, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';

package/esm/router.js

@@ -0,0 +1,121 @@
+/**
+ * Schema routing for the core transform.
+ *
+ * The schema transform historically rewrote every reference to a source
+ * schema to a single target schema (`Map<oldSchema, newSchema>`). That is the
+ * degenerate, whole-schema case of a more general question asked at every
+ * schema-qualified occurrence:
+ *
+ *   given a reference to `(schema, name)` in namespace `ns`, what schema
+ *   should it live in now?
+ *
+ * A {@link SchemaRouter} answers exactly that. It unifies two dimensions:
+ *
+ * - **schema-level** default: move everything in a source schema to one target
+ *   (the classic `Map` behaviour), and
+ * - **object-level** routes: send a specific object — a table, a function, a
+ *   type — to its own target schema, independent of its siblings.
+ *
+ * Object routes are bucketed by PostgreSQL namespace (`relations`, `functions`,
+ * `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".
+ */
+const NS_BUCKET = {
+    relation: 'relations',
+    function: 'functions',
+    type: 'types'
+};
+/**
+ * Resolves the target schema for any schema-qualified occurrence, unifying the
+ * whole-schema `Map` behaviour and per-object routing behind one `resolve`.
+ */
+export class SchemaRouter {
+    routes;
+    constructor(routes = {}) {
+        this.routes = routes instanceof Map ? new Map(routes) : new Map(Object.entries(routes));
+    }
+    /** Build a router from the classic whole-schema `Map<oldSchema,newSchema>`. */
+    static fromSchemaMap(mapping) {
+        const entries = mapping instanceof Map ? [...mapping.entries()] : Object.entries(mapping);
+        const spec = {};
+        for (const [from, to] of entries)
+            spec[from] = { schema: to };
+        return new SchemaRouter(spec);
+    }
+    /** Coerce a `Map`, plain mapping, or existing router into a router. */
+    static from(source) {
+        if (source instanceof SchemaRouter)
+            return source;
+        return SchemaRouter.fromSchemaMap(source);
+    }
+    /** True when this router might rewrite something in `sourceSchema`. */
+    has(sourceSchema) {
+        if (!sourceSchema)
+            return false;
+        return this.routes.has(sourceSchema);
+    }
+    /** True when the router carries no routes at all. */
+    get size() {
+        return this.routes.size;
+    }
+    /**
+     * True when any route targets individual objects (as opposed to whole
+     * schemas). Object routes require AST-precise rewriting of opaque function
+     * bodies; whole-schema routes are handled by the cheaper string passes.
+     */
+    hasObjectRoutes() {
+        for (const route of this.routes.values()) {
+            if (route.relations || route.functions || route.types)
+                return true;
+        }
+        return false;
+    }
+    /** Every source schema this router may touch. */
+    sourceSchemas() {
+        return [...this.routes.keys()];
+    }
+    /**
+     * Resolve the target schema for `(sourceSchema, name)` in namespace `ns`,
+     * or `undefined` to leave it unchanged. Object routes win over the
+     * schema-level default; the default applies to schema-level operations and
+     * to any object without a specific route.
+     */
+    resolve(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;
+        }
+        return route.schema;
+    }
+    /**
+     * Source schemas whose *every* object is guaranteed to move — i.e. those
+     * with a schema-level default. After a transform, none of these should
+     * survive as a qualifier; partially-routed schemas may legitimately remain,
+     * so they are excluded from the strict leftover check.
+     */
+    fullyMovedSchemas() {
+        const out = new Map();
+        for (const [from, route] of this.routes) {
+            if (route.schema !== undefined)
+                out.set(from, route.schema);
+        }
+        return out;
+    }
+    /**
+     * A flat schema-level view (`oldSchema → newSchema`) for legacy string-level
+     * passes and comment/verify/JSON rewrites that operate per source schema.
+     * Only schema-level defaults are included; object-only routes carry no single
+     * schema answer and are omitted.
+     */
+    schemaLevelMap() {
+        return this.fullyMovedSchemas();
+    }
+}