@pgsql/transform 17.6.2 → 17.7.0

package/multi-version-transformer.d.ts

@@ -0,0 +1,9 @@
+export declare class ASTTransformer {
+    private transformers;
+    transform(ast: any, fromVersion: number, toVersion: number): any;
+    transformToLatest(ast: any, fromVersion: number): any;
+    transform13To17(ast: any): any;
+    transform14To17(ast: any): any;
+    transform15To17(ast: any): any;
+    transform16To17(ast: any): any;
+}

package/multi-version-transformer.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTTransformer = void 0;
+const v13_to_v14_1 = require("./transformers/v13-to-v14");
+const v14_to_v15_1 = require("./transformers/v14-to-v15");
+const v15_to_v16_1 = require("./transformers/v15-to-v16");
+const v16_to_v17_1 = require("./transformers/v16-to-v17");
+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(),
+    };
+    transform(ast, fromVersion, toVersion) {
+        if (fromVersion === toVersion) {
+            return ast;
+        }
+        if (fromVersion > toVersion) {
+            throw new Error(`Cannot transform backwards from v${fromVersion} to v${toVersion}`);
+        }
+        let currentAst = ast;
+        let currentVersion = fromVersion;
+        while (currentVersion < toVersion) {
+            const nextVersion = currentVersion + 1;
+            const transformerKey = `${currentVersion}-${nextVersion}`;
+            // Use explicit switch to avoid complex union types
+            switch (transformerKey) {
+                case '13-14':
+                    currentAst = this.transformers['13-14'].transform(currentAst, { parentNodeTypes: [] });
+                    break;
+                case '14-15':
+                    currentAst = this.transformers['14-15'].transform(currentAst, { parentNodeTypes: [] });
+                    break;
+                case '15-16':
+                    currentAst = this.transformers['15-16'].transform(currentAst, { parentNodeTypes: [] });
+                    break;
+                case '16-17':
+                    currentAst = this.transformers['16-17'].transform(currentAst, { parentNodeTypes: [] });
+                    break;
+                default:
+                    throw new Error(`No transformer available for v${currentVersion} to v${nextVersion}`);
+            }
+            currentVersion = nextVersion;
+        }
+        return currentAst;
+    }
+    transformToLatest(ast, fromVersion) {
+        return this.transform(ast, fromVersion, 17);
+    }
+    transform13To17(ast) {
+        return this.transform(ast, 13, 17);
+    }
+    transform14To17(ast) {
+        return this.transform(ast, 14, 17);
+    }
+    transform15To17(ast) {
+        return this.transform(ast, 15, 17);
+    }
+    transform16To17(ast) {
+        return this.transform(ast, 16, 17);
+    }
+}
+exports.ASTTransformer = ASTTransformer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgsql/transform",
-  "version": "17.6.2",
+  "version": "17.7.0",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "Transform PostgreSQL AST types for pgsql-parser",
   "main": "index.js",
@@ -28,11 +28,15 @@
     "build:proto": "ts-node scripts/pg-proto-parser",
     "lint": "eslint . --fix",
     "test": "jest",
-    "test:watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "kitchen-sink": "ts-node scripts/make-kitchen-sink.ts",
+    "test:ast": "ts-node scripts/test-ast.ts"
   },
   "devDependencies": {
-    "pg-proto-parser": "^1.29.1"
+    "@pgsql/parser": "^1.1.4",
+    "pg-proto-parser": "^1.29.1",
+    "pgsql-deparser": "^17.8.4"
   },
   "keywords": [],
-  "gitHead": "bf2e281d50cb6bc05511ab1a6b6390fb5c2cbcff"
+  "gitHead": "db3e424332bcb223c34a1caca3f37fb6fc9a1964"
 }

package/transformers/context.d.ts

@@ -0,0 +1,4 @@
+export interface TransformerContext {
+    parentNodeTypes: string[];
+    [key: string]: any;
+}

package/transformers/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,252 @@
+import * as PG13 from '../13/types';
+import * as PG14 from '../14/types';
+import { TransformerContext } from './context';
+export declare class V13ToV14Transformer {
+    transform(node: PG13.Node, context?: TransformerContext): any;
+    visit(node: PG13.Node, context?: TransformerContext): any;
+    private transformGenericNode;
+    getNodeType(node: PG13.Node): any;
+    getNodeData(node: PG13.Node): any;
+    ParseResult(node: PG13.ParseResult, context: TransformerContext): PG14.ParseResult;
+    FuncCall(node: PG13.FuncCall, context: TransformerContext): {
+        FuncCall: PG14.FuncCall;
+    };
+    private shouldAddFuncformat;
+    private isInCheckConstraintContext;
+    private isInCommentContext;
+    private isInTypeCastContext;
+    private isInInsertContext;
+    private isInUpdateContext;
+    private isInXmlExprContext;
+    private isInRangeFunctionContext;
+    private isInSortByContext;
+    private isInDefaultConstraintContext;
+    private isInPolicyContext;
+    private isInSelectFromContext;
+    private isInSelectTargetContext;
+    private isInReturningContext;
+    private isInCreateIndexContext;
+    private isInConstraintContext;
+    private isInCreateDomainContext;
+    private isInCreateProcedureContext;
+    private isInCallStmtContext;
+    private isStandardFunctionCallSyntax;
+    private isSqlStandardSyntax;
+    CallStmt(node: PG13.CallStmt, context: TransformerContext): {
+        CallStmt: PG14.CallStmt;
+    };
+    CommentStmt(node: PG13.CommentStmt, context: TransformerContext): {
+        CommentStmt: PG14.CommentStmt;
+    };
+    DropStmt(node: PG13.DropStmt, context: TransformerContext): {
+        DropStmt: PG14.DropStmt;
+    };
+    InsertStmt(node: PG13.InsertStmt, context: TransformerContext): {
+        InsertStmt: PG14.InsertStmt;
+    };
+    UpdateStmt(node: PG13.UpdateStmt, context: TransformerContext): {
+        UpdateStmt: PG14.UpdateStmt;
+    };
+    DeleteStmt(node: PG13.DeleteStmt, context: TransformerContext): {
+        DeleteStmt: PG14.DeleteStmt;
+    };
+    CreateOpClassStmt(node: PG13.CreateOpClassStmt, context: TransformerContext): {
+        CreateOpClassStmt: PG14.CreateOpClassStmt;
+    };
+    CreateOpClassItem(node: PG13.CreateOpClassItem, context: TransformerContext): {
+        CreateOpClassItem: PG14.CreateOpClassItem;
+    };
+    CreateAccessMethodStmt(node: any, context: TransformerContext): any;
+    GrantStmt(node: PG13.GrantStmt, context: TransformerContext): {
+        GrantStmt: PG14.GrantStmt;
+    };
+    RevokeStmt(node: any, context: TransformerContext): any;
+    ResTarget(node: PG13.ResTarget, context: TransformerContext): {
+        ResTarget: PG14.ResTarget;
+    };
+    private getFunctionName;
+    private isOperatorName;
+    private getFuncformatValue;
+    private getFunctionNameFromContext;
+    private functionHasExplicitModes;
+    private allParametersHaveExplicitModes;
+    private hasOnlyExplicitInParameters;
+    private hasExplicitInParameters;
+    private isVariadicParameterType;
+    FunctionParameter(node: PG13.FunctionParameter, context: TransformerContext): {
+        FunctionParameter: PG14.FunctionParameter;
+    };
+    AlterFunctionStmt(node: PG13.AlterFunctionStmt, context: TransformerContext): {
+        AlterFunctionStmt: PG14.AlterFunctionStmt;
+    };
+    AlterOwnerStmt(node: PG13.AlterOwnerStmt, context: TransformerContext): {
+        AlterOwnerStmt: PG14.AlterOwnerStmt;
+    };
+    AlterTableStmt(node: PG13.AlterTableStmt, context: TransformerContext): {
+        AlterTableStmt: PG14.AlterTableStmt;
+    };
+    CreateTableAsStmt(node: PG13.CreateTableAsStmt, context: TransformerContext): {
+        CreateTableAsStmt: PG14.CreateTableAsStmt;
+    };
+    RawStmt(node: PG13.RawStmt, context: TransformerContext): {
+        RawStmt: PG14.RawStmt;
+    };
+    SelectStmt(node: PG13.SelectStmt, context: TransformerContext): {
+        SelectStmt: PG14.SelectStmt;
+    };
+    RangeSubselect(node: PG13.RangeSubselect, context: TransformerContext): {
+        RangeSubselect: PG14.RangeSubselect;
+    };
+    CommonTableExpr(node: PG13.CommonTableExpr, context: TransformerContext): {
+        CommonTableExpr: PG14.CommonTableExpr;
+    };
+    SubLink(node: PG13.SubLink, context: TransformerContext): {
+        SubLink: PG14.SubLink;
+    };
+    CopyStmt(node: PG13.CopyStmt, context: TransformerContext): {
+        CopyStmt: PG14.CopyStmt;
+    };
+    CreateEnumStmt(node: PG13.CreateEnumStmt, context: TransformerContext): {
+        CreateEnumStmt: PG14.CreateEnumStmt;
+    };
+    DefineStmt(node: PG13.DefineStmt, context: TransformerContext): {
+        DefineStmt: PG14.DefineStmt;
+    };
+    DoStmt(node: PG13.DoStmt, context: TransformerContext): {
+        DoStmt: PG14.DoStmt;
+    };
+    DeclareCursorStmt(node: PG13.DeclareCursorStmt, context: TransformerContext): {
+        DeclareCursorStmt: PG14.DeclareCursorStmt;
+    };
+    VacuumStmt(node: PG13.VacuumStmt, context: TransformerContext): {
+        VacuumStmt: PG14.VacuumStmt;
+    };
+    VacuumRelation(node: PG13.VacuumRelation, context: TransformerContext): {
+        VacuumRelation: PG14.VacuumRelation;
+    };
+    RangeVar(node: PG13.RangeVar, context: TransformerContext): {
+        RangeVar: PG14.RangeVar;
+    };
+    IntoClause(node: PG13.IntoClause, context: TransformerContext): {
+        IntoClause: PG14.IntoClause;
+    };
+    CreateCastStmt(node: PG13.CreateCastStmt, context: TransformerContext): {
+        CreateCastStmt: PG14.CreateCastStmt;
+    };
+    CreateTransformStmt(node: PG13.CreateTransformStmt, context: TransformerContext): {
+        CreateTransformStmt: PG14.CreateTransformStmt;
+    };
+    CreateFunctionStmt(node: PG13.CreateFunctionStmt, context: TransformerContext): {
+        CreateFunctionStmt: PG14.CreateFunctionStmt;
+    };
+    TableLikeClause(node: PG13.TableLikeClause, context: TransformerContext): {
+        TableLikeClause: PG14.TableLikeClause;
+    };
+    private transformTableLikeOption;
+    private extractParameterNameFromFunctionName;
+    ObjectWithArgs(node: PG13.ObjectWithArgs, context: TransformerContext): {
+        ObjectWithArgs: PG14.ObjectWithArgs;
+    };
+    private shouldCreateObjfuncargs;
+    private shouldPreserveObjfuncargs;
+    private shouldCreateObjfuncargsFromObjargs;
+    private shouldAddObjfuncargsForDropStmt;
+    private shouldPreserveObjnameAsObject;
+    private createFunctionParameterFromTypeName;
+    private isVariadicAggregateContext;
+    private transformA_Expr_Kind;
+    private transformRoleSpecType;
+    private isVariadicParameterContext;
+    private isCreateFunctionContext;
+    String(node: PG13.String, context: TransformerContext): {
+        String: PG14.String;
+    };
+    BitString(node: PG13.BitString, context: TransformerContext): {
+        BitString: PG14.BitString;
+    };
+    Float(node: PG13.Float, context: TransformerContext): {
+        Float: PG14.Float;
+    };
+    Integer(node: PG13.Integer, context: TransformerContext): {
+        Integer: PG14.Integer;
+    };
+    Null(node: PG13.Null, context: TransformerContext): {
+        Null: PG14.Null;
+    };
+    List(node: any, context: TransformerContext): {
+        List: PG14.List;
+    };
+    A_Expr(node: any, context: TransformerContext): {
+        A_Expr: PG14.A_Expr;
+    };
+    RoleSpec(node: any, context: TransformerContext): {
+        RoleSpec: PG14.RoleSpec;
+    };
+    AlterTableCmd(node: any, context: TransformerContext): {
+        AlterTableCmd: PG14.AlterTableCmd;
+    };
+    TypeName(node: any, context: TransformerContext): {
+        TypeName: PG14.TypeName;
+    };
+    ColumnRef(node: any, context: TransformerContext): {
+        ColumnRef: PG14.ColumnRef;
+    };
+    A_Const(node: any, context: TransformerContext): {
+        A_Const: PG14.A_Const;
+    };
+    A_Star(node: any, context: TransformerContext): {
+        A_Star: PG14.A_Star;
+    };
+    SortBy(node: any, context: TransformerContext): {
+        SortBy: PG14.SortBy;
+    };
+    CreateDomainStmt(node: any, context: TransformerContext): {
+        CreateDomainStmt: PG14.CreateDomainStmt;
+    };
+    CreateSeqStmt(node: any, context: TransformerContext): {
+        CreateSeqStmt: PG14.CreateSeqStmt;
+    };
+    WithClause(node: PG13.WithClause, context: TransformerContext): {
+        WithClause: PG14.WithClause;
+    };
+    private shouldConvertCTEsToArray;
+    AlterSeqStmt(node: any, context: TransformerContext): {
+        AlterSeqStmt: PG14.AlterSeqStmt;
+    };
+    CTECycleClause(node: any, context: TransformerContext): {
+        CTECycleClause: PG14.CTECycleClause;
+    };
+    CTESearchClause(node: any, context: TransformerContext): {
+        CTESearchClause: PG14.CTESearchClause;
+    };
+    PLAssignStmt(node: any, context: TransformerContext): {
+        PLAssignStmt: PG14.PLAssignStmt;
+    };
+    ReturnStmt(node: any, context: TransformerContext): {
+        ReturnStmt: PG14.ReturnStmt;
+    };
+    StatsElem(node: any, context: TransformerContext): {
+        StatsElem: PG14.StatsElem;
+    };
+    CreateStatsStmt(node: any, context: TransformerContext): {
+        CreateStatsStmt: PG14.CreateStatsStmt;
+    };
+    CreateStmt(node: any, context: TransformerContext): {
+        CreateStmt: PG14.CreateStmt;
+    };
+    CreatePolicyStmt(node: any, context: TransformerContext): {
+        CreatePolicyStmt: PG14.CreatePolicyStmt;
+    };
+    RenameStmt(node: any, context: TransformerContext): {
+        RenameStmt: PG14.RenameStmt;
+    };
+    AlterObjectSchemaStmt(node: any, context: TransformerContext): {
+        AlterObjectSchemaStmt: PG14.AlterObjectSchemaStmt;
+    };
+    private mapTableLikeOption;
+    private getPG13EnumName;
+    private mapFunctionParameterMode;
+    ReindexStmt(node: PG13.ReindexStmt, context: TransformerContext): {
+        ReindexStmt: PG14.ReindexStmt;
+    };
+}