@pgsql/transform 18.1.1 → 18.3.1

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

@@ -1,51 +0,0 @@
-import { V16ToV17Transformer } from '../../transformers/v16-to-v17';
-import { V17ToV18Transformer } from '../../transformers/v17-to-v18';
-/**
- * Direct transformer from PG16 to PG18
- * This transformer chains v16->...->v18 transformations
- */
-export class PG16ToPG18Transformer {
-    v16to17 = new V16ToV17Transformer();
-    v17to18 = new V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            // Transform through the chain: v16->v17->v18
-            const v17Stmts = node.stmts.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 v17Node = this.v16to17.transform(node, { parentNodeTypes: [] });
-        return this.v17to18.transform(v17Node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG16 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        const v17Stmt = this.v16to17.transform(stmt, { 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/transformers-direct/v17-to-v18/index.js

@@ -1,39 +0,0 @@
-import { V17ToV18Transformer } from '../../transformers/v17-to-v18';
-/**
- * Direct transformer from PG17 to PG18
- * This transformer chains v17->...->v18 transformations
- */
-export class PG17ToPG18Transformer {
-    v17to18 = new V17ToV18Transformer();
-    transform(node) {
-        if (this.isParseResult(node)) {
-            const transformedStmts = node.stmts.map((stmtWrapper) => {
-                if (stmtWrapper.stmt) {
-                    const transformedStmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
-                    return { ...stmtWrapper, stmt: transformedStmt };
-                }
-                return stmtWrapper;
-            });
-            return {
-                ...node,
-                version: 180004, // PG18 version
-                stmts: transformedStmts
-            };
-        }
-        // Otherwise, transform as a regular node
-        return this.v17to18.transform(node, { parentNodeTypes: [] });
-    }
-    /**
-     * Transform a single statement from PG17 to PG18
-     * @deprecated Use transform() instead, which handles all node types
-     */
-    transformStatement(stmt) {
-        return this.v17to18.transform(stmt, { parentNodeTypes: [] });
-    }
-    /**
-     * Type guard to check if a node is a ParseResult
-     */
-    isParseResult(node) {
-        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
-    }
-}

package/multi-version-transformer.d.ts

@@ -1,14 +0,0 @@
-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;
-    transform13To18(ast: any): any;
-    transform14To18(ast: any): any;
-    transform15To18(ast: any): any;
-    transform16To18(ast: any): any;
-    transform17To18(ast: any): any;
-}

package/multi-version-transformer.js

@@ -1,84 +0,0 @@
-"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");
-const v17_to_v18_1 = require("./transformers/v17-to-v18");
-class ASTTransformer {
-    transformers = {
-        '13-14': new v13_to_v14_1.V13ToV14Transformer(),
-        '14-15': new v14_to_v15_1.V14ToV15Transformer(),
-        '15-16': new v15_to_v16_1.V15ToV16Transformer(),
-        '16-17': new v16_to_v17_1.V16ToV17Transformer(),
-        '17-18': new v17_to_v18_1.V17ToV18Transformer(),
-    };
-    transform(ast, fromVersion, toVersion) {
-        if (fromVersion === toVersion) {
-            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;
-                case '17-18':
-                    currentAst = this.transformers['17-18'].transform(currentAst, { parentNodeTypes: [] });
-                    break;
-                default:
-                    throw new Error(`No transformer available for v${currentVersion} to v${nextVersion}`);
-            }
-            currentVersion = nextVersion;
-        }
-        return currentAst;
-    }
-    transformToLatest(ast, fromVersion) {
-        return this.transform(ast, fromVersion, 18);
-    }
-    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);
-    }
-    transform13To18(ast) {
-        return this.transform(ast, 13, 18);
-    }
-    transform14To18(ast) {
-        return this.transform(ast, 14, 18);
-    }
-    transform15To18(ast) {
-        return this.transform(ast, 15, 18);
-    }
-    transform16To18(ast) {
-        return this.transform(ast, 16, 18);
-    }
-    transform17To18(ast) {
-        return this.transform(ast, 17, 18);
-    }
-}
-exports.ASTTransformer = ASTTransformer;

package/transformers/context.d.ts

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

package/transformers/context.js

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

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

@@ -1,255 +0,0 @@
-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;
-    AlterExtensionContentsStmt(node: PG13.AlterExtensionContentsStmt, context: TransformerContext): {
-        AlterExtensionContentsStmt: PG14.AlterExtensionContentsStmt;
-    };
-    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;
-    };
-}