pgsql-deparser 17.8.4 → 17.9.0

package/README.md

@@ -80,12 +80,17 @@ npm install pgsql-deparser
 While we highly recommend using PG17, for PostgreSQL versions 13-16, use the version-specific packages:
 
 ```sh
-npm install pgsql-deparser@v13  # PostgreSQL 13
-npm install pgsql-deparser@v14  # PostgreSQL 14
-npm install pgsql-deparser@v15  # PostgreSQL 15
-npm install pgsql-deparser@v16  # PostgreSQL 16
+npm install pgsql-deparser@pg13  # PostgreSQL 13
+npm install pgsql-deparser@pg14  # PostgreSQL 14
+npm install pgsql-deparser@pg15  # PostgreSQL 15
+npm install pgsql-deparser@pg16  # PostgreSQL 16
 ```
 
+**Version Status:**
+- **PG17**: 🚀 Recommended (stable + modern AST)
+- **PG14-16**: ⚠️ Experimental (modern AST, hardening in progress)
+- **PG13**: Stable (legacy AST format)
+
 ## Options
 
 The deparser accepts optional configuration for formatting and output control:
@@ -150,6 +155,7 @@ Built on the excellent work of several contributors:
 * [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): Offers TypeScript type definitions for PostgreSQL AST nodes, facilitating type-safe construction, analysis, and manipulation of ASTs.
 * [@pgsql/enums](https://www.npmjs.com/package/@pgsql/enums): Provides TypeScript enum definitions for PostgreSQL constants, enabling type-safe usage of PostgreSQL enums and constants in your applications.
 * [@pgsql/utils](https://www.npmjs.com/package/@pgsql/utils): A comprehensive utility library for PostgreSQL, offering type-safe AST node creation and enum value conversions, simplifying the construction and manipulation of PostgreSQL ASTs.
+* [@pgsql/traverse](https://www.npmjs.com/package/@pgsql/traverse): PostgreSQL AST traversal utilities for pgsql-parser, providing a visitor pattern for traversing PostgreSQL Abstract Syntax Tree nodes, similar to Babel's traverse functionality but specifically designed for PostgreSQL AST structures.
 * [pg-proto-parser](https://www.npmjs.com/package/pg-proto-parser): A TypeScript tool that parses PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
 * [libpg-query](https://github.com/launchql/libpg-query-node): The real PostgreSQL parser exposed for Node.js, used primarily in `pgsql-parser` for parsing and deparsing SQL queries.
 

package/deparser.js

@@ -2485,30 +2485,61 @@ class Deparser {
                         .map(option => {
                         if (option.DefElem) {
                             const defElem = option.DefElem;
-                            const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
-                            if (defElem.defname === 'start') {
+                            if (defElem.defname === 'sequence_name') {
+                                if (defElem.arg && defElem.arg.List) {
+                                    const nameList = list_utils_1.ListUtils.unwrapList(defElem.arg)
+                                        .map(item => this.visit(item, context))
+                                        .join('.');
+                                    return `SEQUENCE NAME ${nameList}`;
+                                }
+                                return 'SEQUENCE NAME';
+                            }
+                            else if (defElem.defname === 'start') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return `START WITH ${argValue}`;
                             }
                             else if (defElem.defname === 'increment') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return `INCREMENT BY ${argValue}`;
                             }
                             else if (defElem.defname === 'minvalue') {
-                                return `MINVALUE ${argValue}`;
+                                if (defElem.arg) {
+                                    const argValue = this.visit(defElem.arg, context);
+                                    return `MINVALUE ${argValue}`;
+                                }
+                                else {
+                                    return 'NO MINVALUE';
+                                }
                             }
                             else if (defElem.defname === 'maxvalue') {
-                                return `MAXVALUE ${argValue}`;
+                                if (defElem.arg) {
+                                    const argValue = this.visit(defElem.arg, context);
+                                    return `MAXVALUE ${argValue}`;
+                                }
+                                else {
+                                    return 'NO MAXVALUE';
+                                }
                             }
                             else if (defElem.defname === 'cache') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return `CACHE ${argValue}`;
                             }
                             else if (defElem.defname === 'cycle') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return argValue === 'true' ? 'CYCLE' : 'NO CYCLE';
                             }
+                            const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                             return `${defElem.defname.toUpperCase()} ${argValue}`;
                         }
                         return this.visit(option, context);
                     });
-                    output.push(`(${optionStrs.join(' ')})`);
+                    if (context.isPretty()) {
+                        const indentedOptions = optionStrs.map(option => context.indent(option));
+                        output.push('(\n' + indentedOptions.join('\n') + '\n)');
+                    }
+                    else {
+                        output.push(`(${optionStrs.join(' ')})`);
+                    }
                 }
                 break;
             case 'CONSTR_PRIMARY':
@@ -4327,10 +4358,7 @@ class Deparser {
                 const commandsStr = commands
                     .map(cmd => {
                     const cmdStr = this.visit(cmd, alterContext);
-                    if (cmdStr.startsWith('ADD CONSTRAINT') || cmdStr.startsWith('ADD ')) {
-                        return context.newline() + context.indent(cmdStr);
-                    }
-                    return cmdStr;
+                    return context.newline() + context.indent(cmdStr);
                 })
                     .join(',');
                 output.push(commandsStr);
@@ -4360,35 +4388,99 @@ class Deparser {
                     }
                     if (node.def) {
                         const colDefData = this.getNodeData(node.def);
-                        const parts = [];
-                        if (colDefData.colname) {
-                            parts.push(quote_utils_1.QuoteUtils.quote(colDefData.colname));
-                        }
-                        if (colDefData.typeName) {
-                            parts.push(this.TypeName(colDefData.typeName, context));
-                        }
-                        if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
-                            parts.push('OPTIONS');
-                            const columnContext = context.spawn('ColumnDef');
-                            const options = list_utils_1.ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
-                            parts.push(`(${options.join(', ')})`);
-                        }
-                        if (colDefData.constraints) {
-                            const constraints = list_utils_1.ListUtils.unwrapList(colDefData.constraints);
-                            const constraintStrs = constraints.map(constraint => {
-                                const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
-                                return this.visit(constraint, columnConstraintContext);
-                            });
-                            parts.push(...constraintStrs);
-                        }
-                        if (colDefData.raw_default) {
-                            parts.push('DEFAULT');
-                            parts.push(this.visit(colDefData.raw_default, context));
+                        if (context.isPretty()) {
+                            const parts = [];
+                            const indentedParts = [];
+                            if (colDefData.colname) {
+                                parts.push(quote_utils_1.QuoteUtils.quote(colDefData.colname));
+                            }
+                            if (colDefData.typeName) {
+                                parts.push(this.TypeName(colDefData.typeName, context));
+                            }
+                            if (colDefData.is_not_null) {
+                                indentedParts.push('NOT NULL');
+                            }
+                            if (colDefData.collClause) {
+                                indentedParts.push(this.CollateClause(colDefData.collClause, context));
+                            }
+                            if (colDefData.constraints) {
+                                const constraints = list_utils_1.ListUtils.unwrapList(colDefData.constraints);
+                                constraints.forEach(constraint => {
+                                    const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
+                                    const constraintStr = this.visit(constraint, columnConstraintContext);
+                                    if (constraintStr.includes('REFERENCES') && constraintStr.includes('ON DELETE')) {
+                                        const refMatch = constraintStr.match(/^(.*REFERENCES[^)]*\([^)]*\))\s*(ON\s+DELETE\s+CASCADE.*)$/);
+                                        if (refMatch) {
+                                            indentedParts.push(refMatch[1]);
+                                            indentedParts.push(refMatch[2]);
+                                        }
+                                        else {
+                                            indentedParts.push(constraintStr);
+                                        }
+                                    }
+                                    else if (constraintStr === 'UNIQUE' && colDefData.raw_default) {
+                                        const defaultStr = 'DEFAULT ' + this.visit(colDefData.raw_default, context);
+                                        indentedParts.push('UNIQUE ' + defaultStr);
+                                    }
+                                    else {
+                                        indentedParts.push(constraintStr);
+                                    }
+                                });
+                            }
+                            if (colDefData.raw_default && !colDefData.constraints?.some((c) => {
+                                const constraintStr = this.visit(c, context.spawn('ColumnDef', { isColumnConstraint: true }));
+                                return constraintStr === 'UNIQUE';
+                            })) {
+                                const defaultStr = 'DEFAULT ' + this.visit(colDefData.raw_default, context);
+                                indentedParts.push(defaultStr);
+                            }
+                            if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
+                                indentedParts.push('OPTIONS');
+                                const columnContext = context.spawn('ColumnDef');
+                                const options = list_utils_1.ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
+                                indentedParts.push(`(${options.join(', ')})`);
+                            }
+                            let result = parts.join(' ');
+                            if (indentedParts.length > 0) {
+                                const indentedStr = indentedParts.map(part => context.indent(part)).join(context.newline());
+                                result += context.newline() + indentedStr;
+                            }
+                            output.push(result);
                         }
-                        if (colDefData.is_not_null) {
-                            parts.push('NOT NULL');
+                        else {
+                            const parts = [];
+                            if (colDefData.colname) {
+                                parts.push(quote_utils_1.QuoteUtils.quote(colDefData.colname));
+                            }
+                            if (colDefData.typeName) {
+                                parts.push(this.TypeName(colDefData.typeName, context));
+                            }
+                            if (colDefData.collClause) {
+                                parts.push(this.CollateClause(colDefData.collClause, context));
+                            }
+                            if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
+                                parts.push('OPTIONS');
+                                const columnContext = context.spawn('ColumnDef');
+                                const options = list_utils_1.ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
+                                parts.push(`(${options.join(', ')})`);
+                            }
+                            if (colDefData.constraints) {
+                                const constraints = list_utils_1.ListUtils.unwrapList(colDefData.constraints);
+                                const constraintStrs = constraints.map(constraint => {
+                                    const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
+                                    return this.visit(constraint, columnConstraintContext);
+                                });
+                                parts.push(...constraintStrs);
+                            }
+                            if (colDefData.raw_default) {
+                                parts.push('DEFAULT');
+                                parts.push(this.visit(colDefData.raw_default, context));
+                            }
+                            if (colDefData.is_not_null) {
+                                parts.push('NOT NULL');
+                            }
+                            output.push(parts.join(' '));
                         }
-                        output.push(parts.join(' '));
                     }
                     if (node.behavior === 'DROP_CASCADE') {
                         output.push('CASCADE');
@@ -4904,11 +4996,10 @@ class Deparser {
                     if (node.name) {
                         output.push(quote_utils_1.QuoteUtils.quote(node.name));
                     }
-                    output.push('ADD GENERATED');
+                    output.push('ADD');
                     if (node.def) {
                         output.push(this.visit(node.def, context));
                     }
-                    output.push('AS IDENTITY');
                     break;
                 case 'AT_SetIdentity':
                     output.push('ALTER COLUMN');

package/esm/deparser.js

@@ -2482,30 +2482,61 @@ export class Deparser {
                         .map(option => {
                         if (option.DefElem) {
                             const defElem = option.DefElem;
-                            const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
-                            if (defElem.defname === 'start') {
+                            if (defElem.defname === 'sequence_name') {
+                                if (defElem.arg && defElem.arg.List) {
+                                    const nameList = ListUtils.unwrapList(defElem.arg)
+                                        .map(item => this.visit(item, context))
+                                        .join('.');
+                                    return `SEQUENCE NAME ${nameList}`;
+                                }
+                                return 'SEQUENCE NAME';
+                            }
+                            else if (defElem.defname === 'start') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return `START WITH ${argValue}`;
                             }
                             else if (defElem.defname === 'increment') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return `INCREMENT BY ${argValue}`;
                             }
                             else if (defElem.defname === 'minvalue') {
-                                return `MINVALUE ${argValue}`;
+                                if (defElem.arg) {
+                                    const argValue = this.visit(defElem.arg, context);
+                                    return `MINVALUE ${argValue}`;
+                                }
+                                else {
+                                    return 'NO MINVALUE';
+                                }
                             }
                             else if (defElem.defname === 'maxvalue') {
-                                return `MAXVALUE ${argValue}`;
+                                if (defElem.arg) {
+                                    const argValue = this.visit(defElem.arg, context);
+                                    return `MAXVALUE ${argValue}`;
+                                }
+                                else {
+                                    return 'NO MAXVALUE';
+                                }
                             }
                             else if (defElem.defname === 'cache') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return `CACHE ${argValue}`;
                             }
                             else if (defElem.defname === 'cycle') {
+                                const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                                 return argValue === 'true' ? 'CYCLE' : 'NO CYCLE';
                             }
+                            const argValue = defElem.arg ? this.visit(defElem.arg, context) : '';
                             return `${defElem.defname.toUpperCase()} ${argValue}`;
                         }
                         return this.visit(option, context);
                     });
-                    output.push(`(${optionStrs.join(' ')})`);
+                    if (context.isPretty()) {
+                        const indentedOptions = optionStrs.map(option => context.indent(option));
+                        output.push('(\n' + indentedOptions.join('\n') + '\n)');
+                    }
+                    else {
+                        output.push(`(${optionStrs.join(' ')})`);
+                    }
                 }
                 break;
             case 'CONSTR_PRIMARY':
@@ -4324,10 +4355,7 @@ export class Deparser {
                 const commandsStr = commands
                     .map(cmd => {
                     const cmdStr = this.visit(cmd, alterContext);
-                    if (cmdStr.startsWith('ADD CONSTRAINT') || cmdStr.startsWith('ADD ')) {
-                        return context.newline() + context.indent(cmdStr);
-                    }
-                    return cmdStr;
+                    return context.newline() + context.indent(cmdStr);
                 })
                     .join(',');
                 output.push(commandsStr);
@@ -4357,35 +4385,99 @@ export class Deparser {
                     }
                     if (node.def) {
                         const colDefData = this.getNodeData(node.def);
-                        const parts = [];
-                        if (colDefData.colname) {
-                            parts.push(QuoteUtils.quote(colDefData.colname));
-                        }
-                        if (colDefData.typeName) {
-                            parts.push(this.TypeName(colDefData.typeName, context));
-                        }
-                        if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
-                            parts.push('OPTIONS');
-                            const columnContext = context.spawn('ColumnDef');
-                            const options = ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
-                            parts.push(`(${options.join(', ')})`);
-                        }
-                        if (colDefData.constraints) {
-                            const constraints = ListUtils.unwrapList(colDefData.constraints);
-                            const constraintStrs = constraints.map(constraint => {
-                                const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
-                                return this.visit(constraint, columnConstraintContext);
-                            });
-                            parts.push(...constraintStrs);
-                        }
-                        if (colDefData.raw_default) {
-                            parts.push('DEFAULT');
-                            parts.push(this.visit(colDefData.raw_default, context));
+                        if (context.isPretty()) {
+                            const parts = [];
+                            const indentedParts = [];
+                            if (colDefData.colname) {
+                                parts.push(QuoteUtils.quote(colDefData.colname));
+                            }
+                            if (colDefData.typeName) {
+                                parts.push(this.TypeName(colDefData.typeName, context));
+                            }
+                            if (colDefData.is_not_null) {
+                                indentedParts.push('NOT NULL');
+                            }
+                            if (colDefData.collClause) {
+                                indentedParts.push(this.CollateClause(colDefData.collClause, context));
+                            }
+                            if (colDefData.constraints) {
+                                const constraints = ListUtils.unwrapList(colDefData.constraints);
+                                constraints.forEach(constraint => {
+                                    const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
+                                    const constraintStr = this.visit(constraint, columnConstraintContext);
+                                    if (constraintStr.includes('REFERENCES') && constraintStr.includes('ON DELETE')) {
+                                        const refMatch = constraintStr.match(/^(.*REFERENCES[^)]*\([^)]*\))\s*(ON\s+DELETE\s+CASCADE.*)$/);
+                                        if (refMatch) {
+                                            indentedParts.push(refMatch[1]);
+                                            indentedParts.push(refMatch[2]);
+                                        }
+                                        else {
+                                            indentedParts.push(constraintStr);
+                                        }
+                                    }
+                                    else if (constraintStr === 'UNIQUE' && colDefData.raw_default) {
+                                        const defaultStr = 'DEFAULT ' + this.visit(colDefData.raw_default, context);
+                                        indentedParts.push('UNIQUE ' + defaultStr);
+                                    }
+                                    else {
+                                        indentedParts.push(constraintStr);
+                                    }
+                                });
+                            }
+                            if (colDefData.raw_default && !colDefData.constraints?.some((c) => {
+                                const constraintStr = this.visit(c, context.spawn('ColumnDef', { isColumnConstraint: true }));
+                                return constraintStr === 'UNIQUE';
+                            })) {
+                                const defaultStr = 'DEFAULT ' + this.visit(colDefData.raw_default, context);
+                                indentedParts.push(defaultStr);
+                            }
+                            if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
+                                indentedParts.push('OPTIONS');
+                                const columnContext = context.spawn('ColumnDef');
+                                const options = ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
+                                indentedParts.push(`(${options.join(', ')})`);
+                            }
+                            let result = parts.join(' ');
+                            if (indentedParts.length > 0) {
+                                const indentedStr = indentedParts.map(part => context.indent(part)).join(context.newline());
+                                result += context.newline() + indentedStr;
+                            }
+                            output.push(result);
                         }
-                        if (colDefData.is_not_null) {
-                            parts.push('NOT NULL');
+                        else {
+                            const parts = [];
+                            if (colDefData.colname) {
+                                parts.push(QuoteUtils.quote(colDefData.colname));
+                            }
+                            if (colDefData.typeName) {
+                                parts.push(this.TypeName(colDefData.typeName, context));
+                            }
+                            if (colDefData.collClause) {
+                                parts.push(this.CollateClause(colDefData.collClause, context));
+                            }
+                            if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
+                                parts.push('OPTIONS');
+                                const columnContext = context.spawn('ColumnDef');
+                                const options = ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
+                                parts.push(`(${options.join(', ')})`);
+                            }
+                            if (colDefData.constraints) {
+                                const constraints = ListUtils.unwrapList(colDefData.constraints);
+                                const constraintStrs = constraints.map(constraint => {
+                                    const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
+                                    return this.visit(constraint, columnConstraintContext);
+                                });
+                                parts.push(...constraintStrs);
+                            }
+                            if (colDefData.raw_default) {
+                                parts.push('DEFAULT');
+                                parts.push(this.visit(colDefData.raw_default, context));
+                            }
+                            if (colDefData.is_not_null) {
+                                parts.push('NOT NULL');
+                            }
+                            output.push(parts.join(' '));
                         }
-                        output.push(parts.join(' '));
                     }
                     if (node.behavior === 'DROP_CASCADE') {
                         output.push('CASCADE');
@@ -4901,11 +4993,10 @@ export class Deparser {
                     if (node.name) {
                         output.push(QuoteUtils.quote(node.name));
                     }
-                    output.push('ADD GENERATED');
+                    output.push('ADD');
                     if (node.def) {
                         output.push(this.visit(node.def, context));
                     }
-                    output.push('AS IDENTITY');
                     break;
                 case 'AT_SetIdentity':
                     output.push('ALTER COLUMN');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-deparser",
-  "version": "17.8.4",
+  "version": "17.9.0",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostgreSQL AST Deparser",
   "main": "index.js",
@@ -58,5 +58,5 @@
   "dependencies": {
     "@pgsql/types": "^17.6.1"
   },
-  "gitHead": "db3e424332bcb223c34a1caca3f37fb6fc9a1964"
+  "gitHead": "c2982c6793a8e92395a32e5d9d656b04e060466b"
 }