pgsql-deparser 13.19.1 → 13.20.0

package/esm/v16-to-v17.js

@@ -652,6 +652,12 @@ export class V16ToV17Transformer {
         if (node.storage !== undefined) {
             result.storage = node.storage;
         }
+        if (node.storage_name !== undefined) {
+            result.storage_name = node.storage_name;
+        }
+        if (node.compression !== undefined) {
+            result.compression = node.compression;
+        }
         if (node.raw_default !== undefined) {
             result.raw_default = this.transform(node.raw_default, context);
         }
@@ -1110,7 +1116,50 @@ export 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/esm/v17-to-v18.js

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

package/index.d.ts

@@ -3,7 +3,21 @@
  * Auto-generated by generate-version-deparsers.ts
  */
 import { Node, ParseResult } from '@pgsql/types';
-import { DeparserOptions } from './deparser';
-export declare function deparse(query: Node | Node[] | ParseResult, opts?: DeparserOptions): Promise<string>;
-export declare function deparseSync(query: Node | Node[] | ParseResult, opts?: DeparserOptions): string;
-export { DeparserOptions } from './deparser';
+import { Deparser as Deparser18, DeparserOptions } from './deparser';
+type Query = Node | Node[] | ParseResult;
+export declare class Deparser extends Deparser18 {
+    constructor(tree: Query, opts?: DeparserOptions);
+    static deparse(query: Query, opts?: DeparserOptions): string;
+    DefElem(node: any, context: any): string;
+    GrantRoleStmt(node: any, context: any): string;
+    private publicationTableListed;
+    CreatePublicationStmt(node: any, context: any): string;
+    AlterPublicationStmt(node: any, context: any): string;
+    PublicationObjSpec(node: any, context: any): string;
+    ReindexStmt(node: any, context: any): string;
+}
+export declare function deparse(query: Query, opts?: DeparserOptions): Promise<string>;
+export declare function deparseSync(query: Query, opts?: DeparserOptions): string;
+export { DeparserOptions };
+export { splitSqlLines } from './deparser/utils/sql-formatter';
+export { QuoteUtils } from '@pgsql/quotes';

package/index.js

@@ -4,16 +4,114 @@
  * Auto-generated by generate-version-deparsers.ts
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteUtils = exports.splitSqlLines = exports.Deparser = void 0;
 exports.deparse = deparse;
 exports.deparseSync = deparseSync;
 const deparser_1 = require("./deparser");
-const v13_to_v17_direct_1 = require("./v13-to-v17-direct");
-const tx = new v13_to_v17_direct_1.PG13ToPG17Transformer();
+const v13_to_v18_direct_1 = require("./v13-to-v18-direct");
+const tx = new v13_to_v18_direct_1.PG13ToPG18Transformer();
+const bare = (names, name) => Array.isArray(names) && names.length === 1 && (names[0]?.String?.sval ?? names[0]?.String?.str) === name;
+const v16to17 = tx.v16to17;
+const upgradeTypeName = v16to17.TypeName.bind(v16to17);
+v16to17.TypeName = (node, context) => {
+    const out = upgradeTypeName(node, context);
+    if (bare(node.names, 'json'))
+        out.TypeName.names = [{ String: { sval: 'json' } }];
+    return out;
+};
+const upgradeTypeCast = v16to17.TypeCast.bind(v16to17);
+v16to17.TypeCast = (node, context) => {
+    const out = upgradeTypeCast(node, context);
+    const typeName = out.TypeCast.typeName?.TypeName ?? out.TypeCast.typeName;
+    if (typeName && bare((node.typeName?.TypeName ?? node.typeName)?.names, 'json')) {
+        typeName.names = [{ String: { sval: 'json' } }];
+    }
+    return out;
+};
+const v15to16 = tx.v15to16;
+const upgradeFuncCall = v15to16.FuncCall.bind(v15to16);
+v15to16.FuncCall = (node, context) => {
+    const out = upgradeFuncCall(node, context);
+    if (out.FuncCall && bare(node.funcname, 'json_object')) {
+        out.FuncCall.funcname = [{ String: { sval: 'json_object' } }];
+    }
+    return out;
+};
+const v13to14 = tx.v13to14;
+const upgradeSubstring = v13to14.FuncCall.bind(v13to14);
+v13to14.FuncCall = (node, context) => {
+    const out = upgradeSubstring(node, context);
+    const [schema, name] = (node.funcname ?? []).map((part) => part?.String?.str ?? part?.String?.sval);
+    const argCount = node.args?.length;
+    if (out.FuncCall && node.funcname?.length === 2 && schema === 'pg_catalog' && name === 'substring' && (argCount === 2 || argCount === 3)) {
+        out.FuncCall.funcname = [{ String: { sval: 'pg_catalog' } }, { String: { sval: 'substring' } }];
+        out.FuncCall.funcformat = 'COERCE_SQL_SYNTAX';
+    }
+    return out;
+};
+const toAst18 = (query) => Array.isArray(query) ? query.map(node => tx.transform(node)) : tx.transform(query);
+class Deparser extends deparser_1.Deparser {
+    constructor(tree, opts = {}) {
+        super(toAst18(tree), opts);
+    }
+    static deparse(query, opts = {}) {
+        return new Deparser(query, opts).deparseQuery();
+    }
+    DefElem(node, context) {
+        if (!node.arg && node.defaction !== 'DEFELEM_DROP' && context.parentNodeTypes.includes('AlterOperatorStmt')) {
+            return `${node.defname} = NONE`;
+        }
+        return super.DefElem(node, context);
+    }
+    GrantRoleStmt(node, context) {
+        const sql = super.GrantRoleStmt(node, context);
+        const opts = (Array.isArray(node.opt) ? node.opt : []).map((opt) => opt.DefElem);
+        const arg = opts[0]?.arg;
+        const off = arg?.Boolean ? arg.Boolean.boolval !== true : arg?.String?.sval === 'false';
+        if (!node.is_grant || opts.length !== 1 || opts[0]?.defname !== 'admin' || off)
+            return sql;
+        // locate the option by what the statement prints without GRANTED BY, so a role name can never match
+        const head = node.grantor ? super.GrantRoleStmt({ ...node, grantor: undefined }, context) : sql;
+        const option = ' WITH ADMIN TRUE';
+        if (!head.endsWith(option) || !sql.startsWith(head))
+            return sql;
+        return head.slice(0, -option.length) + ' WITH ADMIN OPTION' + sql.slice(head.length);
+    }
+    publicationTableListed = false;
+    CreatePublicationStmt(node, context) {
+        this.publicationTableListed = false;
+        return super.CreatePublicationStmt(node, context);
+    }
+    AlterPublicationStmt(node, context) {
+        this.publicationTableListed = false;
+        return super.AlterPublicationStmt(node, context);
+    }
+    PublicationObjSpec(node, context) {
+        const sql = super.PublicationObjSpec(node, context);
+        if (node.pubobjtype !== 'PUBLICATIONOBJ_TABLE')
+            return sql;
+        const first = !this.publicationTableListed;
+        this.publicationTableListed = true;
+        return first ? sql : sql.replace(/^TABLE /, '');
+    }
+    ReindexStmt(node, context) {
+        const params = Array.isArray(node.params) ? node.params : [];
+        const others = params.filter((param) => param?.DefElem?.defname !== 'concurrently');
+        if (others.length === params.length)
+            return super.ReindexStmt(node, context);
+        return super
+            .ReindexStmt({ ...node, params: others }, context)
+            .replace(/^REINDEX( \([^)]*\))? (INDEX|TABLE|SCHEMA|SYSTEM|DATABASE)/, match => `${match} CONCURRENTLY`);
+    }
+}
+exports.Deparser = Deparser;
 async function deparse(query, opts) {
-    const ast17 = tx.transform(query);
-    return await (0, deparser_1.deparse)(ast17, opts);
+    return Deparser.deparse(query, opts);
 }
 function deparseSync(query, opts) {
-    const ast17 = tx.transform(query);
-    return (0, deparser_1.deparseSync)(ast17, opts);
+    return Deparser.deparse(query, opts);
 }
+var sql_formatter_1 = require("./deparser/utils/sql-formatter");
+Object.defineProperty(exports, "splitSqlLines", { enumerable: true, get: function () { return sql_formatter_1.splitSqlLines; } });
+var quotes_1 = require("@pgsql/quotes");
+Object.defineProperty(exports, "QuoteUtils", { enumerable: true, get: function () { return quotes_1.QuoteUtils; } });

package/package.json

@@ -34,8 +34,9 @@
     "database"
   ],
   "name": "pgsql-deparser",
-  "version": "13.19.1",
+  "version": "13.20.0",
   "dependencies": {
-    "@pgsql/types": "^13.11.1"
+    "@pgsql/quotes": "18.2.4",
+    "@pgsql/types": "^13.11.2"
   }
 }

package/v13-to-v14.d.ts

@@ -145,6 +145,9 @@ export declare class V13ToV14Transformer {
     };
     private transformTableLikeOption;
     private extractParameterNameFromFunctionName;
+    AlterExtensionContentsStmt(node: any, context: any): {
+        AlterExtensionContentsStmt: any;
+    };
     ObjectWithArgs(node: any, context: any): {
         ObjectWithArgs: any;
     };
@@ -211,6 +214,9 @@ export declare class V13ToV14Transformer {
         WithClause: any;
     };
     private shouldConvertCTEsToArray;
+    AlterSubscriptionStmt(node: any, context: any): {
+        AlterSubscriptionStmt: any;
+    };
     AlterSeqStmt(node: any, context: any): {
         AlterSeqStmt: any;
     };

package/v13-to-v14.js

@@ -1019,10 +1019,13 @@ class V13ToV14Transformer {
         }
         if (node.func !== undefined) {
             // Handle plain object func (not wrapped in ObjectWithArgs)
-            if (typeof node.func === 'object' && !('ObjectWithArgs' in node.func) && 'objargs' in node.func) {
+            if (typeof node.func === 'object' && !('ObjectWithArgs' in node.func) && ('objargs' in node.func || 'objname' in node.func)) {
                 const funcResult = {};
-                if (node.func.objname !== undefined) {
-                    funcResult.objname = this.transform(node.func.objname, childContext);
+                const objname = node.func.objname;
+                if (objname !== undefined) {
+                    funcResult.objname = Array.isArray(objname)
+                        ? objname.map((item) => this.transform(item, childContext))
+                        : this.transform(objname, childContext);
                 }
                 if (node.func.objargs !== undefined) {
                     funcResult.objargs = this.transform(node.func.objargs, childContext);
@@ -1030,6 +1033,9 @@ class V13ToV14Transformer {
                         ? node.func.objargs.map((arg, index) => this.createFunctionParameterFromTypeName(arg, childContext, index))
                         : [this.createFunctionParameterFromTypeName(node.func.objargs, childContext, 0)];
                 }
+                if (node.func.args_unspecified !== undefined) {
+                    funcResult.args_unspecified = node.func.args_unspecified;
+                }
                 result.func = funcResult;
             }
             else {
@@ -1640,6 +1646,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) {
@@ -1841,6 +1866,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;
@@ -1897,7 +1925,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') {
@@ -1972,7 +2000,7 @@ class V13ToV14Transformer {
         const argType = transformedTypeName.TypeName ? transformedTypeName.TypeName : transformedTypeName;
         // Check if this should be a variadic parameter
         const isVariadic = this.isVariadicParameterType(typeNameNode, index, undefined, context);
-        let mode = isVariadic ? "FUNC_PARAM_VARIADIC" : "FUNC_PARAM_DEFAULT";
+        let mode = isVariadic ? 'FUNC_PARAM_VARIADIC' : 'FUNC_PARAM_DEFAULT';
         const functionParam = {
             argType: argType,
             mode: mode
@@ -2007,31 +2035,31 @@ class V13ToV14Transformer {
     }
     transformA_Expr_Kind(kind) {
         const pg13ToP14Map = {
-            'AEXPR_OP': 'AEXPR_OP',
-            'AEXPR_OP_ANY': 'AEXPR_OP_ANY',
-            'AEXPR_OP_ALL': 'AEXPR_OP_ALL',
-            'AEXPR_DISTINCT': 'AEXPR_DISTINCT',
-            'AEXPR_NOT_DISTINCT': 'AEXPR_NOT_DISTINCT',
-            'AEXPR_NULLIF': 'AEXPR_NULLIF',
-            'AEXPR_OF': 'AEXPR_IN', // AEXPR_OF removed, map to AEXPR_IN
-            'AEXPR_IN': 'AEXPR_IN',
-            'AEXPR_LIKE': 'AEXPR_LIKE',
-            'AEXPR_ILIKE': 'AEXPR_ILIKE',
-            'AEXPR_SIMILAR': 'AEXPR_SIMILAR',
-            'AEXPR_BETWEEN': 'AEXPR_BETWEEN',
-            'AEXPR_NOT_BETWEEN': 'AEXPR_NOT_BETWEEN',
-            'AEXPR_BETWEEN_SYM': 'AEXPR_BETWEEN_SYM',
-            'AEXPR_NOT_BETWEEN_SYM': 'AEXPR_NOT_BETWEEN_SYM',
-            'AEXPR_PAREN': 'AEXPR_OP' // AEXPR_PAREN removed, map to AEXPR_OP
+            AEXPR_OP: 'AEXPR_OP',
+            AEXPR_OP_ANY: 'AEXPR_OP_ANY',
+            AEXPR_OP_ALL: 'AEXPR_OP_ALL',
+            AEXPR_DISTINCT: 'AEXPR_DISTINCT',
+            AEXPR_NOT_DISTINCT: 'AEXPR_NOT_DISTINCT',
+            AEXPR_NULLIF: 'AEXPR_NULLIF',
+            AEXPR_OF: 'AEXPR_IN', // AEXPR_OF removed, map to AEXPR_IN
+            AEXPR_IN: 'AEXPR_IN',
+            AEXPR_LIKE: 'AEXPR_LIKE',
+            AEXPR_ILIKE: 'AEXPR_ILIKE',
+            AEXPR_SIMILAR: 'AEXPR_SIMILAR',
+            AEXPR_BETWEEN: 'AEXPR_BETWEEN',
+            AEXPR_NOT_BETWEEN: 'AEXPR_NOT_BETWEEN',
+            AEXPR_BETWEEN_SYM: 'AEXPR_BETWEEN_SYM',
+            AEXPR_NOT_BETWEEN_SYM: 'AEXPR_NOT_BETWEEN_SYM',
+            AEXPR_PAREN: 'AEXPR_OP' // AEXPR_PAREN removed, map to AEXPR_OP
         };
         return pg13ToP14Map[kind] || kind;
     }
     transformRoleSpecType(type) {
         const pg13ToP14Map = {
-            'ROLESPEC_CSTRING': 'ROLESPEC_CSTRING',
-            'ROLESPEC_CURRENT_USER': 'ROLESPEC_CURRENT_USER',
-            'ROLESPEC_SESSION_USER': 'ROLESPEC_SESSION_USER',
-            'ROLESPEC_PUBLIC': 'ROLESPEC_PUBLIC'
+            ROLESPEC_CSTRING: 'ROLESPEC_CSTRING',
+            ROLESPEC_CURRENT_USER: 'ROLESPEC_CURRENT_USER',
+            ROLESPEC_SESSION_USER: 'ROLESPEC_SESSION_USER',
+            ROLESPEC_PUBLIC: 'ROLESPEC_PUBLIC'
         };
         return pg13ToP14Map[type] || type;
     }
@@ -2090,11 +2118,11 @@ class V13ToV14Transformer {
     A_Expr(node, context) {
         const result = {};
         if (node.kind !== undefined) {
-            if (node.kind === "AEXPR_OF") {
-                result.kind = "AEXPR_IN";
+            if (node.kind === 'AEXPR_OF') {
+                result.kind = 'AEXPR_IN';
             }
-            else if (node.kind === "AEXPR_PAREN") {
-                result.kind = "AEXPR_OP";
+            else if (node.kind === 'AEXPR_PAREN') {
+                result.kind = 'AEXPR_OP';
             }
             else {
                 result.kind = node.kind;
@@ -2333,6 +2361,14 @@ class V13ToV14Transformer {
     shouldConvertCTEsToArray(context) {
         return true;
     }
+    AlterSubscriptionStmt(node, context) {
+        const result = this.transformGenericNode(node, context);
+        // PG14 added ADD / DROP PUBLICATION and renamed the existing SET PUBLICATION kind
+        if (result.kind === 'ALTER_SUBSCRIPTION_PUBLICATION') {
+            result.kind = 'ALTER_SUBSCRIPTION_SET_PUBLICATION';
+        }
+        return { AlterSubscriptionStmt: result };
+    }
     AlterSeqStmt(node, context) {
         const result = {};
         if (node.sequence !== undefined) {
@@ -2748,6 +2784,17 @@ class V13ToV14Transformer {
         else if (nodeAny.params !== undefined) {
             result.params = this.transform(nodeAny.params, context);
         }
+        if (nodeAny.concurrent === true) {
+            result.params = [
+                ...(result.params || []),
+                {
+                    DefElem: {
+                        defname: 'concurrently',
+                        defaction: 'DEFELEM_UNSPEC'
+                    }
+                }
+            ];
+        }
         return { ReindexStmt: result };
     }
 }

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

@@ -0,0 +1,25 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-direct-transformer-types.ts
+ */
+/**
+ * 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(node: any): any;
+    /**
+     * 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;
+}