@pgsql/transform 18.1.1 → 18.3.0

package/transformers/v17-to-v18.d.ts

@@ -1,54 +0,0 @@
-import * as PG17 from '../17/types';
-import * as PG18 from '../18/types';
-import { TransformerContext } from './context';
-/**
- * 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 declare class V17ToV18Transformer {
-    transform(node: PG17.Node, context?: TransformerContext): any;
-    visit(node: PG17.Node, context?: TransformerContext): any;
-    /**
-     * Generic recursive walk that re-dispatches wrapped nodes with a
-     * dedicated transformer method and deep-copies everything else.
-     */
-    private walkValue;
-    getNodeType(node: PG17.Node): any;
-    getNodeData(node: PG17.Node): any;
-    ParseResult(node: PG17.ParseResult, context: TransformerContext): PG18.ParseResult;
-    RawStmt(node: PG17.RawStmt, context: TransformerContext): {
-        RawStmt: PG18.RawStmt;
-    };
-    /**
-     * Convert a v17 returningList into a v18 ReturningClause
-     */
-    private transformReturningList;
-    private transformDmlStatement;
-    InsertStmt(node: PG17.InsertStmt, context: TransformerContext): {
-        InsertStmt: PG18.InsertStmt;
-    };
-    UpdateStmt(node: PG17.UpdateStmt, context: TransformerContext): {
-        UpdateStmt: PG18.UpdateStmt;
-    };
-    DeleteStmt(node: PG17.DeleteStmt, context: TransformerContext): {
-        DeleteStmt: PG18.DeleteStmt;
-    };
-    MergeStmt(node: PG17.MergeStmt, context: TransformerContext): {
-        MergeStmt: PG18.MergeStmt;
-    };
-    AlterTableCmd(node: PG17.AlterTableCmd, context: TransformerContext): {
-        AlterTableCmd: PG18.AlterTableCmd;
-    };
-    VariableSetStmt(node: PG17.VariableSetStmt, context: TransformerContext): {
-        VariableSetStmt: PG18.VariableSetStmt;
-    };
-    Constraint(node: PG17.Constraint, context: TransformerContext): {
-        Constraint: PG18.Constraint;
-    };
-}

package/transformers/v17-to-v18.js

@@ -1,208 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.V17ToV18Transformer = void 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
- */
-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 };
-    }
-}
-exports.V17ToV18Transformer = V17ToV18Transformer;

package/transformers-direct/index.d.ts

@@ -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/transformers-direct/index.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * Direct transformers for PostgreSQL version upgrades to PG17/PG18
- * These transformers are designed for tree-shaking optimization
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG17ToPG18Transformer = exports.PG16ToPG18Transformer = exports.PG15ToPG18Transformer = exports.PG14ToPG18Transformer = exports.PG13ToPG18Transformer = exports.PG16ToPG17Transformer = exports.PG15ToPG17Transformer = exports.PG14ToPG17Transformer = exports.PG13ToPG17Transformer = void 0;
-var v13_to_v17_1 = require("./v13-to-v17");
-Object.defineProperty(exports, "PG13ToPG17Transformer", { enumerable: true, get: function () { return v13_to_v17_1.PG13ToPG17Transformer; } });
-var v14_to_v17_1 = require("./v14-to-v17");
-Object.defineProperty(exports, "PG14ToPG17Transformer", { enumerable: true, get: function () { return v14_to_v17_1.PG14ToPG17Transformer; } });
-var v15_to_v17_1 = require("./v15-to-v17");
-Object.defineProperty(exports, "PG15ToPG17Transformer", { enumerable: true, get: function () { return v15_to_v17_1.PG15ToPG17Transformer; } });
-var v16_to_v17_1 = require("./v16-to-v17");
-Object.defineProperty(exports, "PG16ToPG17Transformer", { enumerable: true, get: function () { return v16_to_v17_1.PG16ToPG17Transformer; } });
-var v13_to_v18_1 = require("./v13-to-v18");
-Object.defineProperty(exports, "PG13ToPG18Transformer", { enumerable: true, get: function () { return v13_to_v18_1.PG13ToPG18Transformer; } });
-var v14_to_v18_1 = require("./v14-to-v18");
-Object.defineProperty(exports, "PG14ToPG18Transformer", { enumerable: true, get: function () { return v14_to_v18_1.PG14ToPG18Transformer; } });
-var v15_to_v18_1 = require("./v15-to-v18");
-Object.defineProperty(exports, "PG15ToPG18Transformer", { enumerable: true, get: function () { return v15_to_v18_1.PG15ToPG18Transformer; } });
-var v16_to_v18_1 = require("./v16-to-v18");
-Object.defineProperty(exports, "PG16ToPG18Transformer", { enumerable: true, get: function () { return v16_to_v18_1.PG16ToPG18Transformer; } });
-var v17_to_v18_1 = require("./v17-to-v18");
-Object.defineProperty(exports, "PG17ToPG18Transformer", { enumerable: true, get: function () { return v17_to_v18_1.PG17ToPG18Transformer; } });

package/transformers-direct/v13-to-v17/index.d.ts

@@ -1,27 +0,0 @@
-import * as PG13 from '../../13/types';
-import * as PG17 from '../../17/types';
-/**
- * Direct transformer from PG13 to PG17
- * This transformer chains v13->v14->v15->v16->v17 transformations
- */
-export declare class PG13ToPG17Transformer {
-    private v13to14;
-    private v14to15;
-    private v15to16;
-    private v16to17;
-    /**
-     * Transform a node or parse result from PG13 to PG17
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG13.Node): PG17.Node;
-    transform(node: PG13.ParseResult): PG17.ParseResult;
-    /**
-     * Transform a single statement from PG13 to PG17
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt: any): any;
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    private isParseResult;
-}

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

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG13ToPG17Transformer = void 0;
-const v13_to_v14_1 = require("../../transformers/v13-to-v14");
-const v14_to_v15_1 = require("../../transformers/v14-to-v15");
-const v15_to_v16_1 = require("../../transformers/v15-to-v16");
-const v16_to_v17_1 = require("../../transformers/v16-to-v17");
-/**
- * Direct transformer from PG13 to PG17
- * This transformer chains v13->v14->v15->v16->v17 transformations
- */
-class PG13ToPG17Transformer {
-    v13to14 = new v13_to_v14_1.V13ToV14Transformer();
-    v14to15 = new v14_to_v15_1.V14ToV15Transformer();
-    v15to16 = new v15_to_v16_1.V15ToV16Transformer();
-    v16to17 = new v16_to_v17_1.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;
-    }
-}
-exports.PG13ToPG17Transformer = PG13ToPG17Transformer;

package/transformers-direct/v13-to-v18/index.d.ts

@@ -1,28 +0,0 @@
-import * as PG13 from '../../13/types';
-import * as PG18 from '../../18/types';
-/**
- * Direct transformer from PG13 to PG18
- * This transformer chains v13->...->v18 transformations
- */
-export declare class PG13ToPG18Transformer {
-    private v13to14;
-    private v14to15;
-    private v15to16;
-    private v16to17;
-    private v17to18;
-    /**
-     * Transform a node or parse result from PG13 to PG18
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG13.Node): PG18.Node;
-    transform(node: PG13.ParseResult): PG18.ParseResult;
-    /**
-     * Transform a single statement from PG13 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt: any): any;
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    private isParseResult;
-}

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

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG13ToPG18Transformer = void 0;
-const v13_to_v14_1 = require("../../transformers/v13-to-v14");
-const v14_to_v15_1 = require("../../transformers/v14-to-v15");
-const v15_to_v16_1 = require("../../transformers/v15-to-v16");
-const v16_to_v17_1 = require("../../transformers/v16-to-v17");
-const v17_to_v18_1 = require("../../transformers/v17-to-v18");
-/**
- * Direct transformer from PG13 to PG18
- * This transformer chains v13->...->v18 transformations
- */
-class PG13ToPG18Transformer {
-    v13to14 = new v13_to_v14_1.V13ToV14Transformer();
-    v14to15 = new v14_to_v15_1.V14ToV15Transformer();
-    v15to16 = new v15_to_v16_1.V15ToV16Transformer();
-    v16to17 = new v16_to_v17_1.V16ToV17Transformer();
-    v17to18 = new v17_to_v18_1.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;
-    }
-}
-exports.PG13ToPG18Transformer = PG13ToPG18Transformer;

package/transformers-direct/v14-to-v17/index.d.ts

@@ -1,26 +0,0 @@
-import * as PG14 from '../../14/types';
-import * as PG17 from '../../17/types';
-/**
- * Direct transformer from PG14 to PG17
- * This transformer chains v14->v15->v16->v17 transformations
- */
-export declare class PG14ToPG17Transformer {
-    private v14to15;
-    private v15to16;
-    private v16to17;
-    /**
-     * Transform a node or parse result from PG14 to PG17
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG14.Node): PG17.Node;
-    transform(node: PG14.ParseResult): PG17.ParseResult;
-    /**
-     * Transform a single statement from PG14 to PG17
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt: any): any;
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    private isParseResult;
-}

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

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG14ToPG17Transformer = void 0;
-const v14_to_v15_1 = require("../../transformers/v14-to-v15");
-const v15_to_v16_1 = require("../../transformers/v15-to-v16");
-const v16_to_v17_1 = require("../../transformers/v16-to-v17");
-/**
- * Direct transformer from PG14 to PG17
- * This transformer chains v14->v15->v16->v17 transformations
- */
-class PG14ToPG17Transformer {
-    v14to15 = new v14_to_v15_1.V14ToV15Transformer();
-    v15to16 = new v15_to_v16_1.V15ToV16Transformer();
-    v16to17 = new v16_to_v17_1.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;
-    }
-}
-exports.PG14ToPG17Transformer = PG14ToPG17Transformer;

package/transformers-direct/v14-to-v18/index.d.ts

@@ -1,27 +0,0 @@
-import * as PG14 from '../../14/types';
-import * as PG18 from '../../18/types';
-/**
- * Direct transformer from PG14 to PG18
- * This transformer chains v14->...->v18 transformations
- */
-export declare class PG14ToPG18Transformer {
-    private v14to15;
-    private v15to16;
-    private v16to17;
-    private v17to18;
-    /**
-     * Transform a node or parse result from PG14 to PG18
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG14.Node): PG18.Node;
-    transform(node: PG14.ParseResult): PG18.ParseResult;
-    /**
-     * Transform a single statement from PG14 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt: any): any;
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    private isParseResult;
-}