@pgsql/transform 18.3.1 → 18.4.1

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();
+    }
+}