@pgsql/transform 17.9.19 → 18.1.0

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

@@ -0,0 +1,39 @@
+import { V17ToV18Transformer } from '../../transformers/v17-to-v18';
+/**
+ * Direct transformer from PG17 to PG18
+ * This transformer chains v17->...->v18 transformations
+ */
+export class PG17ToPG18Transformer {
+    v17to18 = new 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;
+    }
+}

package/index.d.ts

@@ -3,18 +3,26 @@ import { Node as PG14Node } from './14/types';
 import { Node as PG15Node } from './15/types';
 import { Node as PG16Node } from './16/types';
 import { Node as PG17Node } from './17/types';
+import { Node as PG18Node } from './18/types';
 import * as PG13Types from './13/types';
 import * as PG14Types from './14/types';
 import * as PG15Types from './15/types';
 import * as PG16Types from './16/types';
 import * as PG17Types from './17/types';
+import * as PG18Types from './18/types';
 export { ASTTransformer } from './multi-version-transformer';
 export { V13ToV14Transformer } from './transformers/v13-to-v14';
 export { V14ToV15Transformer } from './transformers/v14-to-v15';
 export { V15ToV16Transformer } from './transformers/v15-to-v16';
 export { V16ToV17Transformer } from './transformers/v16-to-v17';
+export { V17ToV18Transformer } from './transformers/v17-to-v18';
 export { PG13ToPG17Transformer } from './transformers-direct/v13-to-v17';
 export { PG14ToPG17Transformer } from './transformers-direct/v14-to-v17';
 export { PG15ToPG17Transformer } from './transformers-direct/v15-to-v17';
 export { PG16ToPG17Transformer } from './transformers-direct/v16-to-v17';
-export { PG13Node, PG14Node, PG15Node, PG16Node, PG17Node, PG13Types, PG14Types, PG15Types, PG16Types, PG17Types };
+export { PG13ToPG18Transformer } from './transformers-direct/v13-to-v18';
+export { PG14ToPG18Transformer } from './transformers-direct/v14-to-v18';
+export { PG15ToPG18Transformer } from './transformers-direct/v15-to-v18';
+export { PG16ToPG18Transformer } from './transformers-direct/v16-to-v18';
+export { PG17ToPG18Transformer } from './transformers-direct/v17-to-v18';
+export { PG13Node, PG14Node, PG15Node, PG16Node, PG17Node, PG18Node, PG13Types, PG14Types, PG15Types, PG16Types, PG17Types, PG18Types };

package/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG17Types = exports.PG16Types = exports.PG15Types = exports.PG14Types = exports.PG13Types = exports.PG16ToPG17Transformer = exports.PG15ToPG17Transformer = exports.PG14ToPG17Transformer = exports.PG13ToPG17Transformer = exports.V16ToV17Transformer = exports.V15ToV16Transformer = exports.V14ToV15Transformer = exports.V13ToV14Transformer = exports.ASTTransformer = void 0;
+exports.PG18Types = exports.PG17Types = exports.PG16Types = exports.PG15Types = exports.PG14Types = exports.PG13Types = exports.PG17ToPG18Transformer = exports.PG16ToPG18Transformer = exports.PG15ToPG18Transformer = exports.PG14ToPG18Transformer = exports.PG13ToPG18Transformer = exports.PG16ToPG17Transformer = exports.PG15ToPG17Transformer = exports.PG14ToPG17Transformer = exports.PG13ToPG17Transformer = exports.V17ToV18Transformer = exports.V16ToV17Transformer = exports.V15ToV16Transformer = exports.V14ToV15Transformer = exports.V13ToV14Transformer = exports.ASTTransformer = void 0;
 const PG13Types = __importStar(require("./13/types"));
 exports.PG13Types = PG13Types;
 const PG14Types = __importStar(require("./14/types"));
@@ -44,6 +44,8 @@ const PG16Types = __importStar(require("./16/types"));
 exports.PG16Types = PG16Types;
 const PG17Types = __importStar(require("./17/types"));
 exports.PG17Types = PG17Types;
+const PG18Types = __importStar(require("./18/types"));
+exports.PG18Types = PG18Types;
 var multi_version_transformer_1 = require("./multi-version-transformer");
 Object.defineProperty(exports, "ASTTransformer", { enumerable: true, get: function () { return multi_version_transformer_1.ASTTransformer; } });
 var v13_to_v14_1 = require("./transformers/v13-to-v14");
@@ -54,6 +56,8 @@ var v15_to_v16_1 = require("./transformers/v15-to-v16");
 Object.defineProperty(exports, "V15ToV16Transformer", { enumerable: true, get: function () { return v15_to_v16_1.V15ToV16Transformer; } });
 var v16_to_v17_1 = require("./transformers/v16-to-v17");
 Object.defineProperty(exports, "V16ToV17Transformer", { enumerable: true, get: function () { return v16_to_v17_1.V16ToV17Transformer; } });
+var v17_to_v18_1 = require("./transformers/v17-to-v18");
+Object.defineProperty(exports, "V17ToV18Transformer", { enumerable: true, get: function () { return v17_to_v18_1.V17ToV18Transformer; } });
 var v13_to_v17_1 = require("./transformers-direct/v13-to-v17");
 Object.defineProperty(exports, "PG13ToPG17Transformer", { enumerable: true, get: function () { return v13_to_v17_1.PG13ToPG17Transformer; } });
 var v14_to_v17_1 = require("./transformers-direct/v14-to-v17");
@@ -62,3 +66,13 @@ var v15_to_v17_1 = require("./transformers-direct/v15-to-v17");
 Object.defineProperty(exports, "PG15ToPG17Transformer", { enumerable: true, get: function () { return v15_to_v17_1.PG15ToPG17Transformer; } });
 var v16_to_v17_2 = require("./transformers-direct/v16-to-v17");
 Object.defineProperty(exports, "PG16ToPG17Transformer", { enumerable: true, get: function () { return v16_to_v17_2.PG16ToPG17Transformer; } });
+var v13_to_v18_1 = require("./transformers-direct/v13-to-v18");
+Object.defineProperty(exports, "PG13ToPG18Transformer", { enumerable: true, get: function () { return v13_to_v18_1.PG13ToPG18Transformer; } });
+var v14_to_v18_1 = require("./transformers-direct/v14-to-v18");
+Object.defineProperty(exports, "PG14ToPG18Transformer", { enumerable: true, get: function () { return v14_to_v18_1.PG14ToPG18Transformer; } });
+var v15_to_v18_1 = require("./transformers-direct/v15-to-v18");
+Object.defineProperty(exports, "PG15ToPG18Transformer", { enumerable: true, get: function () { return v15_to_v18_1.PG15ToPG18Transformer; } });
+var v16_to_v18_1 = require("./transformers-direct/v16-to-v18");
+Object.defineProperty(exports, "PG16ToPG18Transformer", { enumerable: true, get: function () { return v16_to_v18_1.PG16ToPG18Transformer; } });
+var v17_to_v18_2 = require("./transformers-direct/v17-to-v18");
+Object.defineProperty(exports, "PG17ToPG18Transformer", { enumerable: true, get: function () { return v17_to_v18_2.PG17ToPG18Transformer; } });

package/multi-version-transformer.d.ts

@@ -6,4 +6,9 @@ export declare class ASTTransformer {
     transform14To17(ast: any): any;
     transform15To17(ast: any): any;
     transform16To17(ast: any): any;
+    transform13To18(ast: any): any;
+    transform14To18(ast: any): any;
+    transform15To18(ast: any): any;
+    transform16To18(ast: any): any;
+    transform17To18(ast: any): any;
 }

package/multi-version-transformer.js

@@ -5,12 +5,14 @@ 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");
 class ASTTransformer {
     transformers = {
         '13-14': new v13_to_v14_1.V13ToV14Transformer(),
         '14-15': new v14_to_v15_1.V14ToV15Transformer(),
         '15-16': new v15_to_v16_1.V15ToV16Transformer(),
         '16-17': new v16_to_v17_1.V16ToV17Transformer(),
+        '17-18': new v17_to_v18_1.V17ToV18Transformer(),
     };
     transform(ast, fromVersion, toVersion) {
         if (fromVersion === toVersion) {
@@ -38,6 +40,9 @@ class ASTTransformer {
                 case '16-17':
                     currentAst = this.transformers['16-17'].transform(currentAst, { parentNodeTypes: [] });
                     break;
+                case '17-18':
+                    currentAst = this.transformers['17-18'].transform(currentAst, { parentNodeTypes: [] });
+                    break;
                 default:
                     throw new Error(`No transformer available for v${currentVersion} to v${nextVersion}`);
             }
@@ -46,7 +51,7 @@ class ASTTransformer {
         return currentAst;
     }
     transformToLatest(ast, fromVersion) {
-        return this.transform(ast, fromVersion, 17);
+        return this.transform(ast, fromVersion, 18);
     }
     transform13To17(ast) {
         return this.transform(ast, 13, 17);
@@ -60,5 +65,20 @@ class ASTTransformer {
     transform16To17(ast) {
         return this.transform(ast, 16, 17);
     }
+    transform13To18(ast) {
+        return this.transform(ast, 13, 18);
+    }
+    transform14To18(ast) {
+        return this.transform(ast, 14, 18);
+    }
+    transform15To18(ast) {
+        return this.transform(ast, 15, 18);
+    }
+    transform16To18(ast) {
+        return this.transform(ast, 16, 18);
+    }
+    transform17To18(ast) {
+        return this.transform(ast, 17, 18);
+    }
 }
 exports.ASTTransformer = ASTTransformer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgsql/transform",
-  "version": "17.9.19",
+  "version": "18.1.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Transform PostgreSQL AST types for pgsql-parser",
   "main": "index.js",
@@ -34,10 +34,12 @@
   },
   "devDependencies": {
     "@pgsql/parser": "^1.2.1",
+    "@pgsql/types": "^18.0.0",
+    "libpg-query": "18.1.1",
     "makage": "^0.1.8",
-    "pg-proto-parser": "1.30.6",
-    "pgsql-deparser": "17.18.5"
+    "pg-proto-parser": "1.31.0",
+    "pgsql-deparser": "18.1.0"
   },
   "keywords": [],
-  "gitHead": "4213e2c9da8ccb8d21c4ec02f35e34aef65b8ced"
+  "gitHead": "13f064c263eb304d704fd21148add24a9d60a8ee"
 }

package/transformers/v13-to-v14.d.ts

@@ -144,6 +144,9 @@ export declare class V13ToV14Transformer {
     };
     private transformTableLikeOption;
     private extractParameterNameFromFunctionName;
+    AlterExtensionContentsStmt(node: PG13.AlterExtensionContentsStmt, context: TransformerContext): {
+        AlterExtensionContentsStmt: PG14.AlterExtensionContentsStmt;
+    };
     ObjectWithArgs(node: PG13.ObjectWithArgs, context: TransformerContext): {
         ObjectWithArgs: PG14.ObjectWithArgs;
     };

package/transformers/v13-to-v14.js

@@ -1635,6 +1635,25 @@ class V13ToV14Transformer {
         // Functions like testfunc1(int), testfunc2(int), testfunc4(boolean) should NOT have parameter names
         return undefined;
     }
+    AlterExtensionContentsStmt(node, context) {
+        const result = {};
+        const childContext = {
+            ...context,
+            alterExtensionObjtype: node.objtype
+        };
+        for (const [key, value] of Object.entries(node)) {
+            if (Array.isArray(value)) {
+                result[key] = value.map(item => this.transform(item, childContext));
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = this.transform(value, childContext);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return { AlterExtensionContentsStmt: result };
+    }
     ObjectWithArgs(node, context) {
         const result = { ...node };
         if (result.objname !== undefined) {
@@ -1836,6 +1855,9 @@ class V13ToV14Transformer {
         if (!context.parentNodeTypes || context.parentNodeTypes.length === 0) {
             return false;
         }
+        if (context.alterExtensionObjtype === 'OBJECT_OPERATOR') {
+            return false;
+        }
         if (context.commentObjtype === 'OBJECT_OPERATOR' &&
             context.parentNodeTypes.includes('CommentStmt')) {
             return false;
@@ -1892,7 +1914,7 @@ class V13ToV14Transformer {
             }
         }
         const allowedNodeTypes = [
-            'CommentStmt', 'AlterFunctionStmt', 'RenameStmt', 'AlterOwnerStmt', 'AlterObjectSchemaStmt', 'CreateCastStmt', 'CreateTransformStmt', 'AlterOpFamilyStmt', 'CreateOpClassItem', 'GrantStmt', 'RevokeStmt'
+            'CommentStmt', 'AlterFunctionStmt', 'RenameStmt', 'AlterOwnerStmt', 'AlterObjectSchemaStmt', 'CreateCastStmt', 'CreateTransformStmt', 'AlterOpFamilyStmt', 'CreateOpClassItem', 'GrantStmt', 'RevokeStmt', 'AlterExtensionContentsStmt'
         ];
         for (const node of path) {
             if (node && typeof node === 'object') {

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

@@ -495,6 +495,9 @@ export declare class V16ToV17Transformer {
     MergeStmt(node: PG16.MergeStmt, context: TransformerContext): {
         MergeStmt: PG17.MergeStmt;
     };
+    MergeWhenClause(node: PG16.MergeWhenClause, context: TransformerContext): {
+        MergeWhenClause: PG17.MergeWhenClause;
+    };
     AlterTableMoveAllStmt(node: PG16.AlterTableMoveAllStmt, context: TransformerContext): {
         AlterTableMoveAllStmt: PG17.AlterTableMoveAllStmt;
     };

package/transformers/v16-to-v17.js

@@ -1108,7 +1108,50 @@ class V16ToV17Transformer {
         return { AlterOpFamilyStmt: node };
     }
     MergeStmt(node, context) {
-        return { MergeStmt: node };
+        const result = {};
+        if (node.relation !== undefined) {
+            result.relation = node.relation;
+        }
+        if (node.sourceRelation !== undefined) {
+            result.sourceRelation = this.transform(node.sourceRelation, context);
+        }
+        if (node.joinCondition !== undefined) {
+            result.joinCondition = this.transform(node.joinCondition, context);
+        }
+        if (node.mergeWhenClauses !== undefined) {
+            result.mergeWhenClauses = Array.isArray(node.mergeWhenClauses)
+                ? node.mergeWhenClauses.map(item => this.transform(item, context))
+                : this.transform(node.mergeWhenClauses, context);
+        }
+        if (node.withClause !== undefined) {
+            result.withClause = this.WithClause(node.withClause, context);
+        }
+        return { MergeStmt: result };
+    }
+    MergeWhenClause(node, context) {
+        const result = {};
+        // v17 replaces the boolean matched with matchKind
+        result.matchKind = node.matched ? 'MERGE_WHEN_MATCHED' : 'MERGE_WHEN_NOT_MATCHED_BY_TARGET';
+        if (node.commandType !== undefined) {
+            result.commandType = node.commandType;
+        }
+        if (node.override !== undefined) {
+            result.override = node.override;
+        }
+        if (node.condition !== undefined) {
+            result.condition = this.transform(node.condition, context);
+        }
+        if (node.targetList !== undefined) {
+            result.targetList = Array.isArray(node.targetList)
+                ? node.targetList.map(item => this.transform(item, context))
+                : this.transform(node.targetList, context);
+        }
+        if (node.values !== undefined) {
+            result.values = Array.isArray(node.values)
+                ? node.values.map(item => this.transform(item, context))
+                : this.transform(node.values, context);
+        }
+        return { MergeWhenClause: result };
     }
     AlterTableMoveAllStmt(node, context) {
         return { AlterTableMoveAllStmt: node };

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

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

@@ -0,0 +1,208 @@
+"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,8 +1,13 @@
 /**
- * Direct transformers for PostgreSQL version upgrades to PG17
+ * 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,10 +1,10 @@
 "use strict";
 /**
- * Direct transformers for PostgreSQL version upgrades to PG17
+ * Direct transformers for PostgreSQL version upgrades to PG17/PG18
  * These transformers are designed for tree-shaking optimization
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PG16ToPG17Transformer = exports.PG15ToPG17Transformer = exports.PG14ToPG17Transformer = exports.PG13ToPG17Transformer = void 0;
+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");
@@ -13,3 +13,13 @@ 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-v18/index.d.ts

@@ -0,0 +1,28 @@
+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;
+}