@pgsql/transform 18.1.1 → 18.3.1

package/esm/transformers/v17-to-v18.js

@@ -1,204 +0,0 @@
-/**
- * V17 to V18 AST Transformer
- * Transforms PostgreSQL v17 AST nodes to v18 format
- *
- * Structural changes in v18:
- * - InsertStmt/UpdateStmt/DeleteStmt/MergeStmt: returningList -> returningClause { exprs }
- * - Constraint: new is_enforced flag (true by default for CHECK/FOREIGN/NOTNULL)
- * - Constraint: CONSTR_GENERATED gains generated_kind ('s' = STORED, 'v' = VIRTUAL)
- * - Column-level NOT NULL constraints gain initially_valid: true
- */
-export class V17ToV18Transformer {
-    transform(node, context = { parentNodeTypes: [] }) {
-        if (node == null) {
-            return null;
-        }
-        if (typeof node === 'number' || node instanceof Number) {
-            return node;
-        }
-        if (typeof node === 'string') {
-            return node;
-        }
-        try {
-            return this.visit(node, context);
-        }
-        catch (error) {
-            const nodeType = Object.keys(node)[0];
-            throw new Error(`Error transforming ${nodeType}: ${error.message}`);
-        }
-    }
-    visit(node, context = { parentNodeTypes: [] }) {
-        if (node && typeof node === 'object' && 'version' in node && 'stmts' in node) {
-            return this.ParseResult(node, context);
-        }
-        const nodeType = this.getNodeType(node);
-        // Handle empty objects
-        if (!nodeType) {
-            return {};
-        }
-        const nodeData = this.getNodeData(node);
-        const methodName = nodeType;
-        if (typeof this[methodName] === 'function') {
-            const childContext = {
-                ...context,
-                parentNodeTypes: [...context.parentNodeTypes, nodeType]
-            };
-            const result = this[methodName](nodeData, childContext);
-            return result;
-        }
-        // No specific method: recurse into children so nested statements
-        // (e.g. DML inside CTEs) still get transformed
-        return this.walkValue(node, context);
-    }
-    /**
-     * Generic recursive walk that re-dispatches wrapped nodes with a
-     * dedicated transformer method and deep-copies everything else.
-     */
-    walkValue(value, context) {
-        if (value == null || typeof value !== 'object') {
-            return value;
-        }
-        if (Array.isArray(value)) {
-            return value.map(item => this.walkValue(item, context));
-        }
-        const keys = Object.keys(value);
-        if (keys.length === 1 && typeof this[keys[0]] === 'function') {
-            // Wrapped node with a dedicated transformer method
-            return this.visit(value, context);
-        }
-        const result = {};
-        for (const key of keys) {
-            result[key] = this.walkValue(value[key], context);
-        }
-        return result;
-    }
-    getNodeType(node) {
-        return Object.keys(node)[0];
-    }
-    getNodeData(node) {
-        const keys = Object.keys(node);
-        if (keys.length === 1 && typeof node[keys[0]] === 'object') {
-            return node[keys[0]];
-        }
-        return node;
-    }
-    ParseResult(node, context) {
-        if (node && typeof node === 'object' && 'version' in node && 'stmts' in node) {
-            return {
-                version: 180004, // PG18 version
-                stmts: node.stmts.map((stmt) => {
-                    if (stmt && typeof stmt === 'object' && 'stmt' in stmt) {
-                        return {
-                            ...stmt,
-                            stmt: this.transform(stmt.stmt, context)
-                        };
-                    }
-                    return this.transform(stmt, context);
-                })
-            };
-        }
-        return node;
-    }
-    RawStmt(node, context) {
-        const result = {};
-        if (node.stmt !== undefined) {
-            result.stmt = this.transform(node.stmt, context);
-        }
-        if (node.stmt_location !== undefined) {
-            result.stmt_location = node.stmt_location;
-        }
-        if (node.stmt_len !== undefined) {
-            result.stmt_len = node.stmt_len;
-        }
-        return { RawStmt: result };
-    }
-    /**
-     * Convert a v17 returningList into a v18 ReturningClause
-     */
-    transformReturningList(returningList, context) {
-        return {
-            exprs: returningList.map(item => this.transform(item, context))
-        };
-    }
-    transformDmlStatement(nodeType, node, context) {
-        const result = {};
-        for (const key of Object.keys(node)) {
-            if (key === 'returningList') {
-                result.returningClause = this.transformReturningList(node.returningList, context);
-            }
-            else {
-                result[key] = this.walkValue(node[key], context);
-            }
-        }
-        return { [nodeType]: result };
-    }
-    InsertStmt(node, context) {
-        return this.transformDmlStatement('InsertStmt', node, context);
-    }
-    UpdateStmt(node, context) {
-        return this.transformDmlStatement('UpdateStmt', node, context);
-    }
-    DeleteStmt(node, context) {
-        return this.transformDmlStatement('DeleteStmt', node, context);
-    }
-    MergeStmt(node, context) {
-        return this.transformDmlStatement('MergeStmt', node, context);
-    }
-    AlterTableCmd(node, context) {
-        const result = {};
-        for (const key of Object.keys(node)) {
-            result[key] = this.walkValue(node[key], context);
-        }
-        // v18 wraps ALTER CONSTRAINT definitions in the new ATAlterConstraint node
-        if (node.subtype === 'AT_AlterConstraint' && node.def?.Constraint) {
-            const constraint = node.def.Constraint;
-            const alterConstraint = {};
-            if (constraint.conname !== undefined) {
-                alterConstraint.conname = constraint.conname;
-            }
-            alterConstraint.is_enforced = true;
-            // v17 ALTER CONSTRAINT could only change deferrability
-            alterConstraint.alterDeferrability = true;
-            if (constraint.deferrable !== undefined) {
-                alterConstraint.deferrable = constraint.deferrable;
-            }
-            if (constraint.initdeferred !== undefined) {
-                alterConstraint.initdeferred = constraint.initdeferred;
-            }
-            result.def = { ATAlterConstraint: alterConstraint };
-        }
-        return { AlterTableCmd: result };
-    }
-    VariableSetStmt(node, context) {
-        const result = {};
-        for (const key of Object.keys(node)) {
-            result[key] = this.walkValue(node[key], context);
-        }
-        // v18 marks SET TRANSACTION / SESSION CHARACTERISTICS args as jumbled
-        if (node.kind === 'VAR_SET_MULTI' && (node.name === 'TRANSACTION' || node.name === 'SESSION CHARACTERISTICS')) {
-            result.jumble_args = true;
-        }
-        return { VariableSetStmt: result };
-    }
-    Constraint(node, context) {
-        const result = {};
-        for (const key of Object.keys(node)) {
-            result[key] = this.walkValue(node[key], context);
-        }
-        // v18 constraints are enforced by default; v17 grammar had no ENFORCED syntax
-        if (node.contype === 'CONSTR_CHECK' || node.contype === 'CONSTR_FOREIGN') {
-            result.is_enforced = true;
-        }
-        if (node.contype === 'CONSTR_NOTNULL') {
-            // v17 only produces column-level NOT NULL constraints, which in v18
-            // carry is_enforced and initially_valid
-            result.is_enforced = true;
-            result.initially_valid = true;
-        }
-        if (node.contype === 'CONSTR_GENERATED' && result.generated_kind === undefined) {
-            // v17 only supports STORED generated columns
-            result.generated_kind = 's';
-        }
-        return { Constraint: result };
-    }
-}

package/esm/transformers-direct/index.js

@@ -1,13 +0,0 @@
-/**
- * Direct transformers for PostgreSQL version upgrades to PG17/PG18
- * These transformers are designed for tree-shaking optimization
- */
-export { PG13ToPG17Transformer } from './v13-to-v17';
-export { PG14ToPG17Transformer } from './v14-to-v17';
-export { PG15ToPG17Transformer } from './v15-to-v17';
-export { PG16ToPG17Transformer } from './v16-to-v17';
-export { PG13ToPG18Transformer } from './v13-to-v18';
-export { PG14ToPG18Transformer } from './v14-to-v18';
-export { PG15ToPG18Transformer } from './v15-to-v18';
-export { PG16ToPG18Transformer } from './v16-to-v18';
-export { PG17ToPG18Transformer } from './v17-to-v18';

package/esm/transformers-direct/v13-to-v17/index.js

@@ -1,74 +0,0 @@
-import { V13ToV14Transformer } from '../../transformers/v13-to-v14';
-import { V14ToV15Transformer } from '../../transformers/v14-to-v15';
-import { V15ToV16Transformer } from '../../transformers/v15-to-v16';
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-/**
- * Direct transformer from PG13 to PG17
- * This transformer chains v13->v14->v15->v16->v17 transformations
- */
-export class PG13ToPG17Transformer {
-    v13to14 = new V13ToV14Transformer();
-    v14to15 = new V14ToV15Transformer();
-    v15to16 = new V15ToV16Transformer();
-    v16to17 = new V16ToV17Transformer();
-    transform(node) {
-        // If it's a ParseResult, handle it specially
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v13->v14->v15->v16->v17
-            const v14Stmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v14Stmt = this.v13to14.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v14Stmt };
-                }
-                return stmtWrapper;
-            });
-            const v15Stmts = v14Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v15Stmt = this.v14to15.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v15Stmt };
-                }
-                return stmtWrapper;
-            });
-            const v16Stmts = v15Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v16Stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v16Stmt };
-                }
-                return stmtWrapper;
-            });
-            const v17Stmts = v16Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v17Stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v17Stmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 170004, // PG17 version
-                stmts: v17Stmts
-            };
-        }
-        // Otherwise, transform as a regular node through the chain
-        const v14Node = this.v13to14.transform(node, { parentNodeTypes: [] });
-        const v15Node = this.v14to15.transform(v14Node, { parentNodeTypes: [] });
-        const v16Node = this.v15to16.transform(v15Node, { parentNodeTypes: [] });
-        return this.v16to17.transform(v16Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG13 to PG17
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v14Stmt = this.v13to14.transform(stmt, { parentNodeTypes: [] });
-        const v15Stmt = this.v14to15.transform(v14Stmt, { parentNodeTypes: [] });
-        const v16Stmt = this.v15to16.transform(v15Stmt, { parentNodeTypes: [] });
-        return this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/esm/transformers-direct/v13-to-v18/index.js

@@ -1,84 +0,0 @@
-import { V13ToV14Transformer } from '../../transformers/v13-to-v14';
-import { V14ToV15Transformer } from '../../transformers/v14-to-v15';
-import { V15ToV16Transformer } from '../../transformers/v15-to-v16';
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-import { V17ToV18Transformer } from '../../transformers/v17-to-v18';
-/**
- * Direct transformer from PG13 to PG18
- * This transformer chains v13->...->v18 transformations
- */
-export class PG13ToPG18Transformer {
-    v13to14 = new V13ToV14Transformer();
-    v14to15 = new V14ToV15Transformer();
-    v15to16 = new V15ToV16Transformer();
-    v16to17 = new V16ToV17Transformer();
-    v17to18 = new V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v13->v14->v15->v16->v17->v18
-            const v14Stmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v13to14.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v15Stmts = v14Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v14to15.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v16Stmts = v15Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v17Stmts = v16Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v18Stmts = v17Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 180004, // PG18 version
-                stmts: v18Stmts
-            };
-        }
-        // Otherwise, transform as a regular node through the chain
-        const v14Node = this.v13to14.transform(node, { parentNodeTypes: [] });
-        const v15Node = this.v14to15.transform(v14Node, { parentNodeTypes: [] });
-        const v16Node = this.v15to16.transform(v15Node, { parentNodeTypes: [] });
-        const v17Node = this.v16to17.transform(v16Node, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG13 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v14Stmt = this.v13to14.transform(stmt, { parentNodeTypes: [] });
-        const v15Stmt = this.v14to15.transform(v14Stmt, { parentNodeTypes: [] });
-        const v16Stmt = this.v15to16.transform(v15Stmt, { parentNodeTypes: [] });
-        const v17Stmt = this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/esm/transformers-direct/v14-to-v17/index.js

@@ -1,63 +0,0 @@
-import { V14ToV15Transformer } from '../../transformers/v14-to-v15';
-import { V15ToV16Transformer } from '../../transformers/v15-to-v16';
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-/**
- * Direct transformer from PG14 to PG17
- * This transformer chains v14->v15->v16->v17 transformations
- */
-export class PG14ToPG17Transformer {
-    v14to15 = new V14ToV15Transformer();
-    v15to16 = new V15ToV16Transformer();
-    v16to17 = new V16ToV17Transformer();
-    transform(node) {
-        // If it's a ParseResult, handle it specially
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v14->v15->v16->v17
-            const v15Stmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v15Stmt = this.v14to15.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v15Stmt };
-                }
-                return stmtWrapper;
-            });
-            const v16Stmts = v15Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v16Stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v16Stmt };
-                }
-                return stmtWrapper;
-            });
-            const v17Stmts = v16Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v17Stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v17Stmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 170004, // PG17 version
-                stmts: v17Stmts
-            };
-        }
-        // Otherwise, transform as a regular node through the chain
-        const v15Node = this.v14to15.transform(node, { parentNodeTypes: [] });
-        const v16Node = this.v15to16.transform(v15Node, { parentNodeTypes: [] });
-        return this.v16to17.transform(v16Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG14 to PG17
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v15Stmt = this.v14to15.transform(stmt, { parentNodeTypes: [] });
-        const v16Stmt = this.v15to16.transform(v15Stmt, { parentNodeTypes: [] });
-        return this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/esm/transformers-direct/v14-to-v18/index.js

@@ -1,73 +0,0 @@
-import { V14ToV15Transformer } from '../../transformers/v14-to-v15';
-import { V15ToV16Transformer } from '../../transformers/v15-to-v16';
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-import { V17ToV18Transformer } from '../../transformers/v17-to-v18';
-/**
- * Direct transformer from PG14 to PG18
- * This transformer chains v14->...->v18 transformations
- */
-export class PG14ToPG18Transformer {
-    v14to15 = new V14ToV15Transformer();
-    v15to16 = new V15ToV16Transformer();
-    v16to17 = new V16ToV17Transformer();
-    v17to18 = new V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v14->v15->v16->v17->v18
-            const v15Stmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v14to15.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v16Stmts = v15Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v17Stmts = v16Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v18Stmts = v17Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 180004, // PG18 version
-                stmts: v18Stmts
-            };
-        }
-        // Otherwise, transform as a regular node through the chain
-        const v15Node = this.v14to15.transform(node, { parentNodeTypes: [] });
-        const v16Node = this.v15to16.transform(v15Node, { parentNodeTypes: [] });
-        const v17Node = this.v16to17.transform(v16Node, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG14 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v15Stmt = this.v14to15.transform(stmt, { parentNodeTypes: [] });
-        const v16Stmt = this.v15to16.transform(v15Stmt, { parentNodeTypes: [] });
-        const v17Stmt = this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/esm/transformers-direct/v15-to-v17/index.js

@@ -1,53 +0,0 @@
-import { V15ToV16Transformer } from '../../transformers/v15-to-v16';
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-/**
- * Direct transformer from PG15 to PG17
- * This transformer chains v15->v16->v17 transformations
- */
-export class PG15ToPG17Transformer {
-    v15to16 = new V15ToV16Transformer();
-    v16to17 = new V16ToV17Transformer();
-    transform(node) {
-        // If it's a ParseResult, handle it specially
-        if (this.isParseResult(node)) {
-            // First transform statements from v15 to v16
-            const v16Stmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v16Stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v16Stmt };
-                }
-                return stmtWrapper;
-            });
-            // Then transform from v16 to v17
-            const v17Stmts = v16Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const v17Stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: v17Stmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 170004, // PG17 version
-                stmts: v17Stmts
-            };
-        }
-        // Otherwise, transform as a regular node through the chain
-        const v16Node = this.v15to16.transform(node, { parentNodeTypes: [] });
-        return this.v16to17.transform(v16Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG15 to PG17
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v16Stmt = this.v15to16.transform(stmt, { parentNodeTypes: [] });
-        return this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/esm/transformers-direct/v15-to-v18/index.js

@@ -1,62 +0,0 @@
-import { V15ToV16Transformer } from '../../transformers/v15-to-v16';
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-import { V17ToV18Transformer } from '../../transformers/v17-to-v18';
-/**
- * Direct transformer from PG15 to PG18
- * This transformer chains v15->...->v18 transformations
- */
-export class PG15ToPG18Transformer {
-    v15to16 = new V15ToV16Transformer();
-    v16to17 = new V16ToV17Transformer();
-    v17to18 = new V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v15->v16->v17->v18
-            const v16Stmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v17Stmts = v16Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            const v18Stmts = v17Stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const stmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 180004, // PG18 version
-                stmts: v18Stmts
-            };
-        }
-        // Otherwise, transform as a regular node through the chain
-        const v16Node = this.v15to16.transform(node, { parentNodeTypes: [] });
-        const v17Node = this.v16to17.transform(v16Node, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG15 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v16Stmt = this.v15to16.transform(stmt, { parentNodeTypes: [] });
-        const v17Stmt = this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/esm/transformers-direct/v16-to-v17/index.js

@@ -1,40 +0,0 @@
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-/**
- * Direct transformer from PG16 to PG17
- * This transformer only includes the necessary code for v16->v17 transformation
- */
-export class PG16ToPG17Transformer {
-    transformer = new V16ToV17Transformer();
-    transform(node) {
-        // If it's a ParseResult, handle it specially
-        if (this.isParseResult(node)) {
-            const transformedStmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const transformedStmt = this.transformer.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: transformedStmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 170004, // PG17 version
-                stmts: transformedStmts
-            };
-        }
-        // Otherwise, transform as a regular node
-        return this.transformer.transform(node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG16 to PG17
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        return this.transformer.transform(stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}