@pgsql/transform 18.1.0 → 18.3.0

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

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG14ToPG18Transformer = 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");
-const v17_to_v18_1 = require("../../transformers/v17-to-v18");
-/**
- * Direct transformer from PG14 to PG18
- * This transformer chains v14->...->v18 transformations
- */
-class PG14ToPG18Transformer {
-    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: 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;
-    }
-}
-exports.PG14ToPG18Transformer = PG14ToPG18Transformer;

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

@@ -1,25 +0,0 @@
-import * as PG15 from '../../15/types';
-import * as PG17 from '../../17/types';
-/**
- * Direct transformer from PG15 to PG17
- * This transformer chains v15->v16->v17 transformations
- */
-export declare class PG15ToPG17Transformer {
-    private v15to16;
-    private v16to17;
-    /**
-     * Transform a node or parse result from PG15 to PG17
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG15.Node): PG17.Node;
-    transform(node: PG15.ParseResult): PG17.ParseResult;
-    /**
-     * Transform a single statement from PG15 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/v15-to-v17/index.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG15ToPG17Transformer = void 0;
-const v15_to_v16_1 = require("../../transformers/v15-to-v16");
-const v16_to_v17_1 = require("../../transformers/v16-to-v17");
-/**
- * Direct transformer from PG15 to PG17
- * This transformer chains v15->v16->v17 transformations
- */
-class PG15ToPG17Transformer {
-    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)) {
-            // 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;
-    }
-}
-exports.PG15ToPG17Transformer = PG15ToPG17Transformer;

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

@@ -1,26 +0,0 @@
-import * as PG15 from '../../15/types';
-import * as PG18 from '../../18/types';
-/**
- * Direct transformer from PG15 to PG18
- * This transformer chains v15->...->v18 transformations
- */
-export declare class PG15ToPG18Transformer {
-    private v15to16;
-    private v16to17;
-    private v17to18;
-    /**
-     * Transform a node or parse result from PG15 to PG18
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG15.Node): PG18.Node;
-    transform(node: PG15.ParseResult): PG18.ParseResult;
-    /**
-     * Transform a single statement from PG15 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/v15-to-v18/index.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG15ToPG18Transformer = void 0;
-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 PG15 to PG18
- * This transformer chains v15->...->v18 transformations
- */
-class PG15ToPG18Transformer {
-    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: 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;
-    }
-}
-exports.PG15ToPG18Transformer = PG15ToPG18Transformer;

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

@@ -1,24 +0,0 @@
-import * as PG16 from '../../16/types';
-import * as PG17 from '../../17/types';
-/**
- * Direct transformer from PG16 to PG17
- * This transformer only includes the necessary code for v16->v17 transformation
- */
-export declare class PG16ToPG17Transformer {
-    private transformer;
-    /**
-     * Transform a node or parse result from PG16 to PG17
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG16.Node): PG17.Node;
-    transform(node: PG16.ParseResult): PG17.ParseResult;
-    /**
-     * Transform a single statement from PG16 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/v16-to-v17/index.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG16ToPG17Transformer = void 0;
-const v16_to_v17_1 = require("../../transformers/v16-to-v17");
-/**
- * Direct transformer from PG16 to PG17
- * This transformer only includes the necessary code for v16->v17 transformation
- */
-class PG16ToPG17Transformer {
-    transformer = new v16_to_v17_1.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;
-    }
-}
-exports.PG16ToPG17Transformer = PG16ToPG17Transformer;

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

@@ -1,25 +0,0 @@
-import * as PG16 from '../../16/types';
-import * as PG18 from '../../18/types';
-/**
- * Direct transformer from PG16 to PG18
- * This transformer chains v16->...->v18 transformations
- */
-export declare class PG16ToPG18Transformer {
-    private v16to17;
-    private v17to18;
-    /**
-     * Transform a node or parse result from PG16 to PG18
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG16.Node): PG18.Node;
-    transform(node: PG16.ParseResult): PG18.ParseResult;
-    /**
-     * Transform a single statement from PG16 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/v16-to-v18/index.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG16ToPG18Transformer = void 0;
-const v16_to_v17_1 = require("../../transformers/v16-to-v17");
-const v17_to_v18_1 = require("../../transformers/v17-to-v18");
-/**
- * Direct transformer from PG16 to PG18
- * This transformer chains v16->...->v18 transformations
- */
-class PG16ToPG18Transformer {
-    v16to17 = new v16_to_v17_1.V16ToV17Transformer();
-    v17to18 = new v17_to_v18_1.V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v16->v17->v18
-            const v17Stmts = node.stmts.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 v17Node = this.v16to17.transform(node, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG16 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v17Stmt = this.v16to17.transform(stmt, { 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.PG16ToPG18Transformer = PG16ToPG18Transformer;

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

@@ -1,24 +0,0 @@
-import * as PG17 from '../../17/types';
-import * as PG18 from '../../18/types';
-/**
- * Direct transformer from PG17 to PG18
- * This transformer chains v17->...->v18 transformations
- */
-export declare class PG17ToPG18Transformer {
-    private v17to18;
-    /**
-     * Transform a node or parse result from PG17 to PG18
-     * @param node - Can be a ParseResult or any Node type
-     */
-    transform(node: PG17.Node): PG18.Node;
-    transform(node: PG17.ParseResult): PG18.ParseResult;
-    /**
-     * Transform a single statement from PG17 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/v17-to-v18/index.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG17ToPG18Transformer = void 0;
-const v17_to_v18_1 = require("../../transformers/v17-to-v18");
-/**
- * Direct transformer from PG17 to PG18
- * This transformer chains v17->...->v18 transformations
- */
-class PG17ToPG18Transformer {
-    v17to18 = new v17_to_v18_1.V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            const transformedStmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const transformedStmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: transformedStmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 180004, // PG18 version
-                stmts: transformedStmts
-            };
-        }
-        // Otherwise, transform as a regular node
-        return this.v17to18.transform(node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG17 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        return this.v17to18.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;
-    }
-}
-exports.PG17ToPG18Transformer = PG17ToPG18Transformer;