pgsql-deparser 17.8.3 → 17.8.4

package/README.md

@@ -69,6 +69,23 @@ console.log(deparse(stmt));
 // Output: SELECT * FROM another_table
 ```
 
+### Latest Version (PostgreSQL 17)
+
+```sh
+npm install pgsql-deparser
+```
+
+### Version-Specific Packages (PostgreSQL 13-16)
+
+While we highly recommend using PG17, for PostgreSQL versions 13-16, use the version-specific packages:
+
+```sh
+npm install pgsql-deparser@v13  # PostgreSQL 13
+npm install pgsql-deparser@v14  # PostgreSQL 14
+npm install pgsql-deparser@v15  # PostgreSQL 15
+npm install pgsql-deparser@v16  # PostgreSQL 16
+```
+
 ## Options
 
 The deparser accepts optional configuration for formatting and output control:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-deparser",
-  "version": "17.8.3",
+  "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",
@@ -51,5 +58,5 @@
   "dependencies": {
     "@pgsql/types": "^17.6.1"
   },
-  "gitHead": "de35365d6a05e91c77c04dea213d5aadfa8b19a6"
+  "gitHead": "db3e424332bcb223c34a1caca3f37fb6fc9a1964"
 }

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

package/utils/statement-splitter.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractStatement = extractStatement;
-exports.splitStatements = splitStatements;
-exports.generateStatementKey = generateStatementKey;
-exports.debugUnicodeExtraction = debugUnicodeExtraction;
-const libpg_query_1 = require("libpg-query");
-/**
- * Extracts a single statement from SQL using PostgreSQL's location information.
- * Handles Unicode properly by using byte positions instead of character positions.
- */
-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.
- */
-async function splitStatements(sql, options = {}) {
-    const parseResult = await (0, libpg_query_1.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
- */
-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
- */
-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
-    };
-}