pgsql-deparser 17.14.0 → 17.15.0

package/deparser.js

@@ -1851,8 +1851,9 @@ class Deparser {
                 return output.join(' ');
             }
         }
-        const quotedNames = names.map((name) => quote_utils_1.QuoteUtils.quoteIdentifier(name));
-        let result = mods(quotedNames.join('.'), args);
+        // Use type-name quoting for non-pg_catalog types
+        // This allows keywords like 'json', 'int', 'boolean' to remain unquoted in type positions
+        let result = mods(quote_utils_1.QuoteUtils.quoteTypeDottedName(names), args);
         if (node.arrayBounds && node.arrayBounds.length > 0) {
             result += formatArrayBounds(node.arrayBounds);
         }

package/esm/deparser.js

@@ -1848,8 +1848,9 @@ export class Deparser {
                 return output.join(' ');
             }
         }
-        const quotedNames = names.map((name) => QuoteUtils.quoteIdentifier(name));
-        let result = mods(quotedNames.join('.'), args);
+        // Use type-name quoting for non-pg_catalog types
+        // This allows keywords like 'json', 'int', 'boolean' to remain unquoted in type positions
+        let result = mods(QuoteUtils.quoteTypeDottedName(names), args);
         if (node.arrayBounds && node.arrayBounds.length > 0) {
             result += formatArrayBounds(node.arrayBounds);
         }

package/esm/utils/quote-utils.js

@@ -168,4 +168,73 @@ export class QuoteUtils {
         }
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-deparser",
-  "version": "17.14.0",
+  "version": "17.15.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL AST Deparser",
   "main": "index.js",
@@ -60,5 +60,5 @@
   "dependencies": {
     "@pgsql/types": "^17.6.2"
   },
-  "gitHead": "48ea4210dc676c26c3ca4de8650cdd64c4eb3bd3"
+  "gitHead": "df8eb8b89aee325cd9005599bc2ac67a746aade7"
 }

package/utils/quote-utils.d.ts

@@ -62,4 +62,26 @@ export declare class QuoteUtils {
      * is null/undefined, quoting each component if necessary.
      */
     static quoteQualifiedIdentifier(qualifier: string | null | undefined, ident: string): string;
+    /**
+     * 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: string): string;
+    /**
+     * 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: string[]): string;
 }

package/utils/quote-utils.js

@@ -171,5 +171,74 @@ class QuoteUtils {
         }
         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 = (0, kwlist_1.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('.');
+    }
 }
 exports.QuoteUtils = QuoteUtils;