@pgsql/transform 18.5.0 → 18.7.0

package/extension-router.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * Extension routing for the core transform.
+ *
+ * A PostgreSQL extension is installed into exactly one schema, and the objects
+ * it provides (functions, types, operators) live in that schema. Two databases
+ * can install the *same* extension into *different* schemas — one leaves it in
+ * `public`, another isolates it in a dedicated schema — so portable SQL must be
+ * able to move an extension's install site **and** rewrite every reference to
+ * the symbols it provides.
+ *
+ * This is a distinct problem from {@link SchemaRouter}, which routes objects the
+ * SQL itself creates. Here the objects are owned by an extension and are not
+ * declared in the script; the only way to know that a bare `crypt(...)` call
+ * belongs to `pgcrypto` (and must move when `pgcrypto` moves) is an
+ * **inventory** of which symbols each extension provides. That inventory is
+ * also **version-aware**: a symbol can graduate into the server core and cease
+ * to be extension-owned (the canonical case is `gen_random_uuid()`, provided by
+ * `pgcrypto` before PostgreSQL 13 and part of core `pg_catalog` from 13 on — it
+ * must never be routed on 13+).
+ *
+ * An {@link ExtensionRouter} answers two questions:
+ *
+ * - **install**: where should `CREATE EXTENSION <e>` (or `ALTER EXTENSION <e>
+ *   SET SCHEMA`) place the extension?
+ * - **reference**: given a reference to a symbol `(schema, name)` in namespace
+ *   `ns`, what schema should it live in now — including stripping the qualifier
+ *   entirely (relying on `search_path`) when the target is "unqualified".
+ *
+ * A schema of `null` denotes the **unqualified** site: a bare reference
+ * (`crypt(...)`) or installing an extension with no explicit `SCHEMA` clause.
+ * This makes the router fully bidirectional: `null -> 'extensions'` qualifies
+ * bare references, and `'extensions' -> null` strips them back to bare.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionRouter = exports.COMMON_EXTENSIONS = void 0;
+const DEFAULT_SERVER_VERSION = 9999;
+/**
+ * A curated, platform-agnostic inventory of common contrib/extension symbols.
+ * Intentionally minimal and conservative — only well-known, stable symbols are
+ * listed so routing never touches something it cannot prove belongs to the
+ * extension. Callers extend this via {@link ExtensionRouterOptions.inventory}.
+ */
+exports.COMMON_EXTENSIONS = [
+    {
+        name: 'pgcrypto',
+        relocatable: true,
+        symbols: [
+            { name: 'crypt' },
+            { name: 'gen_salt' },
+            { name: 'digest' },
+            { name: 'hmac' },
+            { name: 'encrypt' },
+            { name: 'decrypt' },
+            { name: 'encrypt_iv' },
+            { name: 'decrypt_iv' },
+            { name: 'gen_random_bytes' },
+            // Provided by pgcrypto before PG13; part of core pg_catalog from 13 on.
+            { name: 'gen_random_uuid', coreSince: 13 },
+            { name: 'pgp_sym_encrypt' },
+            { name: 'pgp_sym_decrypt' },
+            { name: 'pgp_pub_encrypt' },
+            { name: 'pgp_pub_decrypt' }
+        ]
+    },
+    {
+        name: 'uuid-ossp',
+        relocatable: true,
+        symbols: [
+            { name: 'uuid_generate_v1' },
+            { name: 'uuid_generate_v1mc' },
+            { name: 'uuid_generate_v3' },
+            { name: 'uuid_generate_v4' },
+            { name: 'uuid_generate_v5' },
+            { name: 'uuid_nil' }
+        ]
+    },
+    {
+        name: 'citext',
+        relocatable: true,
+        symbols: [
+            { name: 'citext', namespace: 'type' },
+            { name: 'citextin', namespace: 'function' },
+            { name: 'citext_hash', namespace: 'function' }
+        ]
+    },
+    {
+        name: 'pg_trgm',
+        relocatable: true,
+        symbols: [
+            { name: 'similarity' },
+            { name: 'show_trgm' },
+            { name: 'word_similarity' },
+            { name: 'strict_word_similarity' }
+        ]
+    },
+    {
+        name: 'ltree',
+        relocatable: true,
+        symbols: [
+            { name: 'ltree', namespace: 'type' },
+            { name: 'lquery', namespace: 'type' },
+            { name: 'ltxtquery', namespace: 'type' },
+            { name: 'subltree' },
+            { name: 'subpath' },
+            { name: 'nlevel' },
+            { name: 'lca' }
+        ]
+    },
+    {
+        name: 'hstore',
+        relocatable: true,
+        symbols: [{ name: 'hstore', namespace: 'type' }]
+    },
+    {
+        name: 'unaccent',
+        relocatable: true,
+        symbols: [{ name: 'unaccent' }]
+    }
+];
+/**
+ * Resolves install-schema and symbol-reference routing for extensions, backed
+ * by a version-aware symbol inventory.
+ */
+class ExtensionRouter {
+    routes;
+    serverVersion;
+    definitions;
+    /** `${namespace}:${name}` -> providing extension (+ version predicate). */
+    symbolIndex;
+    constructor(routes = {}, options = {}) {
+        this.routes = routes instanceof Map ? new Map(routes) : new Map(Object.entries(routes));
+        this.serverVersion = options.serverVersion ?? DEFAULT_SERVER_VERSION;
+        const inventory = options.inventory ?? exports.COMMON_EXTENSIONS;
+        this.definitions = new Map(inventory.map(def => [def.name, def]));
+        this.symbolIndex = new Map();
+        for (const def of inventory) {
+            for (const sym of def.symbols) {
+                const key = symbolKey(sym.namespace ?? 'function', sym.name);
+                // First definition wins; inventories should not double-claim a symbol.
+                if (!this.symbolIndex.has(key)) {
+                    this.symbolIndex.set(key, { extension: def.name, coreSince: sym.coreSince });
+                }
+            }
+        }
+    }
+    /**
+     * Build a router that moves the given extensions (default: every inventoried
+     * one) to a single `targetSchema`, rewriting their references from `public`
+     * and from bare (unqualified) sites. Passing `null` as `targetSchema` strips
+     * qualification instead (the "repollute public / rely on search_path"
+     * direction).
+     */
+    static toSchema(targetSchema, options = {}) {
+        const inventory = options.inventory ?? exports.COMMON_EXTENSIONS;
+        const names = options.extensions ?? inventory.map(d => d.name);
+        const from = options.from ?? ['public', null];
+        const spec = {};
+        for (const name of names)
+            spec[name] = { to: targetSchema, from };
+        return new ExtensionRouter(spec, options);
+    }
+    /** Coerce a spec, map, or existing router into a router. */
+    static from(source, options) {
+        if (source instanceof ExtensionRouter)
+            return source;
+        return new ExtensionRouter(source, options);
+    }
+    /** True when no extension routes are configured. */
+    get size() {
+        return this.routes.size;
+    }
+    /** Extension names this router may rewrite. */
+    routedExtensions() {
+        return [...this.routes.keys()];
+    }
+    /** True when any configured extension has inventoried symbols to rewrite. */
+    hasSymbolRoutes() {
+        for (const name of this.routes.keys()) {
+            const def = this.definitions.get(name);
+            if (def && !def.fixedSchema && def.symbols.length > 0)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Resolve the install schema for `CREATE EXTENSION <extname>` /
+     * `ALTER EXTENSION <extname> SET SCHEMA`. Returns:
+     * - a string to place/keep the extension in that schema,
+     * - `null` to install with no explicit `SCHEMA` clause (server default),
+     * - `undefined` to leave the statement unchanged (no route, or the extension
+     *   is pinned to a fixed schema).
+     */
+    resolveInstall(extname) {
+        if (!extname)
+            return undefined;
+        const route = this.routes.get(extname);
+        if (!route)
+            return undefined;
+        if (this.definitions.get(extname)?.fixedSchema !== undefined)
+            return undefined;
+        return route.to;
+    }
+    /**
+     * Resolve a rewrite for a reference to `(schema, name)` in namespace `ns`,
+     * where `schema` is `null` for a bare reference. Returns the target
+     * ({@link SymbolRewrite}) or `undefined` to leave the reference unchanged.
+     *
+     * A reference is rewritten only when the inventory proves the symbol belongs
+     * to a routed extension, the symbol has not graduated to core at the target
+     * server version, the current schema is one the route rewrites `from`, and
+     * the destination actually differs from where it already is.
+     */
+    resolveSymbol(schema, name, ns) {
+        if (!name)
+            return undefined;
+        const indexed = this.symbolIndex.get(symbolKey(ns, name));
+        if (!indexed)
+            return undefined;
+        // Graduated into core at/after the target server version — resolves from
+        // pg_catalog and must not be tied to the extension's schema.
+        if (indexed.coreSince !== undefined && this.serverVersion >= indexed.coreSince)
+            return undefined;
+        const route = this.routes.get(indexed.extension);
+        if (!route)
+            return undefined;
+        if (this.definitions.get(indexed.extension)?.fixedSchema !== undefined)
+            return undefined;
+        const current = schema ?? null;
+        if (route.from !== undefined && !route.from.includes(current))
+            return undefined;
+        if (current === route.to)
+            return undefined;
+        return { to: route.to };
+    }
+}
+exports.ExtensionRouter = ExtensionRouter;
+function symbolKey(ns, name) {
+    return `${ns}:${name}`;
+}

package/extension-transform.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AST transform that applies an {@link ExtensionRouter}.
+ *
+ * Unlike the schema transform — which only rewrites string *fields* already
+ * present on a node — moving an extension changes the **shape** of the AST:
+ *
+ * - `CREATE EXTENSION <e>` with no `SCHEMA` clause must gain one, which means
+ *   constructing a new `DefElem` node and attaching it to a (possibly absent)
+ *   `options` array; the reverse strips the `DefElem` (and empties `options`).
+ * - a bare `crypt(...)` reference gains a schema qualifier (a `String` node is
+ *   prepended to `funcname`), and the reverse removes it.
+ *
+ * All rewrites are AST-precise and driven by the router's version-aware symbol
+ * inventory, so built-ins that merely share a name with an extension symbol
+ * (and symbols that have graduated into core) are left untouched.
+ */
+import type { ExtensionRouteSpec, ExtensionRouterOptions } from './extension-router';
+import { ExtensionRouter } from './extension-router';
+/** What an extension transform changed. */
+export interface ExtensionTransformResult {
+    /** Extensions whose install schema was rewritten: extname -> target (null = unqualified). */
+    installsMoved: Map<string, string | null>;
+    /** Symbol references rewritten, counted by bare symbol name. */
+    symbolsRewritten: Map<string, number>;
+}
+/** Create a fresh result tracker. */
+export declare function createExtensionResult(): ExtensionTransformResult;
+/**
+ * Create a SQL AST visitor that applies extension routing. Composable with the
+ * walkers used by the core transform and by PL/pgSQL body traversal.
+ */
+export declare function createExtensionVisitor(router: ExtensionRouter, result: ExtensionTransformResult): {
+    CreateExtensionStmt: (path: any) => void;
+    AlterObjectSchemaStmt: (path: any) => void;
+    FuncCall: (path: any) => void;
+    CallStmt: (path: any) => void;
+    TypeName: (path: any) => void;
+    CreateFunctionStmt: (path: any) => void;
+};
+/**
+ * Apply extension routing to a SQL string: parse -> walk -> deparse, including
+ * PL/pgSQL and `LANGUAGE sql` bodies. Returns the rewritten SQL and a summary
+ * of what changed.
+ */
+export declare function transformExtensions(sql: string, router: ExtensionRouter | ExtensionRouteSpec, options?: ExtensionRouterOptions): {
+    sql: string;
+    result: ExtensionTransformResult;
+};

package/extension-transform.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * AST transform that applies an {@link ExtensionRouter}.
+ *
+ * Unlike the schema transform — which only rewrites string *fields* already
+ * present on a node — moving an extension changes the **shape** of the AST:
+ *
+ * - `CREATE EXTENSION <e>` with no `SCHEMA` clause must gain one, which means
+ *   constructing a new `DefElem` node and attaching it to a (possibly absent)
+ *   `options` array; the reverse strips the `DefElem` (and empties `options`).
+ * - a bare `crypt(...)` reference gains a schema qualifier (a `String` node is
+ *   prepended to `funcname`), and the reverse removes it.
+ *
+ * All rewrites are AST-precise and driven by the router's version-aware symbol
+ * inventory, so built-ins that merely share a name with an extension symbol
+ * (and symbols that have graduated into core) are left untouched.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtensionResult = createExtensionResult;
+exports.createExtensionVisitor = createExtensionVisitor;
+exports.transformExtensions = transformExtensions;
+const traverse_1 = require("@pgsql/traverse");
+const plpgsql_parser_1 = require("plpgsql-parser");
+const extension_router_1 = require("./extension-router");
+/** Create a fresh result tracker. */
+function createExtensionResult() {
+    return { installsMoved: new Map(), symbolsRewritten: new Map() };
+}
+function schemaStringNode(schema) {
+    return { String: { sval: schema } };
+}
+/**
+ * Rewrite a (possibly schema-qualified) name list in place against the router.
+ * `names` is the node's own array (`funcname`, `TypeName.names`, ...); it is
+ * mutated in place so the enclosing node keeps referring to it.
+ */
+function rewriteNameList(names, router, ns, result) {
+    if (!Array.isArray(names) || names.length === 0)
+        return;
+    const parts = names.map((n) => n?.String?.sval);
+    if (parts.some(p => typeof p !== 'string'))
+        return; // non-identifier element (e.g. %type)
+    const name = parts[parts.length - 1];
+    const schema = parts.length >= 2 ? parts[parts.length - 2] : null;
+    const rewrite = router.resolveSymbol(schema, name, ns);
+    if (!rewrite)
+        return;
+    if (rewrite.to === null) {
+        // Strip qualification: keep only the bare name node.
+        names.splice(0, names.length - 1);
+    }
+    else if (schema === null) {
+        // Qualify a bare reference: prepend the target schema.
+        names.unshift(schemaStringNode(rewrite.to));
+    }
+    else {
+        // Requalify: rewrite the existing schema element.
+        names[names.length - 2].String.sval = rewrite.to;
+    }
+    result.symbolsRewritten.set(name, (result.symbolsRewritten.get(name) ?? 0) + 1);
+}
+/** Read/replace the `schema` DefElem inside a `CreateExtensionStmt.options`. */
+function setExtensionSchemaOption(node, target) {
+    const options = Array.isArray(node.options) ? node.options : [];
+    const idx = options.findIndex((opt) => opt?.DefElem?.defname === 'schema');
+    if (target === null) {
+        // Install with no explicit SCHEMA clause: remove any existing option.
+        if (idx === -1)
+            return false;
+        options.splice(idx, 1);
+        if (options.length === 0)
+            delete node.options;
+        else
+            node.options = options;
+        return true;
+    }
+    const defElem = {
+        DefElem: {
+            defname: 'schema',
+            arg: { String: { sval: target } },
+            defaction: 'DEFELEM_UNSPEC'
+        }
+    };
+    if (idx === -1) {
+        options.push(defElem);
+    }
+    else {
+        const existing = options[idx].DefElem;
+        if (existing.arg?.String?.sval === target)
+            return false;
+        existing.arg = { String: { sval: target } };
+    }
+    node.options = options;
+    return true;
+}
+/**
+ * Create a SQL AST visitor that applies extension routing. Composable with the
+ * walkers used by the core transform and by PL/pgSQL body traversal.
+ */
+function createExtensionVisitor(router, result) {
+    const rewriteBody = router.hasSymbolRoutes();
+    return {
+        CreateExtensionStmt: (path) => {
+            const node = path.node;
+            const target = router.resolveInstall(node.extname);
+            if (target === undefined)
+                return;
+            if (setExtensionSchemaOption(node, target)) {
+                result.installsMoved.set(node.extname, target);
+            }
+        },
+        // ALTER EXTENSION <e> SET SCHEMA <newschema>. The walker does not recurse
+        // into AlterObjectSchemaStmt.object; a null target has no SET SCHEMA form
+        // (a schema must be named), so it is left unchanged.
+        AlterObjectSchemaStmt: (path) => {
+            const node = path.node;
+            if (node.objectType !== 'OBJECT_EXTENSION')
+                return;
+            const extname = node.object?.String?.sval;
+            const target = router.resolveInstall(extname);
+            if (typeof target !== 'string' || target === node.newschema)
+                return;
+            node.newschema = target;
+            result.installsMoved.set(extname, target);
+        },
+        FuncCall: (path) => {
+            rewriteNameList(path.node.funcname, router, 'function', result);
+        },
+        // The walker does not auto-recurse into CallStmt.funccall.
+        CallStmt: (path) => {
+            if (path.node.funccall) {
+                rewriteNameList(path.node.funccall.funcname, router, 'function', result);
+            }
+        },
+        TypeName: (path) => {
+            rewriteNameList(path.node.names, router, 'type', result);
+        },
+        CreateFunctionStmt: (path) => {
+            const node = path.node;
+            if (!rewriteBody)
+                return;
+            // LANGUAGE sql bodies are opaque strings to the walker; parse and rewrite
+            // them separately (PL/pgSQL bodies ride the hydrated walk in transformExtensions).
+            const isPlpgsql = (node.options ?? []).some((opt) => opt?.DefElem?.defname === 'language' &&
+                opt.DefElem.arg?.String?.sval === 'plpgsql');
+            if (isPlpgsql || !Array.isArray(node.options))
+                return;
+            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') {
+                            try {
+                                item.String.sval = rewriteSqlBodyString(item.String.sval, router, result);
+                            }
+                            catch {
+                                // Not parseable standalone (e.g. C symbol names) — leave as-is.
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+/** Rewrite extension references inside a `LANGUAGE sql` body string. */
+function rewriteSqlBodyString(body, router, result) {
+    const stmts = (0, plpgsql_parser_1.parseSql)(body)?.stmts ?? [];
+    if (stmts.length === 0)
+        return body;
+    const visitor = createExtensionVisitor(router, result);
+    const pieces = [];
+    for (const stmt of stmts) {
+        if (!stmt?.stmt)
+            continue;
+        (0, traverse_1.walk)(stmt.stmt, visitor);
+        pieces.push(plpgsql_parser_1.Deparser.deparse(stmt.stmt));
+    }
+    return pieces.join(';\n');
+}
+/**
+ * Apply extension routing to a SQL string: parse -> walk -> deparse, including
+ * PL/pgSQL and `LANGUAGE sql` bodies. Returns the rewritten SQL and a summary
+ * of what changed.
+ */
+function transformExtensions(sql, router, options = {}) {
+    const resolved = extension_router_1.ExtensionRouter.from(router, options);
+    const result = createExtensionResult();
+    const out = (0, plpgsql_parser_1.transformSync)(sql, (ctx) => {
+        const stmts = ctx.sql?.stmts ?? [];
+        const visitor = createExtensionVisitor(resolved, result);
+        for (const stmt of stmts) {
+            if (stmt?.stmt)
+                (0, traverse_1.walk)(stmt.stmt, visitor);
+        }
+        if (resolved.hasSymbolRoutes()) {
+            for (const fn of ctx.functions ?? []) {
+                if (fn.plpgsql?.hydrated) {
+                    (0, plpgsql_parser_1.walk)(fn.plpgsql.hydrated, {}, {
+                        walkSqlExpressions: true,
+                        sqlVisitor: visitor
+                    });
+                }
+            }
+        }
+    }, { hydrate: true, pretty: true });
+    return { sql: out, result };
+}

package/facts.d.ts

@@ -8,7 +8,38 @@ export interface QualifiedName {
 /**
  * Coarse statement classification used for tier/package sorting.
  */
-export type StatementKind = 'schema' | 'table' | 'view' | 'index' | 'type' | 'function' | 'trigger' | 'policy' | 'grant' | 'rls_enable' | 'fk_constraint' | 'constraint' | 'comment' | 'seed_dml' | 'other';
+export type StatementKind = 'schema' | 'extension' | 'table' | 'view' | 'index' | 'type' | 'function' | 'trigger' | 'policy' | 'grant' | 'rls_enable' | 'fk_constraint' | 'constraint' | 'comment' | 'seed_dml' | 'other';
+/**
+ * The action a statement performs on a PostgreSQL extension.
+ *
+ * - `create` — `CREATE EXTENSION` (`CreateExtensionStmt`).
+ * - `set_schema` — `ALTER EXTENSION ... SET SCHEMA` (`AlterObjectSchemaStmt`
+ *   with `objectType: OBJECT_EXTENSION`); only succeeds for relocatable
+ *   extensions, so it is surfaced as its own action.
+ * - `drop` — `DROP EXTENSION` (`DropStmt` with `removeType: OBJECT_EXTENSION`).
+ */
+export type ExtensionAction = 'create' | 'set_schema' | 'drop';
+/**
+ * Facts about an extension-level statement. Unlike ordinary objects, an
+ * extension is installed into exactly one schema and its member objects are
+ * renamed with it, so the relevant fact is the extension name plus the schema
+ * it is (being) placed in.
+ */
+export interface ExtensionFact {
+    /** The extension name (`CREATE EXTENSION <name>`). */
+    name: string;
+    /**
+     * The schema the statement places the extension in, or `null` when none is
+     * specified (`CREATE EXTENSION <name>` with no `SCHEMA` clause installs into
+     * the current default — typically `public` or the extension's fixed schema).
+     * `DROP EXTENSION` carries no schema.
+     */
+    schema: string | null;
+    /** Which extension operation this statement performs. */
+    action: ExtensionAction;
+    /** `CREATE EXTENSION IF NOT EXISTS`. */
+    ifNotExists?: boolean;
+}
 /**
  * AST-derived facts about a single top-level SQL statement.
  *
@@ -42,6 +73,11 @@ export interface StatementFacts {
     referencedSchemas: string[];
     /** Role names granted to, owning, or bound by this statement. */
     roles: string[];
+    /**
+     * For extension-level statements (`kind: 'extension'`): the extension being
+     * created, relocated, or dropped. Absent for every other statement.
+     */
+    extension?: ExtensionFact;
     /** Foreign-key target tables (from column/table FK constraints). */
     fkTargets: QualifiedName[];
     /**

package/facts.js

@@ -16,6 +16,7 @@ const SECURITY_TAGS = new Set([
 ]);
 const KIND_BY_TAG = {
     CreateSchemaStmt: 'schema',
+    CreateExtensionStmt: 'extension',
     CreateStmt: 'table',
     ViewStmt: 'view',
     IndexStmt: 'index',
@@ -40,6 +41,23 @@ const KIND_BY_TAG = {
 function qn(schema, name) {
     return { schema: schema ?? null, name };
 }
+/**
+ * Read the `SCHEMA <name>` clause of a `CreateExtensionStmt` from its options
+ * (`{ DefElem: { defname: 'schema', arg: { String: { sval } } } }`), or `null`
+ * when the statement specifies no schema.
+ */
+function extensionSchemaOption(options) {
+    if (!Array.isArray(options))
+        return null;
+    for (const opt of options) {
+        const def = opt?.DefElem;
+        if (def?.defname === 'schema') {
+            const sval = def.arg?.String?.sval;
+            return typeof sval === 'string' ? sval : null;
+        }
+    }
+    return null;
+}
 function nameListToQualified(names) {
     if (!Array.isArray(names) || names.length === 0)
         return null;
@@ -145,6 +163,14 @@ function classifyOne(nodeTag, node) {
         case 'CreateSchemaStmt':
             facts.creates.push(qn(null, node.schemaname));
             break;
+        case 'CreateExtensionStmt':
+            facts.extension = {
+                name: node.extname,
+                schema: extensionSchemaOption(node.options),
+                action: 'create',
+                ifNotExists: node.if_not_exists === true
+            };
+            break;
         case 'CreateStmt':
         case 'ViewStmt': {
             const rel = nodeTag === 'ViewStmt' ? node.view : node.relation;
@@ -206,6 +232,34 @@ function classifyOne(nodeTag, node) {
                 facts.creates.push(name);
             break;
         }
+        case 'AlterObjectSchemaStmt':
+            // ALTER EXTENSION <name> SET SCHEMA <newschema>. Other object types
+            // (TABLE/TYPE/FUNCTION ... SET SCHEMA) keep their default classification.
+            if (node.objectType === 'OBJECT_EXTENSION') {
+                const name = node.object?.String?.sval;
+                if (typeof name === 'string') {
+                    facts.kind = 'extension';
+                    facts.extension = {
+                        name,
+                        schema: typeof node.newschema === 'string' ? node.newschema : null,
+                        action: 'set_schema'
+                    };
+                }
+            }
+            break;
+        case 'DropStmt':
+            // DROP EXTENSION <name> [, ...]. Extension names are bare String nodes.
+            // Other DROP object types keep their default classification. When
+            // several extensions are dropped in one statement the first names the
+            // fact; the full list stays available via the raw node.
+            if (node.removeType === 'OBJECT_EXTENSION' && Array.isArray(node.objects)) {
+                const name = node.objects[0]?.String?.sval;
+                if (typeof name === 'string') {
+                    facts.kind = 'extension';
+                    facts.extension = { name, schema: null, action: 'drop' };
+                }
+            }
+            break;
         case 'AlterTableStmt': {
             if (node.relation) {
                 facts.creates.push(qn(node.relation.schemaname ?? null, node.relation.relname));

package/index.d.ts

@@ -1,8 +1,16 @@
-export type { QualifiedName, StatementFacts, StatementKind, } from './facts';
+export type { ExtensionAction, ExtensionFact, QualifiedName, StatementFacts, StatementKind, } from './facts';
 export { classifyStatements } from './facts';
+export type { ExtensionDefinition, ExtensionRoute, ExtensionRouteSpec, ExtensionRouterOptions, ExtensionSymbol, ExtensionSymbolNamespace, SymbolRewrite, } from './extension-router';
+export { COMMON_EXTENSIONS, ExtensionRouter } from './extension-router';
+export type { ExtensionTransformResult } from './extension-transform';
+export { createExtensionResult, createExtensionVisitor, transformExtensions, } from './extension-transform';
+export type { RoleRouteSpec } from './role-router';
+export { RoleRouter } from './role-router';
+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/index.js

@@ -1,8 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walkPlpgsqlForSchemas = exports.validateNoUntransformedSchemas = exports.transformVerifyCalls = exports.transformSqlStatement = exports.transformSql = exports.transformSchemaName = exports.transformRelation = exports.transformPlpgsqlTypeString = exports.transformPlpgsqlTypeAst = exports.transformNameList = exports.transformJsonStringValues = exports.transformComments = exports.shouldTransformSchema = exports.extractPgpmHeader = exports.escapeRegexp = exports.createSqlVisitor = exports.createPlpgsqlVisitor = exports.trimDefElemBody = exports.normalizeTree = exports.cleanTree = exports.CLEAN_TREE_VOLATILE_KEYS = exports.validateRoundTrip = exports.normalizeParseTree = exports.firstDifference = exports.captureTransformAsts = exports.captureAstsFromSql = exports.SchemaRouter = exports.qualifyUnqualified = exports.mergeInventories = exports.createQualifyVisitor = exports.collectCreatedObjects = exports.classifyStatements = void 0;
+exports.walkPlpgsqlForSchemas = exports.validateNoUntransformedSchemas = exports.transformVerifyCalls = exports.transformSqlStatement = exports.transformSql = exports.transformSchemaName = exports.transformRelation = exports.transformPlpgsqlTypeString = exports.transformPlpgsqlTypeAst = exports.transformNameList = exports.transformJsonStringValues = exports.transformComments = exports.shouldTransformSchema = exports.extractPgpmHeader = exports.escapeRegexp = exports.createSqlVisitor = exports.createPlpgsqlVisitor = exports.trimDefElemBody = exports.normalizeTree = exports.cleanTree = exports.CLEAN_TREE_VOLATILE_KEYS = exports.validateRoundTrip = exports.normalizeParseTree = exports.firstDifference = exports.captureTransformAsts = exports.captureAstsFromSql = exports.SchemaRouter = exports.qualifyUnqualified = exports.mergeInventories = exports.createQualifyVisitor = exports.collectCreatedObjects = exports.transformRoles = exports.createRoleVisitor = exports.createRoleResult = exports.RoleRouter = exports.transformExtensions = exports.createExtensionVisitor = exports.createExtensionResult = exports.ExtensionRouter = exports.COMMON_EXTENSIONS = exports.classifyStatements = void 0;
 var facts_1 = require("./facts");
 Object.defineProperty(exports, "classifyStatements", { enumerable: true, get: function () { return facts_1.classifyStatements; } });
+var extension_router_1 = require("./extension-router");
+Object.defineProperty(exports, "COMMON_EXTENSIONS", { enumerable: true, get: function () { return extension_router_1.COMMON_EXTENSIONS; } });
+Object.defineProperty(exports, "ExtensionRouter", { enumerable: true, get: function () { return extension_router_1.ExtensionRouter; } });
+var extension_transform_1 = require("./extension-transform");
+Object.defineProperty(exports, "createExtensionResult", { enumerable: true, get: function () { return extension_transform_1.createExtensionResult; } });
+Object.defineProperty(exports, "createExtensionVisitor", { enumerable: true, get: function () { return extension_transform_1.createExtensionVisitor; } });
+Object.defineProperty(exports, "transformExtensions", { enumerable: true, get: function () { return extension_transform_1.transformExtensions; } });
+var role_router_1 = require("./role-router");
+Object.defineProperty(exports, "RoleRouter", { enumerable: true, get: function () { return role_router_1.RoleRouter; } });
+var role_transform_1 = require("./role-transform");
+Object.defineProperty(exports, "createRoleResult", { enumerable: true, get: function () { return role_transform_1.createRoleResult; } });
+Object.defineProperty(exports, "createRoleVisitor", { enumerable: true, get: function () { return role_transform_1.createRoleVisitor; } });
+Object.defineProperty(exports, "transformRoles", { enumerable: true, get: function () { return role_transform_1.transformRoles; } });
 var qualify_1 = require("./qualify");
 Object.defineProperty(exports, "collectCreatedObjects", { enumerable: true, get: function () { return qualify_1.collectCreatedObjects; } });
 Object.defineProperty(exports, "createQualifyVisitor", { enumerable: true, get: function () { return qualify_1.createQualifyVisitor; } });