pgsql-deparser 13.16.0 → 14.0.1

package/deparser/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+import { Deparser, DeparserOptions } from "./deparser";
+declare const deparseMethod: typeof Deparser.deparse;
+export declare const deparseSync: typeof Deparser.deparse;
+export declare const deparse: (...args: Parameters<typeof deparseMethod>) => Promise<ReturnType<typeof deparseMethod>>;
+export { Deparser, DeparserOptions };

package/deparser/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deparser = exports.deparse = exports.deparseSync = void 0;
+const deparser_1 = require("./deparser");
+Object.defineProperty(exports, "Deparser", { enumerable: true, get: function () { return deparser_1.Deparser; } });
+const deparseMethod = deparser_1.Deparser.deparse;
+// Export the original sync version as deparseSync
+exports.deparseSync = deparseMethod;
+// Create an async wrapper for deparse
+const deparse = async (...args) => {
+    return deparseMethod(...args);
+};
+exports.deparse = deparse;

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

@@ -0,0 +1,8 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+export declare class ListUtils {
+    static unwrapList(obj: any): any[];
+    static formatList(items: any[], separator: string, prefix: string, formatter: (item: any) => string): string;
+}

package/deparser/utils/list-utils.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListUtils = void 0;
+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);
+    }
+}
+exports.ListUtils = ListUtils;

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

@@ -0,0 +1,24 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+export declare class QuoteUtils {
+    static needsQuotes(value: string): boolean;
+    static quote(value: any): any;
+    static escape(literal: string): string;
+    /**
+     * Escapes a string value for use in E-prefixed string literals
+     * Handles both backslashes and single quotes properly
+     */
+    static escapeEString(value: string): string;
+    /**
+     * 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;
+    /**
+     * 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;
+}

package/deparser/utils/quote-utils.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteUtils = void 0;
+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'
+]);
+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('\\');
+    }
+}
+exports.QuoteUtils = QuoteUtils;

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

@@ -0,0 +1,16 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+export declare class SqlFormatter {
+    private newlineChar;
+    private tabChar;
+    private prettyMode;
+    constructor(newlineChar?: string, tabChar?: string, prettyMode?: boolean);
+    format(parts: string[], separator?: string): string;
+    indent(text: string, count?: number): string;
+    parens(content: string): string;
+    newline(): string;
+    tab(): string;
+    isPretty(): boolean;
+}

package/deparser/utils/sql-formatter.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlFormatter = void 0;
+class SqlFormatter {
+    newlineChar;
+    tabChar;
+    prettyMode;
+    constructor(newlineChar = '\n', tabChar = '  ', prettyMode = false) {
+        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;
+    }
+}
+exports.SqlFormatter = SqlFormatter;

package/deparser/visitors/base.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 declare abstract class BaseVisitor implements DeparserVisitor {
+    abstract visit(node: any, context?: DeparserContext): string;
+    protected getNodeType(node: any): string;
+    protected getNodeData(node: any): any;
+    protected formatList(items: any[], separator: string, prefix: string, formatter: (item: any) => string): string;
+    protected formatParts(parts: string[], separator?: string): string;
+    protected formatParens(content: string): string;
+    protected formatIndent(text: string, count?: number): string;
+}

package/deparser/visitors/base.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseVisitor = void 0;
+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;
+    }
+}
+exports.BaseVisitor = BaseVisitor;