pgsql-deparser 13.16.0 → 13.19.0

package/esm/deparser/index.js

@@ -0,0 +1,13 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+import { Deparser } 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) => {
+    return deparseMethod(...args);
+};
+export { Deparser };

package/esm/deparser/utils/list-utils.js

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+        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, separator = ', ', prefix = '', formatter) {
+        if (!items || items.length === 0) {
+            return '';
+        }
+        return items
+            .map(item => `${prefix}${formatter(item)}`)
+            .join(separator);
+    }
+}

package/esm/deparser/utils/quote-utils.js

@@ -0,0 +1,85 @@
+/**
+ * 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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        // 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/esm/deparser/utils/sql-formatter.js

@@ -0,0 +1,36 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+export class SqlFormatter {
+    newlineChar;
+    tabChar;
+    prettyMode;
+    constructor(newlineChar = '\n', tabChar = '  ', prettyMode = true) {
+        this.newlineChar = newlineChar;
+        this.tabChar = tabChar;
+        this.prettyMode = prettyMode;
+    }
+    format(parts, separator = ' ') {
+        return parts.filter(part => part !== null && part !== undefined && part !== '').join(separator);
+    }
+    indent(text, count = 1) {
+        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) {
+        return `(${content})`;
+    }
+    newline() {
+        return this.newlineChar;
+    }
+    tab() {
+        return this.tabChar;
+    }
+    isPretty() {
+        return this.prettyMode;
+    }
+}

package/esm/deparser/visitors/base.js

@@ -0,0 +1,117 @@
+/**
+ * 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 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 = true, 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];
+    }
+    getNodeData(node) {
+        const type = this.getNodeType(node);
+        return node[type];
+    }
+    formatList(items, separator = ', ', prefix = '', formatter) {
+        if (!items || items.length === 0) {
+            return '';
+        }
+        return items
+            .map(item => `${prefix}${formatter(item)}`)
+            .join(separator);
+    }
+    formatParts(parts, separator = ' ') {
+        return parts.filter(part => part !== null && part !== undefined && part !== '').join(separator);
+    }
+    formatParens(content) {
+        return `(${content})`;
+    }
+    formatIndent(text, count = 1) {
+        return text;
+    }
+}

package/esm/index.js

@@ -0,0 +1,15 @@
+/**
+ * Deparser for PostgreSQL version 13
+ * Auto-generated by generate-version-deparsers.ts
+ */
+import { deparse as deparse17, deparseSync as deparseSync17 } from './deparser';
+import { PG13ToPG17Transformer } from './v13-to-v17-direct';
+const tx = new PG13ToPG17Transformer();
+export async function deparse(query, opts) {
+    const ast17 = tx.transform(query);
+    return await deparse17(ast17, opts);
+}
+export function deparseSync(query, opts) {
+    const ast17 = tx.transform(query);
+    return deparseSync17(ast17, opts);
+}