pgsql-deparser 17.17.2 → 17.18.0

package/esm/utils/quote-utils.js

@@ -1,240 +0,0 @@
-import { keywordKindOf } from '../kwlist';
-export class QuoteUtils {
-    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('\\');
-    }
-    /**
-     * Quote an identifier only if needed
-     *
-     * This is a TypeScript port of PostgreSQL's quote_identifier() function from ruleutils.c
-     * https://github.com/postgres/postgres/blob/fab5cd3dd1323f9e66efeb676c4bb212ff340204/src/backend/utils/adt/ruleutils.c#L13055-L13137
-     *
-     * Can avoid quoting if ident starts with a lowercase letter or underscore
-     * and contains only lowercase letters, digits, and underscores, *and* is
-     * not any SQL keyword. Otherwise, supply quotes.
-     *
-     * When quotes are needed, embedded double quotes are properly escaped as "".
-     */
-    static quoteIdentifier(ident) {
-        if (!ident)
-            return ident;
-        let safe = true;
-        // Check first character: must be lowercase letter or underscore
-        const firstChar = ident[0];
-        if (!((firstChar >= 'a' && firstChar <= 'z') || firstChar === '_')) {
-            safe = false;
-        }
-        // Check all characters
-        for (let i = 0; i < ident.length; i++) {
-            const ch = ident[i];
-            if ((ch >= 'a' && ch <= 'z') ||
-                (ch >= '0' && ch <= '9') ||
-                (ch === '_')) {
-                // okay
-            }
-            else {
-                safe = false;
-            }
-        }
-        if (safe) {
-            // Check for keyword. We quote keywords except for unreserved ones.
-            // (In some cases we could avoid quoting a col_name or type_func_name
-            // keyword, but it seems much harder than it's worth to tell that.)
-            const kwKind = keywordKindOf(ident);
-            if (kwKind !== 'NO_KEYWORD' && kwKind !== 'UNRESERVED_KEYWORD') {
-                safe = false;
-            }
-        }
-        if (safe) {
-            return ident; // no change needed
-        }
-        // Build quoted identifier with escaped embedded quotes
-        let result = '"';
-        for (let i = 0; i < ident.length; i++) {
-            const ch = ident[i];
-            if (ch === '"') {
-                result += '"'; // escape " as ""
-            }
-            result += ch;
-        }
-        result += '"';
-        return result;
-    }
-    /**
-     * Quote an identifier that appears after a dot in a qualified name.
-     *
-     * In PostgreSQL's grammar, identifiers that appear after a dot (e.g., schema.name,
-     * table.column) are in a more permissive position that accepts all keyword categories
-     * including RESERVED_KEYWORD. This means we only need to quote for lexical reasons
-     * (uppercase, special characters, leading digits) not for keyword reasons.
-     *
-     * Empirically verified: `myschema.select`, `myschema.float`, `t.from` all parse
-     * successfully in PostgreSQL without quotes.
-     */
-    static quoteIdentifierAfterDot(ident) {
-        if (!ident)
-            return ident;
-        let safe = true;
-        const firstChar = ident[0];
-        if (!((firstChar >= 'a' && firstChar <= 'z') || firstChar === '_')) {
-            safe = false;
-        }
-        for (let i = 0; i < ident.length; i++) {
-            const ch = ident[i];
-            if ((ch >= 'a' && ch <= 'z') ||
-                (ch >= '0' && ch <= '9') ||
-                (ch === '_')) {
-                // okay
-            }
-            else {
-                safe = false;
-            }
-        }
-        if (safe) {
-            return ident;
-        }
-        let result = '"';
-        for (let i = 0; i < ident.length; i++) {
-            const ch = ident[i];
-            if (ch === '"') {
-                result += '"';
-            }
-            result += ch;
-        }
-        result += '"';
-        return result;
-    }
-    /**
-     * Quote a dotted name (e.g., schema.table, catalog.schema.table).
-     *
-     * The first part uses strict quoting (keywords are quoted), while subsequent
-     * parts use relaxed quoting (keywords allowed, only quote for lexical reasons).
-     *
-     * This reflects PostgreSQL's grammar where the first identifier in a statement
-     * may conflict with keywords, but identifiers after a dot are in a more
-     * permissive position.
-     */
-    static quoteDottedName(parts) {
-        if (!parts || parts.length === 0)
-            return '';
-        if (parts.length === 1) {
-            return QuoteUtils.quoteIdentifier(parts[0]);
-        }
-        return parts.map((part, index) => index === 0 ? QuoteUtils.quoteIdentifier(part) : QuoteUtils.quoteIdentifierAfterDot(part)).join('.');
-    }
-    /**
-     * Quote a possibly-qualified identifier
-     *
-     * This is inspired by PostgreSQL's quote_qualified_identifier() function from ruleutils.c
-     * but uses relaxed quoting for the tail component since PostgreSQL's grammar accepts
-     * all keywords in qualified name positions.
-     *
-     * Return a name of the form qualifier.ident, or just ident if qualifier
-     * is null/undefined, quoting each component if necessary.
-     */
-    static quoteQualifiedIdentifier(qualifier, ident) {
-        if (qualifier) {
-            return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifierAfterDot(ident)}`;
-        }
-        return QuoteUtils.quoteIdentifier(ident);
-    }
-    /**
-     * Quote an identifier that appears as a type name.
-     *
-     * Type names in PostgreSQL have a less strict quoting policy than standalone identifiers.
-     * In type positions, COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted
-     * (e.g., 'json', 'int', 'boolean', 'interval'). Only RESERVED_KEYWORD must be quoted.
-     *
-     * This is different from:
-     * - quoteIdentifier(): quotes all keywords except UNRESERVED_KEYWORD
-     * - quoteIdentifierAfterDot(): only quotes for lexical reasons (no keyword checking)
-     *
-     * Type names still need quoting for lexical reasons (uppercase, special chars, etc.).
-     */
-    static quoteIdentifierTypeName(ident) {
-        if (!ident)
-            return ident;
-        let safe = true;
-        // Check first character: must be lowercase letter or underscore
-        const firstChar = ident[0];
-        if (!((firstChar >= 'a' && firstChar <= 'z') || firstChar === '_')) {
-            safe = false;
-        }
-        // Check all characters
-        for (let i = 0; i < ident.length; i++) {
-            const ch = ident[i];
-            if ((ch >= 'a' && ch <= 'z') ||
-                (ch >= '0' && ch <= '9') ||
-                (ch === '_')) {
-                // okay
-            }
-            else {
-                safe = false;
-            }
-        }
-        if (safe) {
-            // For type names, only quote RESERVED_KEYWORD
-            // COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted in type positions
-            const kwKind = keywordKindOf(ident);
-            if (kwKind === 'RESERVED_KEYWORD') {
-                safe = false;
-            }
-        }
-        if (safe) {
-            return ident; // no change needed
-        }
-        // Build quoted identifier with escaped embedded quotes
-        let result = '"';
-        for (let i = 0; i < ident.length; i++) {
-            const ch = ident[i];
-            if (ch === '"') {
-                result += '"'; // escape " as ""
-            }
-            result += ch;
-        }
-        result += '"';
-        return result;
-    }
-    /**
-     * Quote a dotted type name (e.g., schema.typename).
-     *
-     * For type names, we use type-name quoting for all parts since the entire
-     * qualified name is in a type context. This allows keywords like 'json',
-     * 'int', 'boolean' to remain unquoted in user-defined schema-qualified types.
-     */
-    static quoteTypeDottedName(parts) {
-        if (!parts || parts.length === 0)
-            return '';
-        return parts.map(part => QuoteUtils.quoteIdentifierTypeName(part)).join('.');
-    }
-}

package/kwlist.d.ts

@@ -1,16 +0,0 @@
-/**
- * Generated from PostgreSQL kwlist.h
- * DO NOT EDIT BY HAND.
- */
-export type KeywordKind = "NO_KEYWORD" | "UNRESERVED_KEYWORD" | "COL_NAME_KEYWORD" | "TYPE_FUNC_NAME_KEYWORD" | "RESERVED_KEYWORD";
-export declare const kwlist: {
-    readonly UNRESERVED_KEYWORD: readonly ["abort", "absent", "absolute", "access", "action", "add", "admin", "after", "aggregate", "also", "alter", "always", "asensitive", "assertion", "assignment", "at", "atomic", "attach", "attribute", "backward", "before", "begin", "breadth", "by", "cache", "call", "called", "cascade", "cascaded", "catalog", "chain", "characteristics", "checkpoint", "class", "close", "cluster", "columns", "comment", "comments", "commit", "committed", "compression", "conditional", "configuration", "conflict", "connection", "constraints", "content", "continue", "conversion", "copy", "cost", "csv", "cube", "current", "cursor", "cycle", "data", "database", "day", "deallocate", "declare", "defaults", "deferred", "definer", "delete", "delimiter", "delimiters", "depends", "depth", "detach", "dictionary", "disable", "discard", "document", "domain", "double", "drop", "each", "empty", "enable", "encoding", "encrypted", "enforced", "enum", "error", "escape", "event", "exclude", "excluding", "exclusive", "execute", "explain", "expression", "extension", "external", "family", "filter", "finalize", "first", "following", "force", "format", "forward", "function", "functions", "generated", "global", "granted", "groups", "handler", "header", "hold", "hour", "identity", "if", "ignore", "immediate", "immutable", "implicit", "import", "include", "including", "increment", "indent", "index", "indexes", "inherit", "inherits", "inline", "input", "insensitive", "insert", "instead", "invoker", "isolation", "keep", "key", "keys", "label", "language", "large", "last", "leakproof", "level", "listen", "load", "local", "location", "lock", "locked", "logged", "lsn", "mapping", "match", "matched", "materialized", "maxvalue", "merge", "method", "minute", "minvalue", "mode", "month", "move", "name", "names", "nested", "new", "next", "nfc", "nfd", "nfkc", "nfkd", "no", "normalized", "nothing", "notify", "nowait", "nulls", "object", "objects", "of", "off", "oids", "old", "omit", "operator", "option", "options", "ordinality", "others", "over", "overriding", "owned", "owner", "parallel", "parameter", "parser", "partial", "partition", "partitions", "passing", "password", "path", "period", "plan", "plans", "policy", "preceding", "prepare", "prepared", "preserve", "prior", "privileges", "procedural", "procedure", "procedures", "program", "publication", "quote", "quotes", "range", "read", "reassign", "recursive", "ref", "referencing", "refresh", "reindex", "relative", "release", "rename", "repeatable", "replace", "replica", "reset", "respect", "restart", "restrict", "return", "returns", "revoke", "role", "rollback", "rollup", "routine", "routines", "rows", "rule", "savepoint", "scalar", "schema", "schemas", "scroll", "search", "second", "security", "sequence", "sequences", "serializable", "server", "session", "set", "sets", "share", "show", "simple", "skip", "snapshot", "source", "split", "sql", "stable", "standalone", "start", "statement", "statistics", "stdin", "stdout", "storage", "stored", "strict", "string", "strip", "subscription", "support", "sysid", "system", "tables", "tablespace", "target", "temp", "template", "temporary", "text", "ties", "transaction", "transform", "trigger", "truncate", "trusted", "type", "types", "uescape", "unbounded", "uncommitted", "unconditional", "unencrypted", "unknown", "unlisten", "unlogged", "until", "update", "vacuum", "valid", "validate", "validator", "value", "varying", "version", "view", "views", "virtual", "volatile", "wait", "whitespace", "within", "without", "work", "wrapper", "write", "xml", "year", "yes", "zone"];
-    readonly RESERVED_KEYWORD: readonly ["all", "analyse", "analyze", "and", "any", "array", "as", "asc", "asymmetric", "both", "case", "cast", "check", "collate", "column", "constraint", "create", "current_catalog", "current_date", "current_role", "current_time", "current_timestamp", "current_user", "default", "deferrable", "desc", "distinct", "do", "else", "end", "except", "false", "fetch", "for", "foreign", "from", "grant", "group", "having", "in", "initially", "intersect", "into", "lateral", "leading", "limit", "localtime", "localtimestamp", "not", "null", "offset", "on", "only", "or", "order", "placing", "primary", "references", "returning", "select", "session_user", "some", "symmetric", "system_user", "table", "then", "to", "trailing", "true", "union", "unique", "user", "using", "variadic", "when", "where", "window", "with"];
-    readonly TYPE_FUNC_NAME_KEYWORD: readonly ["authorization", "binary", "collation", "concurrently", "cross", "current_schema", "freeze", "full", "ilike", "inner", "is", "isnull", "join", "left", "like", "natural", "notnull", "outer", "overlaps", "right", "similar", "tablesample", "verbose"];
-    readonly COL_NAME_KEYWORD: readonly ["between", "bigint", "bit", "boolean", "char", "character", "coalesce", "dec", "decimal", "exists", "extract", "float", "greatest", "grouping", "inout", "int", "integer", "interval", "json", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_scalar", "json_serialize", "json_table", "json_value", "least", "merge_action", "national", "nchar", "none", "normalize", "nullif", "numeric", "out", "overlay", "position", "precision", "real", "row", "setof", "smallint", "substring", "time", "timestamp", "treat", "trim", "values", "varchar", "xmlattributes", "xmlconcat", "xmlelement", "xmlexists", "xmlforest", "xmlnamespaces", "xmlparse", "xmlpi", "xmlroot", "xmlserialize", "xmltable"];
-};
-export declare const RESERVED_KEYWORDS: Set<string>;
-export declare const UNRESERVED_KEYWORDS: Set<string>;
-export declare const COL_NAME_KEYWORDS: Set<string>;
-export declare const TYPE_FUNC_NAME_KEYWORDS: Set<string>;
-export declare function keywordKindOf(word: string): KeywordKind;