@pgsql/transform 18.1.1 → 18.3.1

package/facts.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A (possibly schema-qualified) object name extracted from a statement.
+ */
+export interface QualifiedName {
+    schema: string | null;
+    name: string;
+}
+/**
+ * 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';
+/**
+ * AST-derived facts about a single top-level SQL statement.
+ *
+ * Read-only: classification never modifies the statement. Facts are the
+ * substrate for classifier-driven slicing (schema / functionality / security
+ * tiers) — replacing path/name-glob decisions with computed properties like
+ * "this trigger function references billing".
+ */
+export interface StatementFacts {
+    /** Coarse category of the statement. */
+    kind: StatementKind;
+    /** The raw parser node tag (e.g. `CreateStmt`, `CreatePolicyStmt`). */
+    nodeTag: string;
+    /** Objects this statement creates or directly targets. */
+    creates: QualifiedName[];
+    /**
+     * Schema-qualified objects this statement references — tables, functions
+     * and types reached anywhere in the statement, including PL/pgSQL bodies.
+     * Unqualified references are omitted (they resolve via search_path and
+     * carry no cross-schema information).
+     */
+    references: QualifiedName[];
+    /**
+     * The subset of `references` reached only inside a PL/pgSQL body. These
+     * are late-binding: Postgres resolves them at call time, not at CREATE
+     * time, so they do not constrain deploy order (and legitimately form
+     * recursion cycles between functions).
+     */
+    bodyReferences: QualifiedName[];
+    /** Distinct schemas reached by `references`. */
+    referencedSchemas: string[];
+    /** Role names granted to, owning, or bound by this statement. */
+    roles: string[];
+    /** Foreign-key target tables (from column/table FK constraints). */
+    fkTargets: QualifiedName[];
+    /**
+     * Whether the statement is part of the security surface: policies, grants,
+     * RLS enable/force, security labels, ownership.
+     */
+    securityRelevant: boolean;
+    /** For functions: declared with SECURITY DEFINER. */
+    securityDefiner: boolean;
+    /**
+     * For functions: the body executes dynamic SQL (EXECUTE / EXECUTE ... USING
+     * / FOR ... IN EXECUTE). Analogous to `eval` — references inside the
+     * dynamic string are invisible to the AST, so edges from this statement
+     * are incomplete and slicing should treat it conservatively.
+     */
+    dynamicSql: boolean;
+}
+/**
+ * Classify each top-level statement in a SQL script into {@link StatementFacts}.
+ *
+ * Uses the same parser stack as the schema transformer (pgsql AST walk plus
+ * hydrated PL/pgSQL body walk), so references inside function bodies are
+ * included. The input SQL is never modified.
+ */
+export declare function classifyStatements(sql: string): StatementFacts[];

package/facts.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyStatements = classifyStatements;
+const traverse_1 = require("@pgsql/traverse");
+const plpgsql_parser_1 = require("plpgsql-parser");
+const SECURITY_TAGS = new Set([
+    'CreatePolicyStmt',
+    'AlterPolicyStmt',
+    'GrantStmt',
+    'GrantRoleStmt',
+    'AlterDefaultPrivilegesStmt',
+    'SecLabelStmt',
+    'AlterOwnerStmt',
+    'CreateRoleStmt',
+    'AlterRoleStmt'
+]);
+const KIND_BY_TAG = {
+    CreateSchemaStmt: 'schema',
+    CreateStmt: 'table',
+    ViewStmt: 'view',
+    IndexStmt: 'index',
+    CompositeTypeStmt: 'type',
+    CreateEnumStmt: 'type',
+    CreateDomainStmt: 'type',
+    CreateRangeStmt: 'type',
+    DefineStmt: 'type',
+    CreateFunctionStmt: 'function',
+    CreateTrigStmt: 'trigger',
+    CreateEventTrigStmt: 'trigger',
+    CreatePolicyStmt: 'policy',
+    AlterPolicyStmt: 'policy',
+    GrantStmt: 'grant',
+    GrantRoleStmt: 'grant',
+    AlterDefaultPrivilegesStmt: 'grant',
+    CommentStmt: 'comment',
+    InsertStmt: 'seed_dml',
+    UpdateStmt: 'seed_dml',
+    DeleteStmt: 'seed_dml'
+};
+function qn(schema, name) {
+    return { schema: schema ?? null, name };
+}
+function nameListToQualified(names) {
+    if (!Array.isArray(names) || names.length === 0)
+        return null;
+    const parts = names
+        .map((n) => n?.String?.sval)
+        .filter((s) => typeof s === 'string');
+    if (parts.length === 0)
+        return null;
+    if (parts.length === 1)
+        return qn(null, parts[0]);
+    return qn(parts[parts.length - 2], parts[parts.length - 1]);
+}
+function isCatalogSchema(schema) {
+    return schema === 'pg_catalog' || schema === 'information_schema';
+}
+function pushRef(refs, ref) {
+    if (!ref || !ref.schema || isCatalogSchema(ref.schema))
+        return;
+    if (refs.some(r => r.schema === ref.schema && r.name === ref.name))
+        return;
+    refs.push(ref);
+}
+function collectRoles(node, roles) {
+    const push = (role) => {
+        if (typeof role === 'string' && role.length > 0 && !roles.includes(role)) {
+            roles.push(role);
+        }
+    };
+    if (Array.isArray(node?.grantees)) {
+        for (const g of node.grantees)
+            push(g?.RoleSpec?.rolename);
+    }
+    if (Array.isArray(node?.roles)) {
+        for (const r of node.roles)
+            push(r?.RoleSpec?.rolename);
+    }
+    push(node?.newowner?.rolename);
+    push(node?.role?.rolename);
+}
+/**
+ * Create a read-only visitor that accumulates references, roles and FK
+ * targets into the provided facts object.
+ */
+function createFactsVisitor(facts, bodyRefs) {
+    const push = (ref) => {
+        pushRef(facts.references, ref);
+        if (bodyRefs)
+            pushRef(bodyRefs, ref);
+    };
+    return {
+        RangeVar: (path) => {
+            const node = path.node;
+            if (node.schemaname) {
+                push(qn(node.schemaname, node.relname));
+            }
+        },
+        FuncCall: (path) => {
+            push(nameListToQualified(path.node.funcname));
+        },
+        TypeName: (path) => {
+            push(nameListToQualified(path.node.names));
+        },
+        ColumnRef: (path) => {
+            // schema.table.column references carry cross-schema information
+            const fields = path.node.fields;
+            if (Array.isArray(fields) && fields.length >= 3) {
+                const parts = fields
+                    .map((f) => f?.String?.sval)
+                    .filter((s) => typeof s === 'string');
+                if (parts.length >= 3) {
+                    push(qn(parts[0], parts[1]));
+                }
+            }
+        },
+        Constraint: (path) => {
+            const node = path.node;
+            if (node.contype === 'CONSTR_FOREIGN' && node.pktable) {
+                const target = qn(node.pktable.schemaname ?? null, node.pktable.relname);
+                if (!facts.fkTargets.some(t => t.schema === target.schema && t.name === target.name)) {
+                    facts.fkTargets.push(target);
+                }
+                if (target.schema)
+                    pushRef(facts.references, target);
+            }
+        }
+    };
+}
+function classifyOne(nodeTag, node) {
+    const facts = {
+        kind: KIND_BY_TAG[nodeTag] ?? 'other',
+        nodeTag,
+        creates: [],
+        references: [],
+        referencedSchemas: [],
+        roles: [],
+        fkTargets: [],
+        bodyReferences: [],
+        securityRelevant: SECURITY_TAGS.has(nodeTag),
+        securityDefiner: false,
+        dynamicSql: false
+    };
+    switch (nodeTag) {
+        case 'CreateSchemaStmt':
+            facts.creates.push(qn(null, node.schemaname));
+            break;
+        case 'CreateStmt':
+        case 'ViewStmt': {
+            const rel = nodeTag === 'ViewStmt' ? node.view : node.relation;
+            if (rel)
+                facts.creates.push(qn(rel.schemaname ?? null, rel.relname));
+            break;
+        }
+        case 'IndexStmt':
+            if (node.relation) {
+                facts.creates.push(qn(node.relation.schemaname ?? null, node.idxname ?? node.relation.relname));
+            }
+            break;
+        case 'CreateFunctionStmt': {
+            const name = nameListToQualified(node.funcname);
+            if (name)
+                facts.creates.push(name);
+            for (const opt of node.options ?? []) {
+                const def = opt?.DefElem;
+                if (def?.defname === 'security' && def?.arg?.Boolean?.boolval === true) {
+                    facts.securityDefiner = true;
+                }
+            }
+            break;
+        }
+        case 'CreateTrigStmt':
+            if (node.relation) {
+                // Trigger names are only unique per table; qualify with the table.
+                facts.creates.push(qn(node.relation.schemaname ?? null, `${node.relation.relname}.${node.trigname}`));
+            }
+            pushRef(facts.references, nameListToQualified(node.funcname));
+            break;
+        case 'CreatePolicyStmt':
+        case 'AlterPolicyStmt':
+            if (node.table) {
+                // Policy names are only unique per table; qualify with the table.
+                facts.creates.push(qn(node.table.schemaname ?? null, `${node.table.relname}.${node.policy_name}`));
+                // The guarded table lives on `node.table`; the generic RangeVar walker
+                // does not descend into it, so capture the reference explicitly.
+                if (node.table.schemaname) {
+                    pushRef(facts.references, qn(node.table.schemaname, node.table.relname));
+                }
+            }
+            break;
+        case 'CreateSeqStmt':
+            if (node.sequence) {
+                facts.creates.push(qn(node.sequence.schemaname ?? null, node.sequence.relname));
+            }
+            break;
+        case 'CompositeTypeStmt':
+            if (node.typevar) {
+                facts.creates.push(qn(node.typevar.schemaname ?? null, node.typevar.relname));
+            }
+            break;
+        case 'CreateEnumStmt':
+        case 'CreateDomainStmt':
+        case 'CreateRangeStmt': {
+            const name = nameListToQualified(node.typeName ?? node.domainname);
+            if (name)
+                facts.creates.push(name);
+            break;
+        }
+        case 'AlterTableStmt': {
+            if (node.relation) {
+                facts.creates.push(qn(node.relation.schemaname ?? null, node.relation.relname));
+            }
+            const cmds = node.cmds ?? [];
+            for (const cmd of cmds) {
+                const subtype = cmd?.AlterTableCmd?.subtype;
+                if (subtype === 'AT_EnableRowSecurity' || subtype === 'AT_ForceRowSecurity' ||
+                    subtype === 'AT_DisableRowSecurity' || subtype === 'AT_NoForceRowSecurity') {
+                    facts.kind = 'rls_enable';
+                    facts.securityRelevant = true;
+                }
+                else if (subtype === 'AT_AddConstraint') {
+                    const contype = cmd?.AlterTableCmd?.def?.Constraint?.contype;
+                    facts.kind = contype === 'CONSTR_FOREIGN' ? 'fk_constraint' : 'constraint';
+                }
+                else if (subtype === 'AT_ChangeOwner') {
+                    facts.securityRelevant = true;
+                    const owner = cmd?.AlterTableCmd?.newowner?.rolename;
+                    if (owner && !facts.roles.includes(owner))
+                        facts.roles.push(owner);
+                }
+            }
+            break;
+        }
+        case 'InsertStmt':
+        case 'UpdateStmt':
+        case 'DeleteStmt':
+            if (node.relation) {
+                facts.creates.push(qn(node.relation.schemaname ?? null, node.relation.relname));
+            }
+            break;
+        default:
+            break;
+    }
+    collectRoles(node, facts.roles);
+    return facts;
+}
+/**
+ * Classify each top-level statement in a SQL script into {@link StatementFacts}.
+ *
+ * Uses the same parser stack as the schema transformer (pgsql AST walk plus
+ * hydrated PL/pgSQL body walk), so references inside function bodies are
+ * included. The input SQL is never modified.
+ */
+function classifyStatements(sql) {
+    const allFacts = [];
+    (0, plpgsql_parser_1.transformSync)(sql, (ctx) => {
+        const stmts = ctx.sql?.stmts ?? [];
+        for (const stmt of stmts) {
+            const stmtNode = stmt?.stmt;
+            const nodeTag = stmtNode ? Object.keys(stmtNode)[0] : 'other';
+            const node = stmtNode?.[nodeTag] ?? {};
+            const facts = classifyOne(nodeTag, node);
+            if (stmtNode) {
+                (0, traverse_1.walk)(stmtNode, createFactsVisitor(facts));
+            }
+            allFacts.push(facts);
+        }
+        for (const fn of ctx.functions ?? []) {
+            const facts = allFacts[fn.stmtIndex];
+            if (!facts || !fn.plpgsql?.hydrated)
+                continue;
+            // Refs already found outside the body (signature types, defaults)
+            // constrain deploy order and are not body-only.
+            const outer = new Set(facts.references.map(r => `${r.schema ?? '?'}.${r.name}`));
+            (0, plpgsql_parser_1.walk)(fn.plpgsql.hydrated, {
+                PLpgSQL_stmt_dynexecute: () => { facts.dynamicSql = true; },
+                PLpgSQL_stmt_dynfors: () => { facts.dynamicSql = true; }
+            }, {
+                walkSqlExpressions: true,
+                sqlVisitor: createFactsVisitor(facts, facts.bodyReferences)
+            });
+            facts.bodyReferences = facts.bodyReferences.filter(r => !outer.has(`${r.schema ?? '?'}.${r.name}`));
+        }
+    }, { hydrate: true });
+    for (const facts of allFacts) {
+        const selfRef = (r) => facts.creates.some(c => c.schema === r.schema && c.name === r.name);
+        facts.references = facts.references.filter(r => !selfRef(r));
+        facts.bodyReferences = facts.bodyReferences.filter(r => !selfRef(r));
+        facts.referencedSchemas = [...new Set(facts.references.map(r => r.schema).filter(Boolean))];
+    }
+    return allFacts;
+}

package/index.d.ts

@@ -1,28 +1,10 @@
-import { Node as PG13Node } from './13/types';
-import { Node as PG14Node } from './14/types';
-import { Node as PG15Node } from './15/types';
-import { Node as PG16Node } from './16/types';
-import { Node as PG17Node } from './17/types';
-import { Node as PG18Node } from './18/types';
-import * as PG13Types from './13/types';
-import * as PG14Types from './14/types';
-import * as PG15Types from './15/types';
-import * as PG16Types from './16/types';
-import * as PG17Types from './17/types';
-import * as PG18Types from './18/types';
-export { ASTTransformer } from './multi-version-transformer';
-export { V13ToV14Transformer } from './transformers/v13-to-v14';
-export { V14ToV15Transformer } from './transformers/v14-to-v15';
-export { V15ToV16Transformer } from './transformers/v15-to-v16';
-export { V16ToV17Transformer } from './transformers/v16-to-v17';
-export { V17ToV18Transformer } from './transformers/v17-to-v18';
-export { PG13ToPG17Transformer } from './transformers-direct/v13-to-v17';
-export { PG14ToPG17Transformer } from './transformers-direct/v14-to-v17';
-export { PG15ToPG17Transformer } from './transformers-direct/v15-to-v17';
-export { PG16ToPG17Transformer } from './transformers-direct/v16-to-v17';
-export { PG13ToPG18Transformer } from './transformers-direct/v13-to-v18';
-export { PG14ToPG18Transformer } from './transformers-direct/v14-to-v18';
-export { PG15ToPG18Transformer } from './transformers-direct/v15-to-v18';
-export { PG16ToPG18Transformer } from './transformers-direct/v16-to-v18';
-export { PG17ToPG18Transformer } from './transformers-direct/v17-to-v18';
-export { PG13Node, PG14Node, PG15Node, PG16Node, PG17Node, PG18Node, PG13Types, PG14Types, PG15Types, PG16Types, PG17Types, PG18Types };
+export type { QualifiedName, StatementFacts, StatementKind, } from './facts';
+export { classifyStatements } from './facts';
+export type { ObjectInventory, QualifyResult, QualifyRoutes, QualifyTargetSelector, QualifyUnqualifiedOptions, } from './qualify';
+export { collectCreatedObjects, createQualifyVisitor, mergeInventories, qualifyUnqualified, } from './qualify';
+export type { CapturedAsts } from './round-trip';
+export { captureAstsFromSql, captureTransformAsts, firstDifference, normalizeParseTree, validateRoundTrip, } from './round-trip';
+export type { NormalizeTreeOptions } from './round-trip-core';
+export { CLEAN_TREE_VOLATILE_KEYS, cleanTree, normalizeTree, trimDefElemBody, } from './round-trip-core';
+export type { SchemaTransformPass, SchemaTransformResult, TransformSqlOptions, } from './transform';
+export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, shouldTransformSchema, transformComments, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';

package/index.js

@@ -1,78 +1,39 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG18Types = exports.PG17Types = exports.PG16Types = exports.PG15Types = exports.PG14Types = exports.PG13Types = exports.PG17ToPG18Transformer = exports.PG16ToPG18Transformer = exports.PG15ToPG18Transformer = exports.PG14ToPG18Transformer = exports.PG13ToPG18Transformer = exports.PG16ToPG17Transformer = exports.PG15ToPG17Transformer = exports.PG14ToPG17Transformer = exports.PG13ToPG17Transformer = exports.V17ToV18Transformer = exports.V16ToV17Transformer = exports.V15ToV16Transformer = exports.V14ToV15Transformer = exports.V13ToV14Transformer = exports.ASTTransformer = void 0;
-const PG13Types = __importStar(require("./13/types"));
-exports.PG13Types = PG13Types;
-const PG14Types = __importStar(require("./14/types"));
-exports.PG14Types = PG14Types;
-const PG15Types = __importStar(require("./15/types"));
-exports.PG15Types = PG15Types;
-const PG16Types = __importStar(require("./16/types"));
-exports.PG16Types = PG16Types;
-const PG17Types = __importStar(require("./17/types"));
-exports.PG17Types = PG17Types;
-const PG18Types = __importStar(require("./18/types"));
-exports.PG18Types = PG18Types;
-var multi_version_transformer_1 = require("./multi-version-transformer");
-Object.defineProperty(exports, "ASTTransformer", { enumerable: true, get: function () { return multi_version_transformer_1.ASTTransformer; } });
-var v13_to_v14_1 = require("./transformers/v13-to-v14");
-Object.defineProperty(exports, "V13ToV14Transformer", { enumerable: true, get: function () { return v13_to_v14_1.V13ToV14Transformer; } });
-var v14_to_v15_1 = require("./transformers/v14-to-v15");
-Object.defineProperty(exports, "V14ToV15Transformer", { enumerable: true, get: function () { return v14_to_v15_1.V14ToV15Transformer; } });
-var v15_to_v16_1 = require("./transformers/v15-to-v16");
-Object.defineProperty(exports, "V15ToV16Transformer", { enumerable: true, get: function () { return v15_to_v16_1.V15ToV16Transformer; } });
-var v16_to_v17_1 = require("./transformers/v16-to-v17");
-Object.defineProperty(exports, "V16ToV17Transformer", { enumerable: true, get: function () { return v16_to_v17_1.V16ToV17Transformer; } });
-var v17_to_v18_1 = require("./transformers/v17-to-v18");
-Object.defineProperty(exports, "V17ToV18Transformer", { enumerable: true, get: function () { return v17_to_v18_1.V17ToV18Transformer; } });
-var v13_to_v17_1 = require("./transformers-direct/v13-to-v17");
-Object.defineProperty(exports, "PG13ToPG17Transformer", { enumerable: true, get: function () { return v13_to_v17_1.PG13ToPG17Transformer; } });
-var v14_to_v17_1 = require("./transformers-direct/v14-to-v17");
-Object.defineProperty(exports, "PG14ToPG17Transformer", { enumerable: true, get: function () { return v14_to_v17_1.PG14ToPG17Transformer; } });
-var v15_to_v17_1 = require("./transformers-direct/v15-to-v17");
-Object.defineProperty(exports, "PG15ToPG17Transformer", { enumerable: true, get: function () { return v15_to_v17_1.PG15ToPG17Transformer; } });
-var v16_to_v17_2 = require("./transformers-direct/v16-to-v17");
-Object.defineProperty(exports, "PG16ToPG17Transformer", { enumerable: true, get: function () { return v16_to_v17_2.PG16ToPG17Transformer; } });
-var v13_to_v18_1 = require("./transformers-direct/v13-to-v18");
-Object.defineProperty(exports, "PG13ToPG18Transformer", { enumerable: true, get: function () { return v13_to_v18_1.PG13ToPG18Transformer; } });
-var v14_to_v18_1 = require("./transformers-direct/v14-to-v18");
-Object.defineProperty(exports, "PG14ToPG18Transformer", { enumerable: true, get: function () { return v14_to_v18_1.PG14ToPG18Transformer; } });
-var v15_to_v18_1 = require("./transformers-direct/v15-to-v18");
-Object.defineProperty(exports, "PG15ToPG18Transformer", { enumerable: true, get: function () { return v15_to_v18_1.PG15ToPG18Transformer; } });
-var v16_to_v18_1 = require("./transformers-direct/v16-to-v18");
-Object.defineProperty(exports, "PG16ToPG18Transformer", { enumerable: true, get: function () { return v16_to_v18_1.PG16ToPG18Transformer; } });
-var v17_to_v18_2 = require("./transformers-direct/v17-to-v18");
-Object.defineProperty(exports, "PG17ToPG18Transformer", { enumerable: true, get: function () { return v17_to_v18_2.PG17ToPG18Transformer; } });
+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.qualifyUnqualified = exports.mergeInventories = exports.createQualifyVisitor = exports.collectCreatedObjects = exports.classifyStatements = void 0;
+var facts_1 = require("./facts");
+Object.defineProperty(exports, "classifyStatements", { enumerable: true, get: function () { return facts_1.classifyStatements; } });
+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; } });
+Object.defineProperty(exports, "mergeInventories", { enumerable: true, get: function () { return qualify_1.mergeInventories; } });
+Object.defineProperty(exports, "qualifyUnqualified", { enumerable: true, get: function () { return qualify_1.qualifyUnqualified; } });
+var round_trip_1 = require("./round-trip");
+Object.defineProperty(exports, "captureAstsFromSql", { enumerable: true, get: function () { return round_trip_1.captureAstsFromSql; } });
+Object.defineProperty(exports, "captureTransformAsts", { enumerable: true, get: function () { return round_trip_1.captureTransformAsts; } });
+Object.defineProperty(exports, "firstDifference", { enumerable: true, get: function () { return round_trip_1.firstDifference; } });
+Object.defineProperty(exports, "normalizeParseTree", { enumerable: true, get: function () { return round_trip_1.normalizeParseTree; } });
+Object.defineProperty(exports, "validateRoundTrip", { enumerable: true, get: function () { return round_trip_1.validateRoundTrip; } });
+var round_trip_core_1 = require("./round-trip-core");
+Object.defineProperty(exports, "CLEAN_TREE_VOLATILE_KEYS", { enumerable: true, get: function () { return round_trip_core_1.CLEAN_TREE_VOLATILE_KEYS; } });
+Object.defineProperty(exports, "cleanTree", { enumerable: true, get: function () { return round_trip_core_1.cleanTree; } });
+Object.defineProperty(exports, "normalizeTree", { enumerable: true, get: function () { return round_trip_core_1.normalizeTree; } });
+Object.defineProperty(exports, "trimDefElemBody", { enumerable: true, get: function () { return round_trip_core_1.trimDefElemBody; } });
+var transform_1 = require("./transform");
+Object.defineProperty(exports, "createPlpgsqlVisitor", { enumerable: true, get: function () { return transform_1.createPlpgsqlVisitor; } });
+Object.defineProperty(exports, "createSqlVisitor", { enumerable: true, get: function () { return transform_1.createSqlVisitor; } });
+Object.defineProperty(exports, "escapeRegexp", { enumerable: true, get: function () { return transform_1.escapeRegexp; } });
+Object.defineProperty(exports, "extractPgpmHeader", { enumerable: true, get: function () { return transform_1.extractPgpmHeader; } });
+Object.defineProperty(exports, "shouldTransformSchema", { enumerable: true, get: function () { return transform_1.shouldTransformSchema; } });
+Object.defineProperty(exports, "transformComments", { enumerable: true, get: function () { return transform_1.transformComments; } });
+Object.defineProperty(exports, "transformJsonStringValues", { enumerable: true, get: function () { return transform_1.transformJsonStringValues; } });
+Object.defineProperty(exports, "transformNameList", { enumerable: true, get: function () { return transform_1.transformNameList; } });
+Object.defineProperty(exports, "transformPlpgsqlTypeAst", { enumerable: true, get: function () { return transform_1.transformPlpgsqlTypeAst; } });
+Object.defineProperty(exports, "transformPlpgsqlTypeString", { enumerable: true, get: function () { return transform_1.transformPlpgsqlTypeString; } });
+Object.defineProperty(exports, "transformRelation", { enumerable: true, get: function () { return transform_1.transformRelation; } });
+Object.defineProperty(exports, "transformSchemaName", { enumerable: true, get: function () { return transform_1.transformSchemaName; } });
+Object.defineProperty(exports, "transformSql", { enumerable: true, get: function () { return transform_1.transformSql; } });
+Object.defineProperty(exports, "transformSqlStatement", { enumerable: true, get: function () { return transform_1.transformSqlStatement; } });
+Object.defineProperty(exports, "transformVerifyCalls", { enumerable: true, get: function () { return transform_1.transformVerifyCalls; } });
+Object.defineProperty(exports, "validateNoUntransformedSchemas", { enumerable: true, get: function () { return transform_1.validateNoUntransformedSchemas; } });
+Object.defineProperty(exports, "walkPlpgsqlForSchemas", { enumerable: true, get: function () { return transform_1.walkPlpgsqlForSchemas; } });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@pgsql/transform",
-  "version": "18.1.1",
+  "version": "18.3.1",
   "author": "Constructive <developers@constructive.io>",
-  "description": "Transform PostgreSQL AST types for pgsql-parser",
+  "description": "AST-based SQL transformation, qualification, classification and closure analysis for PostgreSQL",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
@@ -23,23 +23,31 @@
     "copy": "makage assets",
     "clean": "makage clean dist",
     "prepublishOnly": "npm run build",
-    "build": "npm run build:proto && npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
+    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
     "build:dev": "npm run clean && tsc --declarationMap && tsc -p tsconfig.esm.json && npm run copy",
-    "build:proto": "ts-node scripts/pg-proto-parser",
     "lint": "eslint . --fix",
     "test": "jest",
     "test:watch": "jest --watch",
-    "kitchen-sink": "ts-node scripts/make-kitchen-sink.ts",
-    "test:ast": "ts-node scripts/test-ast.ts"
+    "fixtures": "ts-node scripts/make-fixtures.ts",
+    "scan-corpus": "node scripts/scan-corpus.js"
+  },
+  "dependencies": {
+    "@pgsql/quotes": "18.1.0",
+    "@pgsql/traverse": "18.3.0",
+    "plpgsql-parser": "18.2.1"
   },
   "devDependencies": {
-    "@pgsql/parser": "^1.2.1",
-    "@pgsql/types": "^18.0.0",
-    "libpg-query": "18.1.2",
-    "makage": "^0.1.8",
-    "pg-proto-parser": "1.31.0",
-    "pgsql-deparser": "18.1.1"
+    "makage": "^0.1.8"
   },
-  "keywords": [],
-  "gitHead": "d57254a6bae519c2ce7c54f88dff44105124a821"
+  "keywords": [
+    "sql",
+    "postgres",
+    "postgresql",
+    "pg",
+    "ast",
+    "transform",
+    "classify",
+    "plpgsql"
+  ],
+  "gitHead": "ef29a3eb49d020f309f7289dbf1fd1e642ed5008"
 }