pgsql-deparser 13.16.0 → 14.0.0

package/src/deparser/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+
+import { Deparser, DeparserOptions } from "./deparser";
+const deparseMethod = Deparser.deparse;
+// Export the original sync version as deparseSync
+export const deparseSync = deparseMethod;
+// Create an async wrapper for deparse
+export const deparse = async (...args: Parameters<typeof deparseMethod>): Promise<ReturnType<typeof deparseMethod>> => {
+    return deparseMethod(...args);
+};
+export { Deparser, DeparserOptions };

package/src/deparser/utils/list-utils.ts

@@ -0,0 +1,27 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+
+export class ListUtils {
+    static unwrapList(obj: any): any[] {
+        if (obj === undefined || obj === null) {
+            return [];
+        }
+        if (obj.List !== undefined) {
+            return obj.List.items || [];
+        }
+        if (Array.isArray(obj)) {
+            return obj;
+        }
+        return [obj];
+    }
+    static formatList(items: any[], separator: string = ', ', prefix: string = '', formatter: (item: any) => string): string {
+        if (!items || items.length === 0) {
+            return '';
+        }
+        return items
+            .map(item => `${prefix}${formatter(item)}`)
+            .join(separator);
+    }
+}

package/src/deparser/utils/quote-utils.ts

@@ -0,0 +1,86 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+
+const RESERVED_WORDS = new Set([
+    'all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric',
+    'authorization', 'binary', 'both', 'case', 'cast', 'check', 'collate', 'collation',
+    'column', 'concurrently', 'constraint', 'create', 'cross', 'current_catalog',
+    'current_date', 'current_role', 'current_schema', 'current_time', 'current_timestamp',
+    'current_user', 'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end',
+    'except', 'false', 'fetch', 'for', 'foreign', 'freeze', 'from', 'full', 'grant',
+    'group', 'having', 'ilike', 'in', 'initially', 'inner', 'intersect', 'into', 'is',
+    'isnull', 'join', 'lateral', 'leading', 'left', 'like', 'limit', 'localtime',
+    'localtimestamp', 'natural', 'not', 'notnull', 'null', 'offset', 'on', 'only',
+    'or', 'order', 'outer', 'overlaps', 'placing', 'primary', 'references', 'returning',
+    'right', 'select', 'session_user', 'similar', 'some', 'symmetric', 'table', 'tablesample',
+    'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic',
+    'verbose', 'when', 'where', 'window', 'with'
+]);
+export class QuoteUtils {
+    static needsQuotes(value: string): boolean {
+        if (!value || typeof value !== 'string') {
+            return false;
+        }
+        const lowerValue = value.toLowerCase();
+        if (RESERVED_WORDS.has(lowerValue)) {
+            return true;
+        }
+        if (!/^[a-z_][a-z0-9_$]*$/i.test(value)) {
+            return true;
+        }
+        if (value !== value.toLowerCase()) {
+            return true;
+        }
+        return false;
+    }
+    static quote(value: any): any {
+        if (value == null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.quote(v));
+        }
+        if (typeof value !== 'string') {
+            return value;
+        }
+        if (this.needsQuotes(value)) {
+            return `"${value}"`;
+        }
+        return value;
+    }
+    static escape(literal: string): string {
+        return `'${literal.replace(/'/g, "''")}'`;
+    }
+    /**
+     * Escapes a string value for use in E-prefixed string literals
+     * Handles both backslashes and single quotes properly
+     */
+    static escapeEString(value: string): string {
+        return value.replace(/\\/g, '\\\\').replace(/'/g, "''");
+    }
+    /**
+     * Formats a string as an E-prefixed string literal with proper escaping
+     * This wraps the complete E-prefix logic including detection and formatting
+     */
+    static formatEString(value: string): string {
+        const needsEscape = QuoteUtils.needsEscapePrefix(value);
+        if (needsEscape) {
+            const escapedValue = QuoteUtils.escapeEString(value);
+            return `E'${escapedValue}'`;
+        }
+        else {
+            return QuoteUtils.escape(value);
+        }
+    }
+    /**
+     * Determines if a string value needs E-prefix for escaped string literals
+     * Detects backslash escape sequences that require E-prefix in PostgreSQL
+     */
+    static needsEscapePrefix(value: string): boolean {
+        // Always use E'' if the string contains any backslashes,
+        // unless it's a raw \x... bytea-style literal.
+        return !/^\\x[0-9a-fA-F]+$/i.test(value) && value.includes('\\');
+    }
+}

package/src/deparser/utils/sql-formatter.ts

@@ -0,0 +1,37 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+
+export class SqlFormatter {
+    private newlineChar: string;
+    private tabChar: string;
+    private prettyMode: boolean;
+    constructor(newlineChar: string = '\n', tabChar: string = '  ', prettyMode: boolean = false) {
+        this.newlineChar = newlineChar;
+        this.tabChar = tabChar;
+        this.prettyMode = prettyMode;
+    }
+    format(parts: string[], separator: string = ' '): string {
+        return parts.filter(part => part !== null && part !== undefined && part !== '').join(separator);
+    }
+    indent(text: string, count: number = 1): string {
+        if (!this.prettyMode) {
+            return text;
+        }
+        const indentation = this.tabChar.repeat(count);
+        return text.split(this.newlineChar).map(line => line.trim() ? indentation + line : line).join(this.newlineChar);
+    }
+    parens(content: string): string {
+        return `(${content})`;
+    }
+    newline(): string {
+        return this.newlineChar;
+    }
+    tab(): string {
+        return this.tabChar;
+    }
+    isPretty(): boolean {
+        return this.prettyMode;
+    }
+}

package/src/deparser/visitors/base.ts

@@ -0,0 +1,40 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+
+export interface DeparserContext {
+    isStringLiteral?: boolean;
+    parentNodeTypes: string[];
+    [key: string]: any;
+}
+export interface DeparserVisitor {
+    visit(node: any, context?: DeparserContext): string;
+}
+export abstract class BaseVisitor implements DeparserVisitor {
+    abstract visit(node: any, context?: DeparserContext): string;
+    protected getNodeType(node: any): string {
+        return Object.keys(node)[0];
+    }
+    protected getNodeData(node: any): any {
+        const type = this.getNodeType(node);
+        return (node as any)[type];
+    }
+    protected formatList(items: any[], separator: string = ', ', prefix: string = '', formatter: (item: any) => string): string {
+        if (!items || items.length === 0) {
+            return '';
+        }
+        return items
+            .map(item => `${prefix}${formatter(item)}`)
+            .join(separator);
+    }
+    protected formatParts(parts: string[], separator: string = ' '): string {
+        return parts.filter(part => part !== null && part !== undefined && part !== '').join(separator);
+    }
+    protected formatParens(content: string): string {
+        return `(${content})`;
+    }
+    protected formatIndent(text: string, count: number = 1): string {
+        return text;
+    }
+}

package/src/index.ts

@@ -1,3 +1,27 @@
-import Deparser from './deparser';
-const deparse = Deparser.deparse;
-export { deparse, Deparser };
+/**
+ * Deparser for PostgreSQL version 14
+ * Auto-generated by generate-version-deparsers.ts
+ */
+
+import { Node, ParseResult } from '@pgsql/types';
+import { 
+  deparse as deparse17, 
+  deparseSync as deparseSync17,
+  DeparserOptions 
+} from './deparser';
+import { PG14ToPG17Transformer } from './v14-to-v17-direct';
+
+const tx = new PG14ToPG17Transformer();
+
+export async function deparse(query: Node | Node[] | ParseResult, opts?: DeparserOptions): Promise<string> {
+  const ast17 = tx.transform(query);
+  return await deparse17(ast17, opts);
+}
+
+export function deparseSync(query: Node | Node[] | ParseResult, opts?: DeparserOptions): string {
+  const ast17 = tx.transform(query);
+  return deparseSync17(ast17, opts);
+}
+
+// Re-export DeparserOptions for convenience
+export { DeparserOptions } from './deparser';