pgsql-deparser 13.19.0 → 13.20.0

package/esm/deparser/index.js

@@ -2,7 +2,7 @@
  * Auto-generated file with types stripped for better tree-shaking
  * DO NOT EDIT - Generated by strip-deparser-types.ts
  */
-import { Deparser } from "./deparser";
+import { Deparser } from './deparser';
 const deparseMethod = Deparser.deparse;
 // Export the original sync version as deparseSync
 export const deparseSync = deparseMethod;
@@ -11,3 +11,5 @@ export const deparse = async (...args) => {
     return deparseMethod(...args);
 };
 export { Deparser };
+export { splitSqlLines } from './utils/sql-formatter';
+export { QuoteUtils } from '@pgsql/quotes';

package/esm/deparser/utils/sql-formatter.js

@@ -2,6 +2,108 @@
  * Auto-generated file with types stripped for better tree-shaking
  * DO NOT EDIT - Generated by strip-deparser-types.ts
  */
+const isIdentChar = (ch) => ch !== undefined && (/[A-Za-z0-9_$]/.test(ch) || ch.charCodeAt(0) >= 0x80);
+const DOLLAR_TAG = /\$(?:[A-Za-z_\u0080-\uffff][A-Za-z0-9_\u0080-\uffff]*)?\$/y;
+/**
+ * Splits SQL text into lines, breaking only at newlines that sit between
+ * tokens. A newline inside a string literal ('...', E'...', $tag$...$tag$),
+ * a quoted identifier or a block comment is part of that token's value and
+ * stays inside its line, so callers can re-indent the lines without changing
+ * what the SQL means.
+ */
+export function splitSqlLines(text, newlineChar = '\n') {
+    if (!newlineChar || !text.includes(newlineChar)) {
+        return [text];
+    }
+    const lines = [];
+    const length = text.length;
+    let lineStart = 0;
+    let i = 0;
+    while (i < length) {
+        const ch = text[i];
+        if (ch === "'") {
+            const prev = text[i - 1];
+            const backslashEscapes = (prev === 'E' || prev === 'e') && !isIdentChar(text[i - 2]);
+            i++;
+            while (i < length) {
+                if (backslashEscapes && text[i] === '\\') {
+                    i += 2;
+                }
+                else if (text[i] === "'") {
+                    if (text[i + 1] === "'") {
+                        i += 2;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            i++;
+        }
+        else if (ch === '"') {
+            i++;
+            while (i < length) {
+                if (text[i] === '"') {
+                    if (text[i + 1] === '"') {
+                        i += 2;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            i++;
+        }
+        else if (ch === '$' && !isIdentChar(text[i - 1])) {
+            DOLLAR_TAG.lastIndex = i;
+            const tag = DOLLAR_TAG.exec(text);
+            if (tag) {
+                const close = text.indexOf(tag[0], i + tag[0].length);
+                i = close === -1 ? length : close + tag[0].length;
+            }
+            else {
+                i++;
+            }
+        }
+        else if (ch === '-' && text[i + 1] === '-') {
+            const end = text.indexOf('\n', i);
+            i = end === -1 ? length : end;
+        }
+        else if (ch === '/' && text[i + 1] === '*') {
+            let depth = 1;
+            i += 2;
+            while (i < length && depth > 0) {
+                if (text[i] === '/' && text[i + 1] === '*') {
+                    depth++;
+                    i += 2;
+                }
+                else if (text[i] === '*' && text[i + 1] === '/') {
+                    depth--;
+                    i += 2;
+                }
+                else {
+                    i++;
+                }
+            }
+        }
+        else if (text.startsWith(newlineChar, i)) {
+            lines.push(text.slice(lineStart, i));
+            i += newlineChar.length;
+            lineStart = i;
+        }
+        else {
+            i++;
+        }
+    }
+    lines.push(text.slice(lineStart));
+    return lines;
+}
 export class SqlFormatter {
     newlineChar;
     tabChar;
@@ -19,7 +121,7 @@ export class SqlFormatter {
             return text;
         }
         const indentation = this.tabChar.repeat(count);
-        return text.split(this.newlineChar).map(line => line.trim() ? indentation + line : line).join(this.newlineChar);
+        return splitSqlLines(text, this.newlineChar).map(line => line.trim() ? indentation + line : line).join(this.newlineChar);
     }
     parens(content) {
         return `(${content})`;

package/esm/index.js

@@ -2,14 +2,108 @@
  * Deparser for PostgreSQL version 13
  * Auto-generated by generate-version-deparsers.ts
  */
-import { deparse as deparse17, deparseSync as deparseSync17 } from './deparser';
-import { PG13ToPG17Transformer } from './v13-to-v17-direct';
-const tx = new PG13ToPG17Transformer();
+import { Deparser as Deparser18 } from './deparser';
+import { PG13ToPG18Transformer } from './v13-to-v18-direct';
+const tx = new 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);
+export class Deparser extends Deparser18 {
+    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`);
+    }
+}
 export async function deparse(query, opts) {
-    const ast17 = tx.transform(query);
-    return await deparse17(ast17, opts);
+    return Deparser.deparse(query, opts);
 }
 export function deparseSync(query, opts) {
-    const ast17 = tx.transform(query);
-    return deparseSync17(ast17, opts);
+    return Deparser.deparse(query, opts);
 }
+export { splitSqlLines } from './deparser/utils/sql-formatter';
+export { QuoteUtils } from '@pgsql/quotes';

package/esm/v13-to-v14.js

@@ -1016,10 +1016,13 @@ export 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);
@@ -1027,6 +1030,9 @@ export 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 {
@@ -1637,6 +1643,25 @@ export 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) {
@@ -1838,6 +1863,9 @@ export 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;
@@ -1894,7 +1922,7 @@ export 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') {
@@ -1969,7 +1997,7 @@ export 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
@@ -2004,31 +2032,31 @@ export 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;
     }
@@ -2087,11 +2115,11 @@ export 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;
@@ -2330,6 +2358,14 @@ export 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) {
@@ -2745,6 +2781,17 @@ export 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/esm/v13-to-v18-direct.js

@@ -0,0 +1,88 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-direct-transformer-types.ts
+ */
+import { V13ToV14Transformer } from "./v13-to-v14";
+import { V14ToV15Transformer } from "./v14-to-v15";
+import { V15ToV16Transformer } from "./v15-to-v16";
+import { V16ToV17Transformer } from "./v16-to-v17";
+import { V17ToV18Transformer } from "./v17-to-v18";
+/**
+ * Direct transformer from PG13 to PG18
+ * This transformer chains v13->...->v18 transformations
+ */
+export class PG13ToPG18Transformer {
+    v13to14 = new V13ToV14Transformer();
+    v14to15 = new V14ToV15Transformer();
+    v15to16 = new V15ToV16Transformer();
+    v16to17 = new V16ToV17Transformer();
+    v17to18 = new V17ToV18Transformer();
+    transform(node) {
+        if (this.isParseResult(node)) {
+            // Transform through the chain: v13->v14->v15->v16->v17->v18
+            const v14Stmts = node.stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const stmt = this.v13to14.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt };
+                }
+                return stmtWrapper;
+            });
+            const v15Stmts = v14Stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const stmt = this.v14to15.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt };
+                }
+                return stmtWrapper;
+            });
+            const v16Stmts = v15Stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const stmt = this.v15to16.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt };
+                }
+                return stmtWrapper;
+            });
+            const v17Stmts = v16Stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const stmt = this.v16to17.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt };
+                }
+                return stmtWrapper;
+            });
+            const v18Stmts = v17Stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const stmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt };
+                }
+                return stmtWrapper;
+            });
+            return {
+                ...node,
+                version: 180004, // PG18 version
+                stmts: v18Stmts
+            };
+        }
+        // Otherwise, transform as a regular node through the chain
+        const v14Node = this.v13to14.transform(node, { parentNodeTypes: [] });
+        const v15Node = this.v14to15.transform(v14Node, { parentNodeTypes: [] });
+        const v16Node = this.v15to16.transform(v15Node, { parentNodeTypes: [] });
+        const v17Node = this.v16to17.transform(v16Node, { parentNodeTypes: [] });
+        return this.v17to18.transform(v17Node, { parentNodeTypes: [] });
+    }
+    /**
+     * Transform a single statement from PG13 to PG18
+     * @deprecated Use transform() instead, which handles all node types
+     */
+    transformStatement(stmt) {
+        const v14Stmt = this.v13to14.transform(stmt, { parentNodeTypes: [] });
+        const v15Stmt = this.v14to15.transform(v14Stmt, { parentNodeTypes: [] });
+        const v16Stmt = this.v15to16.transform(v15Stmt, { parentNodeTypes: [] });
+        const v17Stmt = this.v16to17.transform(v16Stmt, { parentNodeTypes: [] });
+        return this.v17to18.transform(v17Stmt, { parentNodeTypes: [] });
+    }
+    /**
+     * Type guard to check if a node is a ParseResult
+     */
+    isParseResult(node) {
+        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
+    }
+}

package/esm/v14-to-v15.js

@@ -828,8 +828,21 @@ export class V14ToV15Transformer {
         const result = this.transformGenericNode(node, context);
         return { StatsElem: result };
     }
+    // PG15 replaced the publication's list of tables with a list of PublicationObjSpec
+    publicationTablesToObjects(result) {
+        if (result.tables === undefined)
+            return;
+        result.pubobjects = (Array.isArray(result.tables) ? result.tables : [result.tables]).map((table) => ({
+            PublicationObjSpec: {
+                pubobjtype: 'PUBLICATIONOBJ_TABLE',
+                pubtable: { relation: table.RangeVar ?? table }
+            }
+        }));
+        delete result.tables;
+    }
     CreatePublicationStmt(node, context) {
         const result = this.transformGenericNode(node, context);
+        this.publicationTablesToObjects(result);
         return { CreatePublicationStmt: result };
     }
     CreateSubscriptionStmt(node, context) {
@@ -838,10 +851,31 @@ export class V14ToV15Transformer {
     }
     AlterPublicationStmt(node, context) {
         const result = this.transformGenericNode(node, context);
+        this.publicationTablesToObjects(result);
+        if (result.tableAction !== undefined) {
+            const actions = {
+                DEFELEM_ADD: 'AP_AddObjects',
+                DEFELEM_DROP: 'AP_DropObjects',
+                DEFELEM_SET: 'AP_SetObjects'
+            };
+            if (actions[result.tableAction]) {
+                result.action = actions[result.tableAction];
+            }
+            delete result.tableAction;
+        }
         return { AlterPublicationStmt: result };
     }
     AlterSubscriptionStmt(node, context) {
         const result = this.transformGenericNode(node, context);
+        // ENABLE / DISABLE carried an Integer before PG15 introduced the Boolean node
+        if (result.kind === 'ALTER_SUBSCRIPTION_ENABLED' && Array.isArray(result.options)) {
+            result.options = result.options.map((option) => {
+                const ival = option?.DefElem?.arg?.Integer;
+                if (option?.DefElem?.defname !== 'enabled' || !ival)
+                    return option;
+                return { DefElem: { ...option.DefElem, arg: { Boolean: { boolval: ival.ival === 1 } } } };
+            });
+        }
         return { AlterSubscriptionStmt: result };
     }
     DropSubscriptionStmt(node, context) {

package/esm/v15-to-v16.js

@@ -790,9 +790,9 @@ export class V15ToV16Transformer {
             const partspec = { ...node.partspec };
             if (partspec.strategy !== undefined) {
                 const strategyMap = {
-                    'range': 'PARTITION_STRATEGY_RANGE',
-                    'list': 'PARTITION_STRATEGY_LIST',
-                    'hash': 'PARTITION_STRATEGY_HASH'
+                    range: 'PARTITION_STRATEGY_RANGE',
+                    list: 'PARTITION_STRATEGY_LIST',
+                    hash: 'PARTITION_STRATEGY_HASH'
                 };
                 partspec.strategy = strategyMap[partspec.strategy] || partspec.strategy;
             }
@@ -854,6 +854,9 @@ export class V15ToV16Transformer {
         if (node.storage !== undefined) {
             result.storage = node.storage;
         }
+        if (node.compression !== undefined) {
+            result.compression = node.compression;
+        }
         if (node.raw_default !== undefined) {
             result.raw_default = this.transform(node.raw_default, context);
         }
@@ -976,6 +979,11 @@ export class V15ToV16Transformer {
         if (node.fk_del_action !== undefined) {
             result.fk_del_action = node.fk_del_action;
         }
+        if (node.fk_del_set_cols !== undefined) {
+            result.fk_del_set_cols = Array.isArray(node.fk_del_set_cols)
+                ? node.fk_del_set_cols.map((item) => this.transform(item, context))
+                : this.transform(node.fk_del_set_cols, context);
+        }
         if (node.old_conpfeqop !== undefined) {
             result.old_conpfeqop = Array.isArray(node.old_conpfeqop)
                 ? node.old_conpfeqop.map((item) => this.transform(item, context))
@@ -2551,13 +2559,13 @@ export class V15ToV16Transformer {
             result.opt = [
                 {
                     DefElem: {
-                        defname: "admin",
+                        defname: 'admin',
                         arg: {
                             Boolean: {
                                 boolval: true
                             }
                         },
-                        defaction: "DEFELEM_UNSPEC"
+                        defaction: 'DEFELEM_UNSPEC'
                     }
                 }
             ];
@@ -2568,6 +2576,9 @@ export class V15ToV16Transformer {
                 ? nodeAny.opt.map((item) => this.transform(item, context))
                 : this.transform(nodeAny.opt, context);
         }
+        if (node.grantor !== undefined) {
+            result.grantor = node.grantor;
+        }
         return { GrantRoleStmt: result };
     }
     SecLabelStmt(node, context) {