pgsql-deparser 17.8.2 → 17.8.4

package/esm/visitors/base.js

@@ -1,3 +1,90 @@
+import { SqlFormatter } from '../utils/sql-formatter';
+export class DeparserContext {
+    indentLevel;
+    prettyMode;
+    isStringLiteral;
+    parentNodeTypes;
+    formatter;
+    select;
+    from;
+    group;
+    sort;
+    insertColumns;
+    update;
+    bool;
+    isColumnConstraint;
+    isDomainConstraint;
+    alterColumnOptions;
+    alterTableOptions;
+    isEnumValue;
+    objtype;
+    subtype;
+    constructor({ indentLevel = 0, prettyMode = false, isStringLiteral, parentNodeTypes = [], formatter, select, from, group, sort, insertColumns, update, bool, isColumnConstraint, isDomainConstraint, alterColumnOptions, alterTableOptions, isEnumValue, objtype, subtype, ...rest } = {}) {
+        this.indentLevel = indentLevel;
+        this.prettyMode = prettyMode;
+        this.isStringLiteral = isStringLiteral;
+        this.parentNodeTypes = parentNodeTypes;
+        this.formatter = formatter || new SqlFormatter('\n', '  ', prettyMode);
+        this.select = select;
+        this.from = from;
+        this.group = group;
+        this.sort = sort;
+        this.insertColumns = insertColumns;
+        this.update = update;
+        this.bool = bool;
+        this.isColumnConstraint = isColumnConstraint;
+        this.isDomainConstraint = isDomainConstraint;
+        this.alterColumnOptions = alterColumnOptions;
+        this.alterTableOptions = alterTableOptions;
+        this.isEnumValue = isEnumValue;
+        this.objtype = objtype;
+        this.subtype = subtype;
+        Object.assign(this, rest);
+    }
+    spawn(nodeType, overrides = {}) {
+        return new DeparserContext({
+            indentLevel: this.indentLevel,
+            prettyMode: this.prettyMode,
+            isStringLiteral: this.isStringLiteral,
+            parentNodeTypes: [...this.parentNodeTypes, nodeType],
+            formatter: this.formatter,
+            select: this.select,
+            from: this.from,
+            group: this.group,
+            sort: this.sort,
+            insertColumns: this.insertColumns,
+            update: this.update,
+            bool: this.bool,
+            isColumnConstraint: this.isColumnConstraint,
+            isDomainConstraint: this.isDomainConstraint,
+            alterColumnOptions: this.alterColumnOptions,
+            alterTableOptions: this.alterTableOptions,
+            isEnumValue: this.isEnumValue,
+            objtype: this.objtype,
+            subtype: this.subtype,
+            ...overrides,
+        });
+    }
+    indent(text, count) {
+        if (!this.prettyMode) {
+            return text;
+        }
+        const indentCount = count !== undefined ? count : this.indentLevel + 1;
+        return this.formatter.indent(text, indentCount);
+    }
+    newline() {
+        return this.formatter.newline();
+    }
+    parens(content) {
+        return this.formatter.parens(content);
+    }
+    format(parts, separator) {
+        return this.formatter.format(parts, separator);
+    }
+    isPretty() {
+        return this.formatter.isPretty();
+    }
+}
 export class BaseVisitor {
     getNodeType(node) {
         return Object.keys(node)[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-deparser",
-  "version": "17.8.2",
+  "version": "17.8.4",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostgreSQL AST Deparser",
   "main": "index.js",
@@ -33,7 +33,14 @@
     "fixtures:upstream-diff": "ts-node scripts/make-upstream-diff.ts",
     "lint": "eslint . --fix",
     "test": "jest",
-    "test:watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "strip-transformer-types": "ts-node scripts/strip-transformer-types.ts",
+    "strip-direct-transformer-types": "ts-node scripts/strip-direct-transformer-types.ts",
+    "strip-deparser-types": "ts-node scripts/strip-deparser-types.ts",
+    "organize-transformers": "ts-node scripts/organize-transformers-by-version.ts",
+    "generate-version-deparsers": "ts-node scripts/generate-version-deparsers.ts",
+    "generate-packages": "ts-node scripts/generate-version-packages.ts",
+    "prepare-versions": "npm run strip-transformer-types && npm run strip-direct-transformer-types && npm run strip-deparser-types && npm run organize-transformers && npm run generate-version-deparsers && npm run generate-packages"
   },
   "keywords": [
     "sql",
@@ -46,10 +53,10 @@
     "database"
   ],
   "devDependencies": {
-    "libpg-query": "17.5.3"
+    "libpg-query": "17.5.5"
   },
   "dependencies": {
     "@pgsql/types": "^17.6.1"
   },
-  "gitHead": "309bfda0a8a4335ff29093763ad0f14c8a71ee21"
+  "gitHead": "db3e424332bcb223c34a1caca3f37fb6fc9a1964"
 }

package/visitors/base.d.ts

@@ -1,10 +1,56 @@
 import { Node } from '@pgsql/types';
-export interface DeparserContext {
+import { SqlFormatter } from '../utils/sql-formatter';
+export interface DeparserContextOptions {
     isStringLiteral?: boolean;
-    parentNodeTypes: string[];
+    parentNodeTypes?: string[];
     indentLevel?: number;
+    prettyMode?: boolean;
+    formatter?: SqlFormatter;
+    select?: boolean;
+    from?: boolean;
+    group?: boolean;
+    sort?: boolean;
+    insertColumns?: boolean;
+    update?: boolean;
+    bool?: boolean;
+    isColumnConstraint?: boolean;
+    isDomainConstraint?: boolean;
+    alterColumnOptions?: boolean;
+    alterTableOptions?: boolean;
+    isEnumValue?: boolean;
+    objtype?: string;
+    subtype?: string;
     [key: string]: any;
 }
+export declare class DeparserContext {
+    readonly indentLevel: number;
+    readonly prettyMode: boolean;
+    readonly isStringLiteral?: boolean;
+    readonly parentNodeTypes: string[];
+    private readonly formatter;
+    readonly select?: boolean;
+    readonly from?: boolean;
+    readonly group?: boolean;
+    readonly sort?: boolean;
+    readonly insertColumns?: boolean;
+    readonly update?: boolean;
+    readonly bool?: boolean;
+    readonly isColumnConstraint?: boolean;
+    readonly isDomainConstraint?: boolean;
+    readonly alterColumnOptions?: boolean;
+    readonly alterTableOptions?: boolean;
+    readonly isEnumValue?: boolean;
+    readonly objtype?: string;
+    readonly subtype?: string;
+    readonly [key: string]: any;
+    constructor({ indentLevel, prettyMode, isStringLiteral, parentNodeTypes, formatter, select, from, group, sort, insertColumns, update, bool, isColumnConstraint, isDomainConstraint, alterColumnOptions, alterTableOptions, isEnumValue, objtype, subtype, ...rest }?: DeparserContextOptions);
+    spawn(nodeType: string, overrides?: Partial<DeparserContextOptions>): DeparserContext;
+    indent(text: string, count?: number): string;
+    newline(): string;
+    parens(content: string): string;
+    format(parts: string[], separator?: string): string;
+    isPretty(): boolean;
+}
 export interface DeparserVisitor {
     visit(node: Node, context?: DeparserContext): string;
 }

package/visitors/base.js

@@ -1,6 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseVisitor = void 0;
+exports.BaseVisitor = exports.DeparserContext = void 0;
+const sql_formatter_1 = require("../utils/sql-formatter");
+class DeparserContext {
+    indentLevel;
+    prettyMode;
+    isStringLiteral;
+    parentNodeTypes;
+    formatter;
+    select;
+    from;
+    group;
+    sort;
+    insertColumns;
+    update;
+    bool;
+    isColumnConstraint;
+    isDomainConstraint;
+    alterColumnOptions;
+    alterTableOptions;
+    isEnumValue;
+    objtype;
+    subtype;
+    constructor({ indentLevel = 0, prettyMode = false, isStringLiteral, parentNodeTypes = [], formatter, select, from, group, sort, insertColumns, update, bool, isColumnConstraint, isDomainConstraint, alterColumnOptions, alterTableOptions, isEnumValue, objtype, subtype, ...rest } = {}) {
+        this.indentLevel = indentLevel;
+        this.prettyMode = prettyMode;
+        this.isStringLiteral = isStringLiteral;
+        this.parentNodeTypes = parentNodeTypes;
+        this.formatter = formatter || new sql_formatter_1.SqlFormatter('\n', '  ', prettyMode);
+        this.select = select;
+        this.from = from;
+        this.group = group;
+        this.sort = sort;
+        this.insertColumns = insertColumns;
+        this.update = update;
+        this.bool = bool;
+        this.isColumnConstraint = isColumnConstraint;
+        this.isDomainConstraint = isDomainConstraint;
+        this.alterColumnOptions = alterColumnOptions;
+        this.alterTableOptions = alterTableOptions;
+        this.isEnumValue = isEnumValue;
+        this.objtype = objtype;
+        this.subtype = subtype;
+        Object.assign(this, rest);
+    }
+    spawn(nodeType, overrides = {}) {
+        return new DeparserContext({
+            indentLevel: this.indentLevel,
+            prettyMode: this.prettyMode,
+            isStringLiteral: this.isStringLiteral,
+            parentNodeTypes: [...this.parentNodeTypes, nodeType],
+            formatter: this.formatter,
+            select: this.select,
+            from: this.from,
+            group: this.group,
+            sort: this.sort,
+            insertColumns: this.insertColumns,
+            update: this.update,
+            bool: this.bool,
+            isColumnConstraint: this.isColumnConstraint,
+            isDomainConstraint: this.isDomainConstraint,
+            alterColumnOptions: this.alterColumnOptions,
+            alterTableOptions: this.alterTableOptions,
+            isEnumValue: this.isEnumValue,
+            objtype: this.objtype,
+            subtype: this.subtype,
+            ...overrides,
+        });
+    }
+    indent(text, count) {
+        if (!this.prettyMode) {
+            return text;
+        }
+        const indentCount = count !== undefined ? count : this.indentLevel + 1;
+        return this.formatter.indent(text, indentCount);
+    }
+    newline() {
+        return this.formatter.newline();
+    }
+    parens(content) {
+        return this.formatter.parens(content);
+    }
+    format(parts, separator) {
+        return this.formatter.format(parts, separator);
+    }
+    isPretty() {
+        return this.formatter.isPretty();
+    }
+}
+exports.DeparserContext = DeparserContext;
 class BaseVisitor {
     getNodeType(node) {
         return Object.keys(node)[0];

package/esm/utils/index.js

@@ -1,90 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-export const cleanLines = (sql) => {
-    return sql
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((a) => a)
-        .join('\n');
-};
-export const transform = (obj, props) => {
-    let copy = null;
-    // Handle the 3 simple types, and null or undefined
-    if (obj == null || typeof obj !== 'object') {
-        return obj;
-    }
-    // Handle Date
-    if (obj instanceof Date) {
-        copy = new Date();
-        copy.setTime(obj.getTime());
-        return copy;
-    }
-    // Handle Array
-    if (obj instanceof Array) {
-        copy = [];
-        for (let i = 0, len = obj.length; i < len; i++) {
-            copy[i] = transform(obj[i], props);
-        }
-        return copy;
-    }
-    // Handle Object
-    if (obj instanceof Object || typeof obj === 'object') {
-        copy = {};
-        for (const attr in obj) {
-            if (obj.hasOwnProperty(attr)) {
-                if (props.hasOwnProperty(attr)) {
-                    if (typeof props[attr] === 'function') {
-                        copy[attr] = props[attr](obj[attr]);
-                    }
-                    else if (props[attr].hasOwnProperty(obj[attr])) {
-                        copy[attr] = props[attr][obj[attr]];
-                    }
-                    else {
-                        copy[attr] = transform(obj[attr], props);
-                    }
-                }
-                else {
-                    copy[attr] = transform(obj[attr], props);
-                }
-            }
-            else {
-                copy[attr] = transform(obj[attr], props);
-            }
-        }
-        return copy;
-    }
-    throw new Error("Unable to copy obj! Its type isn't supported.");
-};
-const noop = () => undefined;
-export const cleanTree = (tree) => {
-    return transform(tree, {
-        stmt_len: noop,
-        stmt_location: noop,
-        location: noop,
-        DefElem: (obj) => {
-            if (obj.defname === 'as') {
-                if (Array.isArray(obj.arg) && obj.arg.length) {
-                    // function
-                    obj.arg[0].String.sval = obj.arg[0].String.sval.trim();
-                }
-                else if (obj.arg.List && obj.arg.List.items) {
-                    // function
-                    obj.arg.List.items[0].String.sval = obj.arg.List.items[0].String.sval.trim();
-                }
-                else {
-                    // do stmt
-                    obj.arg.String.sval = obj.arg.String.sval.trim();
-                }
-                return cleanTree(obj);
-            }
-            else {
-                return cleanTree(obj);
-            }
-        }
-    });
-};
-export const cleanTreeWithStmt = (tree) => {
-    return transform(tree, {
-        stmt_location: noop,
-        location: noop
-    });
-};

package/esm/utils/statement-splitter.js

@@ -1,125 +0,0 @@
-import { parse } from 'libpg-query';
-/**
- * Extracts a single statement from SQL using PostgreSQL's location information.
- * Handles Unicode properly by using byte positions instead of character positions.
- */
-export function extractStatement(originalSQL, rawStmt, isFirst = false, options = {}) {
-    let extracted = null;
-    // Convert string to buffer to handle byte positions correctly (for Unicode)
-    const sqlBuffer = Buffer.from(originalSQL, 'utf8');
-    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
-        // Use byte positions as provided by PostgreSQL
-        const startByte = rawStmt.stmt_location;
-        const endByte = rawStmt.stmt_location + rawStmt.stmt_len;
-        // Extract using byte positions and convert back to string
-        const extractedBuffer = sqlBuffer.slice(startByte, endByte);
-        extracted = extractedBuffer.toString('utf8');
-    }
-    else if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len === undefined) {
-        // We have location but no length - extract from location to end of file
-        const extractedBuffer = sqlBuffer.slice(rawStmt.stmt_location);
-        extracted = extractedBuffer.toString('utf8');
-    }
-    else if (isFirst && rawStmt.stmt_len !== undefined) {
-        // For first statement when location is missing but we have length
-        const extractedBuffer = sqlBuffer.slice(0, rawStmt.stmt_len);
-        extracted = extractedBuffer.toString('utf8');
-    }
-    else if (isFirst && rawStmt.stmt_location === undefined && rawStmt.stmt_len === undefined) {
-        // For first statement when both location and length are missing, use entire SQL
-        extracted = originalSQL;
-    }
-    if (extracted && options.stripComments !== false) {
-        // Split into lines to handle leading whitespace and comments properly
-        const lines = extracted.split('\n');
-        let startLineIndex = 0;
-        // Find the first line that contains actual SQL content
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            // Skip empty lines and comment-only lines
-            if (line === '' || line.startsWith('--')) {
-                continue;
-            }
-            startLineIndex = i;
-            break;
-        }
-        // Reconstruct from the first SQL line, preserving the original indentation of that line
-        if (startLineIndex < lines.length) {
-            const resultLines = lines.slice(startLineIndex);
-            extracted = resultLines.join('\n').trim();
-        }
-    }
-    // Final validation unless skipped
-    if (extracted && !options.skipValidation) {
-        const firstLine = extracted.split('\n')[0].trim();
-        const firstWord = firstLine.split(/\s+/)[0].toUpperCase();
-        // Only check for most obvious malformed patterns at the BEGINNING
-        if (
-        // Check if it starts with truncated patterns (not just contains anywhere)
-        extracted.trim().startsWith('ELECT ') || // Missing S from SELECT
-            extracted.trim().startsWith('REATE ') || // Missing C from CREATE  
-            extracted.trim().startsWith('NSERT ') || // Missing I from INSERT
-            // Completely empty or whitespace only
-            extracted.trim().length === 0) {
-            return null; // Invalid extraction, skip this statement
-        }
-    }
-    return extracted;
-}
-/**
- * Splits SQL text into individual statements using PostgreSQL's parser.
- * Handles Unicode characters properly and provides detailed location information.
- */
-export async function splitStatements(sql, options = {}) {
-    const parseResult = await parse(sql);
-    const statements = [];
-    if (!parseResult.stmts) {
-        return statements;
-    }
-    for (let idx = 0; idx < parseResult.stmts.length; idx++) {
-        const stmt = parseResult.stmts[idx];
-        const extracted = extractStatement(sql, stmt, idx === 0, options);
-        if (extracted) {
-            statements.push({
-                statement: extracted,
-                index: idx,
-                location: stmt.stmt_location,
-                length: stmt.stmt_len
-            });
-        }
-    }
-    return statements;
-}
-/**
- * Utility to generate statement keys for fixtures
- */
-export function generateStatementKey(relativePath, statementIndex, extension = 'sql') {
-    return `${relativePath.replace(/\.sql$/, '')}-${statementIndex + 1}.${extension}`;
-}
-/**
- * Test utility to compare byte vs character extraction for debugging Unicode issues
- */
-export function debugUnicodeExtraction(sql, rawStmt) {
-    const charLength = sql.length;
-    const byteLength = Buffer.from(sql, 'utf8').length;
-    // Character-based extraction (old way)
-    let characterBased = '';
-    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
-        characterBased = sql.substring(rawStmt.stmt_location, rawStmt.stmt_location + rawStmt.stmt_len);
-    }
-    // Byte-based extraction (new way)
-    let byteBased = '';
-    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
-        const sqlBuffer = Buffer.from(sql, 'utf8');
-        const extractedBuffer = sqlBuffer.slice(rawStmt.stmt_location, rawStmt.stmt_location + rawStmt.stmt_len);
-        byteBased = extractedBuffer.toString('utf8');
-    }
-    return {
-        characterBased,
-        byteBased,
-        matches: characterBased === byteBased,
-        unicodeChars: byteLength - charLength,
-        byteLength,
-        charLength
-    };
-}

package/utils/index.d.ts

@@ -1,4 +0,0 @@
-export declare const cleanLines: (sql: string) => string;
-export declare const transform: (obj: any, props: any) => any;
-export declare const cleanTree: (tree: any) => any;
-export declare const cleanTreeWithStmt: (tree: any) => any;

package/utils/index.js

@@ -1,97 +0,0 @@
-"use strict";
-/* eslint-disable no-restricted-syntax */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanTreeWithStmt = exports.cleanTree = exports.transform = exports.cleanLines = void 0;
-const cleanLines = (sql) => {
-    return sql
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((a) => a)
-        .join('\n');
-};
-exports.cleanLines = cleanLines;
-const transform = (obj, props) => {
-    let copy = null;
-    // Handle the 3 simple types, and null or undefined
-    if (obj == null || typeof obj !== 'object') {
-        return obj;
-    }
-    // Handle Date
-    if (obj instanceof Date) {
-        copy = new Date();
-        copy.setTime(obj.getTime());
-        return copy;
-    }
-    // Handle Array
-    if (obj instanceof Array) {
-        copy = [];
-        for (let i = 0, len = obj.length; i < len; i++) {
-            copy[i] = (0, exports.transform)(obj[i], props);
-        }
-        return copy;
-    }
-    // Handle Object
-    if (obj instanceof Object || typeof obj === 'object') {
-        copy = {};
-        for (const attr in obj) {
-            if (obj.hasOwnProperty(attr)) {
-                if (props.hasOwnProperty(attr)) {
-                    if (typeof props[attr] === 'function') {
-                        copy[attr] = props[attr](obj[attr]);
-                    }
-                    else if (props[attr].hasOwnProperty(obj[attr])) {
-                        copy[attr] = props[attr][obj[attr]];
-                    }
-                    else {
-                        copy[attr] = (0, exports.transform)(obj[attr], props);
-                    }
-                }
-                else {
-                    copy[attr] = (0, exports.transform)(obj[attr], props);
-                }
-            }
-            else {
-                copy[attr] = (0, exports.transform)(obj[attr], props);
-            }
-        }
-        return copy;
-    }
-    throw new Error("Unable to copy obj! Its type isn't supported.");
-};
-exports.transform = transform;
-const noop = () => undefined;
-const cleanTree = (tree) => {
-    return (0, exports.transform)(tree, {
-        stmt_len: noop,
-        stmt_location: noop,
-        location: noop,
-        DefElem: (obj) => {
-            if (obj.defname === 'as') {
-                if (Array.isArray(obj.arg) && obj.arg.length) {
-                    // function
-                    obj.arg[0].String.sval = obj.arg[0].String.sval.trim();
-                }
-                else if (obj.arg.List && obj.arg.List.items) {
-                    // function
-                    obj.arg.List.items[0].String.sval = obj.arg.List.items[0].String.sval.trim();
-                }
-                else {
-                    // do stmt
-                    obj.arg.String.sval = obj.arg.String.sval.trim();
-                }
-                return (0, exports.cleanTree)(obj);
-            }
-            else {
-                return (0, exports.cleanTree)(obj);
-            }
-        }
-    });
-};
-exports.cleanTree = cleanTree;
-const cleanTreeWithStmt = (tree) => {
-    return (0, exports.transform)(tree, {
-        stmt_location: noop,
-        location: noop
-    });
-};
-exports.cleanTreeWithStmt = cleanTreeWithStmt;

package/utils/statement-splitter.d.ts

@@ -1,38 +0,0 @@
-import { RawStmt } from '@pgsql/types';
-export interface ExtractedStatement {
-    statement: string;
-    index: number;
-    location?: number;
-    length?: number;
-}
-export interface StatementSplitterOptions {
-    /** Skip validation for malformed statements */
-    skipValidation?: boolean;
-    /** Strip leading comments from extracted statements */
-    stripComments?: boolean;
-}
-/**
- * Extracts a single statement from SQL using PostgreSQL's location information.
- * Handles Unicode properly by using byte positions instead of character positions.
- */
-export declare function extractStatement(originalSQL: string, rawStmt: RawStmt, isFirst?: boolean, options?: StatementSplitterOptions): string | null;
-/**
- * Splits SQL text into individual statements using PostgreSQL's parser.
- * Handles Unicode characters properly and provides detailed location information.
- */
-export declare function splitStatements(sql: string, options?: StatementSplitterOptions): Promise<ExtractedStatement[]>;
-/**
- * Utility to generate statement keys for fixtures
- */
-export declare function generateStatementKey(relativePath: string, statementIndex: number, extension?: string): string;
-/**
- * Test utility to compare byte vs character extraction for debugging Unicode issues
- */
-export declare function debugUnicodeExtraction(sql: string, rawStmt: RawStmt): {
-    characterBased: string;
-    byteBased: string;
-    matches: boolean;
-    unicodeChars: number;
-    byteLength: number;
-    charLength: number;
-};