pgsql-deparser 13.15.0 → 13.18.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 = true) {
+        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,145 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+
+import { SqlFormatter } from '../utils/sql-formatter';
+export interface DeparserContextOptions {
+    isStringLiteral?: boolean;
+    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 class DeparserContext {
+    readonly indentLevel: number;
+    readonly prettyMode: boolean;
+    readonly isStringLiteral?: boolean;
+    readonly parentNodeTypes: string[];
+    private readonly formatter: SqlFormatter;
+    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 = 0, prettyMode = true, isStringLiteral, parentNodeTypes = [], formatter, select, from, group, sort, insertColumns, update, bool, isColumnConstraint, isDomainConstraint, alterColumnOptions, alterTableOptions, isEnumValue, objtype, subtype, ...rest }: DeparserContextOptions = {}) {
+        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: string, overrides: Partial<DeparserContextOptions> = {}): DeparserContext {
+        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: string, count?: number): string {
+        if (!this.prettyMode) {
+            return text;
+        }
+        const indentCount = count !== undefined ? count : this.indentLevel + 1;
+        return this.formatter.indent(text, indentCount);
+    }
+    newline(): string {
+        return this.formatter.newline();
+    }
+    parens(content: string): string {
+        return this.formatter.parens(content);
+    }
+    format(parts: string[], separator?: string): string {
+        return this.formatter.format(parts, separator);
+    }
+    isPretty(): boolean {
+        return this.formatter.isPretty();
+    }
+}
+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 13
+ * Auto-generated by generate-version-deparsers.ts
+ */
+
+import { Node, ParseResult } from '@pgsql/types';
+import { 
+  deparse as deparse17, 
+  deparseSync as deparseSync17,
+  DeparserOptions 
+} from './deparser';
+import { PG13ToPG17Transformer } from './v13-to-v17-direct';
+
+const tx = new PG13ToPG17Transformer();
+
+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';