pgsql-deparser 17.7.1 → 17.8.0

package/README.md

@@ -24,7 +24,7 @@ npm install pgsql-deparser
 
 ## Features
 
-* ⚡ **Pure TypeScript Performance** – Zero dependencies, no WASM, no compilation - just blazing fast SQL generation
+* ⚡ **Pure TypeScript Performance** – Zero runtime dependencies, no WASM, no compilation - just blazing fast SQL generation
 * 🪶 **Ultra Lightweight** – Minimal footprint with laser-focused functionality for AST-to-SQL conversion only
 * 🧪 **Battle-Tested Reliability** – Validated against 23,000+ SQL statements ensuring production-grade stability
 * 🌍 **Universal Compatibility** – Runs anywhere JavaScript does - browsers, Node.js, edge functions, you name it
@@ -69,6 +69,48 @@ console.log(deparse(stmt));
 // Output: SELECT * FROM another_table
 ```
 
+## Options
+
+The deparser accepts optional configuration for formatting and output control:
+
+```ts
+import { deparseSync as deparse } from 'pgsql-deparser';
+
+const options = {
+  pretty: true,           // Enable pretty formatting (default: false)
+  newline: '\n',         // Newline character (default: '\n')
+  tab: '  ',             // Tab/indentation character (default: '  ')
+  semicolons: true       // Add semicolons to statements (default: true)
+};
+
+const sql = deparse(ast, options);
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `pretty` | `boolean` | `false` | Enable pretty formatting with indentation and line breaks |
+| `newline` | `string` | `'\n'` | Character(s) used for line breaks |
+| `tab` | `string` | `'  '` | Character(s) used for indentation |
+| `semicolons` | `boolean` | `true` | Add semicolons to SQL statements |
+
+**Pretty formatting example:**
+```ts
+// Without pretty formatting
+const sql1 = deparse(selectAst, { pretty: false });
+// "SELECT id, name FROM users WHERE active = true;"
+
+// With pretty formatting  
+const sql2 = deparse(selectAst, { pretty: true });
+// SELECT
+//   id,
+//   name
+// FROM users
+// WHERE
+//   active = true;
+```
+
+For complete documentation and advanced options, see [DEPARSER_USAGE.md](../../DEPARSER_USAGE.md).
+
 ## Why Use `pgsql-deparser`?
 
 `pgsql-deparser` is particularly useful in development environments where native dependencies are problematic or in applications where only the deparser functionality is required. Its independence from the full `pgsql-parser` package allows for more focused and lightweight SQL generation tasks.
@@ -98,4 +140,4 @@ Built on the excellent work of several contributors:
 
 AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
 
-No developer or entity involved in creating Software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the Software code or Software CLI, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.
+No developer or entity involved in creating Software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the Software code or Software CLI, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

package/deparser.d.ts

@@ -6,6 +6,7 @@ export interface DeparserOptions {
     tab?: string;
     functionDelimiter?: string;
     functionDelimiterFallback?: string;
+    pretty?: boolean;
 }
 /**
  * Deparser - Converts PostgreSQL AST nodes back to SQL strings
@@ -294,4 +295,5 @@ export declare class Deparser implements DeparserVisitor {
     AlterObjectSchemaStmt(node: t.AlterObjectSchemaStmt, context: DeparserContext): string;
     AlterRoleSetStmt(node: t.AlterRoleSetStmt, context: DeparserContext): string;
     CreateForeignTableStmt(node: t.CreateForeignTableStmt, context: DeparserContext): string;
+    private containsMultilineStringLiteral;
 }

package/deparser.js

@@ -51,7 +51,7 @@ class Deparser {
     tree;
     options;
     constructor(tree, opts = {}) {
-        this.formatter = new sql_formatter_1.SqlFormatter(opts.newline, opts.tab);
+        this.formatter = new sql_formatter_1.SqlFormatter(opts.newline, opts.tab, opts.pretty);
         // Set default options
         this.options = {
             functionDelimiter: '$$',
@@ -184,7 +184,9 @@ class Deparser {
         }
         if (!node.op || node.op === 'SETOP_NONE') {
             if (node.valuesLists == null) {
-                output.push('SELECT');
+                if (!this.formatter.isPretty() || !node.targetList) {
+                    output.push('SELECT');
+                }
             }
         }
         else {
@@ -230,41 +232,82 @@ class Deparser {
                 output.push(rightStmt);
             }
         }
+        // Handle DISTINCT clause - in pretty mode, we'll include it in the SELECT clause
+        let distinctPart = '';
         if (node.distinctClause) {
             const distinctClause = list_utils_1.ListUtils.unwrapList(node.distinctClause);
             if (distinctClause.length > 0 && Object.keys(distinctClause[0]).length > 0) {
-                output.push('DISTINCT ON');
                 const clause = distinctClause
                     .map(e => this.visit(e, { ...context, select: true }))
                     .join(', ');
-                output.push(this.formatter.parens(clause));
+                distinctPart = ' DISTINCT ON ' + this.formatter.parens(clause);
             }
             else {
-                output.push('DISTINCT');
+                distinctPart = ' DISTINCT';
+            }
+            if (!this.formatter.isPretty()) {
+                if (distinctClause.length > 0 && Object.keys(distinctClause[0]).length > 0) {
+                    output.push('DISTINCT ON');
+                    const clause = distinctClause
+                        .map(e => this.visit(e, { ...context, select: true }))
+                        .join(', ');
+                    output.push(this.formatter.parens(clause));
+                }
+                else {
+                    output.push('DISTINCT');
+                }
             }
         }
         if (node.targetList) {
             const targetList = list_utils_1.ListUtils.unwrapList(node.targetList);
-            const targets = targetList
-                .map(e => this.visit(e, { ...context, select: true }))
-                .join(', ');
-            output.push(targets);
+            if (this.formatter.isPretty()) {
+                const targetStrings = targetList
+                    .map(e => {
+                    const targetStr = this.visit(e, { ...context, select: true });
+                    if (this.containsMultilineStringLiteral(targetStr)) {
+                        return targetStr;
+                    }
+                    return this.formatter.indent(targetStr);
+                });
+                const formattedTargets = targetStrings.join(',' + this.formatter.newline());
+                output.push('SELECT' + distinctPart);
+                output.push(formattedTargets);
+            }
+            else {
+                const targets = targetList
+                    .map(e => this.visit(e, { ...context, select: true }))
+                    .join(', ');
+                output.push(targets);
+            }
         }
         if (node.intoClause) {
             output.push('INTO');
             output.push(this.IntoClause(node.intoClause, context));
         }
         if (node.fromClause) {
-            output.push('FROM');
             const fromList = list_utils_1.ListUtils.unwrapList(node.fromClause);
             const fromItems = fromList
                 .map(e => this.deparse(e, { ...context, from: true }))
                 .join(', ');
-            output.push(fromItems);
+            output.push('FROM ' + fromItems.trim());
         }
         if (node.whereClause) {
-            output.push('WHERE');
-            output.push(this.visit(node.whereClause, context));
+            if (this.formatter.isPretty()) {
+                output.push('WHERE');
+                const whereExpr = this.visit(node.whereClause, context);
+                const lines = whereExpr.split(this.formatter.newline());
+                const indentedLines = lines.map((line, index) => {
+                    if (index === 0) {
+                        return this.formatter.indent(line);
+                    }
+                    return line;
+                });
+                output.push(indentedLines.join(this.formatter.newline()));
+            }
+            else {
+                output.push('WHERE');
+                output.push(this.visit(node.whereClause, context));
+            }
         }
         if (node.valuesLists) {
             output.push('VALUES');
@@ -275,16 +318,43 @@ class Deparser {
             output.push(lists.join(', '));
         }
         if (node.groupClause) {
-            output.push('GROUP BY');
             const groupList = list_utils_1.ListUtils.unwrapList(node.groupClause);
-            const groupItems = groupList
-                .map(e => this.visit(e, { ...context, group: true }))
-                .join(', ');
-            output.push(groupItems);
+            if (this.formatter.isPretty()) {
+                const groupItems = groupList
+                    .map(e => {
+                    const groupStr = this.visit(e, { ...context, group: true });
+                    if (this.containsMultilineStringLiteral(groupStr)) {
+                        return groupStr;
+                    }
+                    return this.formatter.indent(groupStr);
+                })
+                    .join(',' + this.formatter.newline());
+                output.push('GROUP BY');
+                output.push(groupItems);
+            }
+            else {
+                output.push('GROUP BY');
+                const groupItems = groupList
+                    .map(e => this.visit(e, { ...context, group: true }))
+                    .join(', ');
+                output.push(groupItems);
+            }
         }
         if (node.havingClause) {
-            output.push('HAVING');
-            output.push(this.visit(node.havingClause, context));
+            if (this.formatter.isPretty()) {
+                output.push('HAVING');
+                const havingStr = this.visit(node.havingClause, context);
+                if (this.containsMultilineStringLiteral(havingStr)) {
+                    output.push(havingStr);
+                }
+                else {
+                    output.push(this.formatter.indent(havingStr));
+                }
+            }
+            else {
+                output.push('HAVING');
+                output.push(this.visit(node.havingClause, context));
+            }
         }
         if (node.windowClause) {
             output.push('WINDOW');
@@ -295,20 +365,33 @@ class Deparser {
             output.push(windowClauses);
         }
         if (node.sortClause) {
-            output.push('ORDER BY');
             const sortList = list_utils_1.ListUtils.unwrapList(node.sortClause);
-            const sortItems = sortList
-                .map(e => this.visit(e, { ...context, sort: true }))
-                .join(', ');
-            output.push(sortItems);
+            if (this.formatter.isPretty()) {
+                const sortItems = sortList
+                    .map(e => {
+                    const sortStr = this.visit(e, { ...context, sort: true });
+                    if (this.containsMultilineStringLiteral(sortStr)) {
+                        return sortStr;
+                    }
+                    return this.formatter.indent(sortStr);
+                })
+                    .join(',' + this.formatter.newline());
+                output.push('ORDER BY');
+                output.push(sortItems);
+            }
+            else {
+                output.push('ORDER BY');
+                const sortItems = sortList
+                    .map(e => this.visit(e, { ...context, sort: true }))
+                    .join(', ');
+                output.push(sortItems);
+            }
         }
         if (node.limitCount) {
-            output.push('LIMIT');
-            output.push(this.visit(node.limitCount, context));
+            output.push('LIMIT ' + this.visit(node.limitCount, context));
         }
         if (node.limitOffset) {
-            output.push('OFFSET');
-            output.push(this.visit(node.limitOffset, context));
+            output.push('OFFSET ' + this.visit(node.limitOffset, context));
         }
         if (node.lockingClause) {
             const lockingList = list_utils_1.ListUtils.unwrapList(node.lockingClause);
@@ -317,6 +400,10 @@ class Deparser {
                 .join(' ');
             output.push(lockingClauses);
         }
+        if (this.formatter.isPretty()) {
+            const filteredOutput = output.filter(item => item.trim() !== '');
+            return filteredOutput.join(this.formatter.newline());
+        }
         return output.join(' ');
     }
     A_Expr(node, context) {
@@ -806,9 +893,23 @@ class Deparser {
         if (node.recursive) {
             output.push('RECURSIVE');
         }
-        const ctes = list_utils_1.ListUtils.unwrapList(node.ctes);
-        const cteStrs = ctes.map(cte => this.visit(cte, context));
-        output.push(cteStrs.join(', '));
+        if (node.ctes && node.ctes.length > 0) {
+            const ctes = list_utils_1.ListUtils.unwrapList(node.ctes);
+            if (this.formatter.isPretty()) {
+                const cteStrings = ctes.map(cte => {
+                    const cteStr = this.visit(cte, context);
+                    if (this.containsMultilineStringLiteral(cteStr)) {
+                        return this.formatter.newline() + cteStr;
+                    }
+                    return this.formatter.newline() + this.formatter.indent(cteStr);
+                });
+                output.push(cteStrings.join(','));
+            }
+            else {
+                const cteStrings = ctes.map(cte => this.visit(cte, context));
+                output.push(cteStrings.join(', '));
+            }
+        }
         return output.join(' ');
     }
     ResTarget(node, context) {
@@ -892,11 +993,23 @@ class Deparser {
         // return formatStr.replace('%s', () => andArgs); // ✅ Function callback prevents interpretation
         switch (boolop) {
             case 'AND_EXPR':
-                const andArgs = args.map(arg => this.visit(arg, boolContext)).join(' AND ');
-                return formatStr.replace('%s', () => andArgs);
+                if (this.formatter.isPretty() && args.length > 1) {
+                    const andArgs = args.map(arg => this.visit(arg, boolContext)).join(this.formatter.newline() + '  AND ');
+                    return formatStr.replace('%s', () => andArgs);
+                }
+                else {
+                    const andArgs = args.map(arg => this.visit(arg, boolContext)).join(' AND ');
+                    return formatStr.replace('%s', () => andArgs);
+                }
             case 'OR_EXPR':
-                const orArgs = args.map(arg => this.visit(arg, boolContext)).join(' OR ');
-                return formatStr.replace('%s', () => orArgs);
+                if (this.formatter.isPretty() && args.length > 1) {
+                    const orArgs = args.map(arg => this.visit(arg, boolContext)).join(this.formatter.newline() + '  OR ');
+                    return formatStr.replace('%s', () => orArgs);
+                }
+                else {
+                    const orArgs = args.map(arg => this.visit(arg, boolContext)).join(' OR ');
+                    return formatStr.replace('%s', () => orArgs);
+                }
             case 'NOT_EXPR':
                 return `NOT (${this.visit(args[0], context)})`;
             default:
@@ -1943,7 +2056,13 @@ class Deparser {
             const elementStrs = elements.map(el => {
                 return this.deparse(el, context);
             });
-            output.push(this.formatter.parens(elementStrs.join(', ')));
+            if (this.formatter.isPretty()) {
+                const formattedElements = elementStrs.map(el => this.formatter.indent(el)).join(',' + this.formatter.newline());
+                output.push('(' + this.formatter.newline() + formattedElements + this.formatter.newline() + ')');
+            }
+            else {
+                output.push(this.formatter.parens(elementStrs.join(', ')));
+            }
         }
         else if (!node.partbound) {
             output.push(this.formatter.parens(''));
@@ -2228,38 +2347,52 @@ class Deparser {
                     }
                 }
                 if (node.fk_upd_action && node.fk_upd_action !== 'a') {
-                    output.push('ON UPDATE');
+                    let updateClause = 'ON UPDATE ';
                     switch (node.fk_upd_action) {
                         case 'r':
-                            output.push('RESTRICT');
+                            updateClause += 'RESTRICT';
                             break;
                         case 'c':
-                            output.push('CASCADE');
+                            updateClause += 'CASCADE';
                             break;
                         case 'n':
-                            output.push('SET NULL');
+                            updateClause += 'SET NULL';
                             break;
                         case 'd':
-                            output.push('SET DEFAULT');
+                            updateClause += 'SET DEFAULT';
                             break;
                     }
+                    if (this.formatter.isPretty()) {
+                        output.push('\n' + this.formatter.indent(updateClause));
+                    }
+                    else {
+                        output.push('ON UPDATE');
+                        output.push(updateClause.replace('ON UPDATE ', ''));
+                    }
                 }
                 if (node.fk_del_action && node.fk_del_action !== 'a') {
-                    output.push('ON DELETE');
+                    let deleteClause = 'ON DELETE ';
                     switch (node.fk_del_action) {
                         case 'r':
-                            output.push('RESTRICT');
+                            deleteClause += 'RESTRICT';
                             break;
                         case 'c':
-                            output.push('CASCADE');
+                            deleteClause += 'CASCADE';
                             break;
                         case 'n':
-                            output.push('SET NULL');
+                            deleteClause += 'SET NULL';
                             break;
                         case 'd':
-                            output.push('SET DEFAULT');
+                            deleteClause += 'SET DEFAULT';
                             break;
                     }
+                    if (this.formatter.isPretty()) {
+                        output.push('\n' + this.formatter.indent(deleteClause));
+                    }
+                    else {
+                        output.push('ON DELETE');
+                        output.push(deleteClause.replace('ON DELETE ', ''));
+                    }
                 }
                 // Handle NOT VALID for foreign key constraints - only for table constraints, not domain constraints
                 if (node.skip_validation && !context.isDomainConstraint) {
@@ -2317,17 +2450,48 @@ class Deparser {
         // Handle deferrable constraints for all constraint types that support it
         if (node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_FOREIGN') {
             if (node.deferrable) {
-                output.push('DEFERRABLE');
-                if (node.initdeferred === true) {
-                    output.push('INITIALLY DEFERRED');
+                if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
+                    output.push('\n' + this.formatter.indent('DEFERRABLE'));
+                    if (node.initdeferred === true) {
+                        output.push('\n' + this.formatter.indent('INITIALLY DEFERRED'));
+                    }
+                    else if (node.initdeferred === false) {
+                        output.push('\n' + this.formatter.indent('INITIALLY IMMEDIATE'));
+                    }
                 }
-                else if (node.initdeferred === false) {
-                    output.push('INITIALLY IMMEDIATE');
+                else {
+                    output.push('DEFERRABLE');
+                    if (node.initdeferred === true) {
+                        output.push('INITIALLY DEFERRED');
+                    }
+                    else if (node.initdeferred === false) {
+                        output.push('INITIALLY IMMEDIATE');
+                    }
                 }
             }
             else if (node.deferrable === false) {
-                output.push('NOT DEFERRABLE');
+                if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
+                    output.push('\n' + this.formatter.indent('NOT DEFERRABLE'));
+                }
+                else {
+                    output.push('NOT DEFERRABLE');
+                }
+            }
+        }
+        if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
+            let result = '';
+            for (let i = 0; i < output.length; i++) {
+                if (output[i].startsWith('\n')) {
+                    result += output[i];
+                }
+                else {
+                    if (i > 0 && !output[i - 1].startsWith('\n')) {
+                        result += ' ';
+                    }
+                    result += output[i];
+                }
             }
+            return result;
         }
         return output.join(' ');
     }
@@ -3051,11 +3215,9 @@ class Deparser {
         }
         switch (node.jointype) {
             case 'JOIN_INNER':
-                // Handle NATURAL JOIN first - it has isNatural=true (NATURAL already added above)
                 if (node.isNatural) {
                     joinStr += 'JOIN';
                 }
-                // Handle CROSS JOIN case - when there's no quals, no usingClause, and not natural
                 else if (!node.quals && (!node.usingClause || node.usingClause.length === 0)) {
                     joinStr += 'CROSS JOIN';
                 }
@@ -3075,26 +3237,51 @@ class Deparser {
             default:
                 joinStr += 'JOIN';
         }
-        output.push(joinStr);
         if (node.rarg) {
             let rargStr = this.visit(node.rarg, context);
             if (node.rarg && 'JoinExpr' in node.rarg && !node.rarg.JoinExpr.alias) {
                 rargStr = `(${rargStr})`;
             }
-            output.push(rargStr);
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + joinStr + ' ' + rargStr);
+            }
+            else {
+                output.push(joinStr + ' ' + rargStr);
+            }
+        }
+        else {
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + joinStr);
+            }
+            else {
+                output.push(joinStr);
+            }
         }
         if (node.usingClause && node.usingClause.length > 0) {
-            output.push('USING');
             const usingList = list_utils_1.ListUtils.unwrapList(node.usingClause);
             const columnNames = usingList.map(col => this.visit(col, context));
-            output.push(`(${columnNames.join(', ')})`);
+            if (this.formatter.isPretty()) {
+                output.push(` USING (${columnNames.join(', ')})`);
+            }
+            else {
+                output.push(`USING (${columnNames.join(', ')})`);
+            }
         }
         else if (node.quals) {
-            output.push('ON');
-            output.push(this.visit(node.quals, context));
+            if (this.formatter.isPretty()) {
+                output.push(` ON ${this.visit(node.quals, context)}`);
+            }
+            else {
+                output.push(`ON ${this.visit(node.quals, context)}`);
+            }
+        }
+        let result;
+        if (this.formatter.isPretty()) {
+            result = output.join('');
+        }
+        else {
+            result = output.join(' ');
         }
-        let result = output.join(' ');
-        // Handle join_using_alias first (for USING clause aliases like "AS x")
         if (node.join_using_alias && node.join_using_alias.aliasname) {
             let aliasStr = node.join_using_alias.aliasname;
             if (node.join_using_alias.colnames && node.join_using_alias.colnames.length > 0) {
@@ -3104,7 +3291,6 @@ class Deparser {
             }
             result += ` AS ${aliasStr}`;
         }
-        // Handle regular alias (for outer table aliases like "y")
         if (node.alias && node.alias.aliasname) {
             let aliasStr = node.alias.aliasname;
             if (node.alias.colnames && node.alias.colnames.length > 0) {
@@ -5823,38 +6009,82 @@ class Deparser {
         return output.join(' ');
     }
     CreatePolicyStmt(node, context) {
-        const output = ['CREATE', 'POLICY'];
+        const output = [];
+        const initialParts = ['CREATE', 'POLICY'];
         if (node.policy_name) {
-            output.push(`"${node.policy_name}"`);
+            initialParts.push(`"${node.policy_name}"`);
         }
-        output.push('ON');
+        output.push(initialParts.join(' '));
+        // Add ON clause on new line in pretty mode
         if (node.table) {
-            output.push(this.RangeVar(node.table, context));
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + this.formatter.indent(`ON ${this.RangeVar(node.table, context)}`));
+            }
+            else {
+                output.push('ON');
+                output.push(this.RangeVar(node.table, context));
+            }
         }
         // Handle AS RESTRICTIVE/PERMISSIVE clause
         if (node.permissive === undefined) {
-            output.push('AS', 'RESTRICTIVE');
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + this.formatter.indent('AS RESTRICTIVE'));
+            }
+            else {
+                output.push('AS', 'RESTRICTIVE');
+            }
         }
         else if (node.permissive === true) {
-            output.push('AS', 'PERMISSIVE');
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + this.formatter.indent('AS PERMISSIVE'));
+            }
+            else {
+                output.push('AS', 'PERMISSIVE');
+            }
         }
         if (node.cmd_name) {
-            output.push('FOR', node.cmd_name.toUpperCase());
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + this.formatter.indent(`FOR ${node.cmd_name.toUpperCase()}`));
+            }
+            else {
+                output.push('FOR', node.cmd_name.toUpperCase());
+            }
         }
         if (node.roles && node.roles.length > 0) {
-            output.push('TO');
             const roles = list_utils_1.ListUtils.unwrapList(node.roles).map(role => this.visit(role, context));
-            output.push(roles.join(', '));
+            if (this.formatter.isPretty()) {
+                output.push(this.formatter.newline() + this.formatter.indent(`TO ${roles.join(', ')}`));
+            }
+            else {
+                output.push('TO');
+                output.push(roles.join(', '));
+            }
         }
         if (node.qual) {
-            output.push('USING');
-            output.push(`(${this.visit(node.qual, context)})`);
+            if (this.formatter.isPretty()) {
+                const qualExpr = this.visit(node.qual, context);
+                output.push(this.formatter.newline() + this.formatter.indent('USING ('));
+                output.push(this.formatter.newline() + this.formatter.indent(this.formatter.indent(qualExpr)));
+                output.push(this.formatter.newline() + this.formatter.indent(')'));
+            }
+            else {
+                output.push('USING');
+                output.push(`(${this.visit(node.qual, context)})`);
+            }
         }
         if (node.with_check) {
-            output.push('WITH CHECK');
-            output.push(`(${this.visit(node.with_check, context)})`);
+            if (this.formatter.isPretty()) {
+                const checkExpr = this.visit(node.with_check, context);
+                output.push(this.formatter.newline() + this.formatter.indent('WITH CHECK ('));
+                output.push(this.formatter.newline() + this.formatter.indent(this.formatter.indent(checkExpr)));
+                output.push(this.formatter.newline() + this.formatter.indent(')'));
+            }
+            else {
+                output.push('WITH CHECK');
+                output.push(`(${this.visit(node.with_check, context)})`);
+            }
         }
-        return output.join(' ');
+        return this.formatter.isPretty() ? output.join('') : output.join(' ');
     }
     AlterPolicyStmt(node, context) {
         const output = ['ALTER', 'POLICY'];
@@ -9720,5 +9950,9 @@ class Deparser {
         }
         return output.join(' ');
     }
+    containsMultilineStringLiteral(content) {
+        const stringLiteralRegex = /'[^']*\n[^']*'/g;
+        return stringLiteralRegex.test(content);
+    }
 }
 exports.Deparser = Deparser;