@pgsql/transform 17.6.2 → 17.7.0

package/transformers-direct/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Direct transformers for PostgreSQL version upgrades to PG17
+ * 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';

package/transformers-direct/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Direct transformers for PostgreSQL version upgrades to PG17
+ * These transformers are designed for tree-shaking optimization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,78 @@
+"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/v14-to-v17/index.d.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,67 @@
+"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/v15-to-v17/index.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,57 @@
+"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/v16-to-v17/index.d.ts

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,44 @@
+"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;