pgsql-deparser 13.19.0 → 13.20.0

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;
+}

package/v13-to-v18-direct.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-direct-transformer-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG13ToPG18Transformer = void 0;
+const v13_to_v14_1 = require("./v13-to-v14");
+const v14_to_v15_1 = require("./v14-to-v15");
+const v15_to_v16_1 = require("./v15-to-v16");
+const v16_to_v17_1 = require("./v16-to-v17");
+const v17_to_v18_1 = require("./v17-to-v18");
+/**
+ * Direct transformer from PG13 to PG18
+ * This transformer chains v13->...->v18 transformations
+ */
+class PG13ToPG18Transformer {
+    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();
+    v17to18 = new v17_to_v18_1.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;
+    }
+}
+exports.PG13ToPG18Transformer = PG13ToPG18Transformer;

package/v14-to-v15.d.ts

@@ -342,6 +342,7 @@ export declare class V14ToV15Transformer {
     StatsElem(node: any, context: any): {
         StatsElem: any;
     };
+    private publicationTablesToObjects;
     CreatePublicationStmt(node: any, context: any): {
         CreatePublicationStmt: any;
     };

package/v14-to-v15.js

@@ -831,8 +831,21 @@ 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) {
@@ -841,10 +854,31 @@ 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/v15-to-v16.js

@@ -793,9 +793,9 @@ 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;
             }
@@ -857,6 +857,9 @@ 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);
         }
@@ -979,6 +982,11 @@ 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))
@@ -2554,13 +2562,13 @@ class V15ToV16Transformer {
             result.opt = [
                 {
                     DefElem: {
-                        defname: "admin",
+                        defname: 'admin',
                         arg: {
                             Boolean: {
                                 boolval: true
                             }
                         },
-                        defaction: "DEFELEM_UNSPEC"
+                        defaction: 'DEFELEM_UNSPEC'
                     }
                 }
             ];
@@ -2571,6 +2579,9 @@ 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) {

package/v16-to-v17.d.ts

@@ -496,6 +496,9 @@ export declare class V16ToV17Transformer {
     MergeStmt(node: any, context: any): {
         MergeStmt: any;
     };
+    MergeWhenClause(node: any, context: any): {
+        MergeWhenClause: any;
+    };
     AlterTableMoveAllStmt(node: any, context: any): {
         AlterTableMoveAllStmt: any;
     };

package/v16-to-v17.js

@@ -655,6 +655,12 @@ 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);
         }
@@ -1113,7 +1119,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/v17-to-v18.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-transformer-types.ts
+ */
+/**
+ * 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: any, context?: any): any;
+    visit(node: any, context?: any): any;
+    /**
+     * Generic recursive walk that re-dispatches wrapped nodes with a
+     * dedicated transformer method and deep-copies everything else.
+     */
+    private walkValue;
+    getNodeType(node: any): any;
+    getNodeData(node: any): any;
+    ParseResult(node: any, context: any): any;
+    RawStmt(node: any, context: any): {
+        RawStmt: any;
+    };
+    /**
+     * Convert a v17 returningList into a v18 ReturningClause
+     */
+    private transformReturningList;
+    private transformDmlStatement;
+    InsertStmt(node: any, context: any): {
+        InsertStmt: any;
+    };
+    UpdateStmt(node: any, context: any): {
+        UpdateStmt: any;
+    };
+    DeleteStmt(node: any, context: any): {
+        DeleteStmt: any;
+    };
+    MergeStmt(node: any, context: any): {
+        MergeStmt: any;
+    };
+    AlterTableCmd(node: any, context: any): {
+        AlterTableCmd: any;
+    };
+    VariableSetStmt(node: any, context: any): {
+        VariableSetStmt: any;
+    };
+    Constraint(node: any, context: any): {
+        Constraint: any;
+    };
+}

package/v17-to-v18.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-transformer-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V17ToV18Transformer = void 0;
+// @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
+ */
+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;