happy-sql 2.0.8 → 2.1.0

package/ChangeLog

@@ -1,3 +1,8 @@
+2026.08.22, v2.1.0
+
+feature:
+- 533076c parser: WITH RECURSIVE: add
+
 2026.08.21, v2.0.8
 
 fix:

package/lib/parser/visitors/clause/from/fixture/group-by-fix.js

@@ -0,0 +1,14 @@
+[
+    select(
+        kind,
+        count(
+            '*',
+        ),
+        from(
+            VariableDeclaration,
+            groupBy(
+                kind,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/from/fixture/group-by-having-fix.js

@@ -0,0 +1,22 @@
+[
+    select(
+        kind,
+        count(
+            '*',
+        ),
+        from(
+            VariableDeclaration,
+            where(
+                kind === 'const',
+            ),
+            groupBy(
+                kind,
+            ),
+            having(
+                count(
+                    '*',
+                ) > 1,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/from/fixture/group-by-having.sql

@@ -0,0 +1 @@
+SELECT kind, COUNT(*) FROM VariableDeclaration WHERE kind = 'const' GROUP BY kind HAVING COUNT(*) > 1

package/lib/parser/visitors/clause/from/fixture/group-by-multi-fix.js

@@ -0,0 +1,13 @@
+[
+    select(
+        kind,
+        name,
+        from(
+            VariableDeclaration,
+            groupBy(
+                kind,
+                name,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/from/fixture/group-by-multi.sql

@@ -0,0 +1 @@
+SELECT kind, name FROM VariableDeclaration GROUP BY kind, name

package/lib/parser/visitors/clause/from/fixture/group-by.sql

@@ -0,0 +1 @@
+SELECT kind, COUNT(*) FROM VariableDeclaration GROUP BY kind

package/lib/parser/visitors/clause/from/from.js

@@ -1,5 +1,7 @@
 import {types} from '@putout/babel';
 import {convertOperand} from '#parser/clause/operand';
+import {convertGroupBy} from './group-by.js';
+import {convertHaving} from './having.js';
 
 const isString = (a) => typeof a === 'string';
 
@@ -108,7 +110,7 @@ const flattenJoins = (node, joins = []) => {
     return joins;
 };
 
-export const convertFrom = ({expr, whereClause}) => {
+export const convertFrom = ({expr, whereClause, groupByClause, havingClause}) => {
     const fromArgs = [];
     
     if (whereClause)
@@ -116,6 +118,12 @@ export const convertFrom = ({expr, whereClause}) => {
             convertCondition(whereClause.expr),
         ]));
     
+    if (groupByClause)
+        fromArgs.push(convertGroupBy(groupByClause));
+    
+    if (havingClause)
+        fromArgs.push(convertHaving(havingClause));
+    
     if (expr.type === 'join_expr') {
         const parts = flattenJoins(expr);
         return callExpression(identifier('from'), parts);

package/lib/parser/visitors/clause/from/group-by.js

@@ -0,0 +1,6 @@
+import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
+
+const {callExpression, identifier} = types;
+
+export const convertGroupBy = (clause) => callExpression(identifier('groupBy'), clause.columns.items.map(convertOperand));

package/lib/parser/visitors/clause/from/having.js

@@ -0,0 +1,8 @@
+import {types} from '@putout/babel';
+import {convertCondition} from '#parser/clause/where';
+
+const {callExpression, identifier} = types;
+
+export const convertHaving = (clause) => callExpression(identifier('having'), [
+    convertCondition(clause.expr),
+]);

package/lib/parser/visitors/clause/index.js

@@ -5,6 +5,7 @@ import {convertDelete} from '#parser/clause/delete';
 import {convertWithNamed} from '#parser/clause/with-named';
 import {convertCreateTable} from '#parser/clause/create-table';
 import {convertCreateSequence} from '#parser/clause/create-sequence';
+import {convertUnionAll} from '#parser/clause/union';
 import {findClause} from '#parser/clause/find';
 
 export const convertClause = (stmt) => {
@@ -26,11 +27,21 @@ const convertInsertOrNamed = (stmt) => {
     return convertInsert(stmt);
 };
 
+const convertSelectOrNamed = (stmt) => {
+    const {clauses} = stmt;
+    
+    if (findClause(clauses, 'with_clause'))
+        return convertWithNamed(stmt);
+    
+    return convertSelect(stmt);
+};
+
 const clauseVisitors = {
-    select_stmt: convertSelect,
+    select_stmt: convertSelectOrNamed,
     insert_stmt: convertInsertOrNamed,
     update_stmt: convertUpdate,
     delete_stmt: convertDelete,
     create_table_stmt: convertCreateTable,
     create_sequence_stmt: convertCreateSequence,
+    compound_select_stmt: convertUnionAll,
 };

package/lib/parser/visitors/clause/operand.js

@@ -1,4 +1,5 @@
 import {types} from '@putout/babel';
+import {convertCount, isCount} from '#parser/clause/count';
 
 const {
     identifier,
@@ -10,6 +11,9 @@ const {
 } = types;
 
 export const convertOperand = (node) => {
+    if (isCount(node))
+        return convertCount(node);
+    
     if (node.type === 'member_expr')
         return memberExpression(identifier(node.object.name), identifier(node.property.name));
     

package/lib/parser/visitors/clause/select/select.js

@@ -11,6 +11,8 @@ const {
     tsLiteralType,
     callExpression,
     memberExpression,
+    numericLiteral,
+    binaryExpression,
 } = types;
 
 const convertColumn = (column) => {
@@ -32,6 +34,16 @@ const convertColumn = (column) => {
     if (column.type === 'parameter')
         return stringLiteral(column.text);
     
+    if (column.type === 'number_literal')
+        return numericLiteral(column.value);
+    
+    if (column.type === 'binary_expr')
+        return binaryExpression(
+            column.operator,
+            convertOperand(column.left),
+            convertOperand(column.right),
+        );
+    
     return identifier(column.name);
 };
 
@@ -57,12 +69,16 @@ export const convertSelect = ({clauses}) => {
     const selectClause = findClause(clauses, 'select_clause');
     const fromClause = findClause(clauses, 'from_clause');
     const whereClause = findClause(clauses, 'where_clause');
+    const groupByClause = findClause(clauses, 'group_by_clause');
+    const havingClause = findClause(clauses, 'having_clause');
     
     const args = [
         ...convertColumns(selectClause.columns),
         fromClause && convertFrom({
             expr: fromClause.expr,
             whereClause,
+            groupByClause,
+            havingClause,
         }),
     ].filter(Boolean);
     

package/lib/parser/visitors/clause/union/fixture/union-all-fix.js

@@ -0,0 +1,10 @@
+[
+    unionAll(
+        select(
+            1,
+        ),
+        select(
+            2,
+        ),
+    ),
+];

package/lib/parser/visitors/clause/union/fixture/union-all.sql

@@ -0,0 +1 @@
+SELECT 1 UNION ALL SELECT 2

package/lib/parser/visitors/clause/union/union.js

@@ -0,0 +1,11 @@
+import {types} from '@putout/babel';
+import {convertClause} from '#parser/clause';
+
+const {callExpression, identifier} = types;
+
+export const convertUnionAll = (stmt) => {
+    return callExpression(identifier('unionAll'), [
+        convertClause(stmt.left),
+        convertClause(stmt.right),
+    ]);
+};

package/lib/parser/visitors/clause/where/where.js

@@ -71,7 +71,7 @@ const convertBinary = (node) => {
     );
 };
 
-const convertCondition = (node) => {
+export const convertCondition = (node) => {
     if (node.operator?.name === 'AND')
         return convertAnd(node);
     

package/lib/parser/visitors/clause/with-named/fixture/with-named-select-fix.js

@@ -0,0 +1,19 @@
+[
+    withNamed(
+        recent = select(
+            id,
+            from(
+                users,
+                where(
+                    kind === 'const',
+                ),
+            ),
+        ),
+        select(
+            id,
+            from(
+                recent,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-named-select.sql

@@ -0,0 +1 @@
+WITH recent AS (SELECT id FROM users WHERE kind = 'const') SELECT id FROM recent

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-fix.js

@@ -0,0 +1,27 @@
+[
+    withRecursive(
+        numbers(
+            'value',
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    value + 1,
+                    from(
+                        numbers,
+                        where(
+                            value < 10,
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        select(
+            value,
+            from(
+                numbers,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-multi-fix.js

@@ -0,0 +1,38 @@
+[
+    withRecursive(
+        t(
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    2,
+                ),
+            ),
+        ),
+        u(
+            'a',
+            'b',
+            unionAll(
+                select(
+                    1,
+                    2,
+                ),
+                select(
+                    a,
+                    b,
+                    from(
+                        t,
+                    ),
+                ),
+            ),
+        ),
+        select(
+            a,
+            b,
+            from(
+                u,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-multi.sql

@@ -0,0 +1 @@
+WITH RECURSIVE t AS (SELECT 1 UNION ALL SELECT 2), u(a, b) AS (SELECT 1, 2 UNION ALL SELECT a, b FROM t) SELECT a, b FROM u

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-no-columns-fix.js

@@ -0,0 +1,20 @@
+[
+    withRecursive(
+        t(
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    2,
+                ),
+            ),
+        ),
+        select(
+            '*',
+            from(
+                t,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-no-columns.sql

@@ -0,0 +1 @@
+WITH RECURSIVE t AS (SELECT 1 UNION ALL SELECT 2) SELECT * FROM t

package/lib/parser/visitors/clause/with-named/fixture/with-recursive.sql

@@ -0,0 +1 @@
+WITH RECURSIVE numbers(value) AS (SELECT 1 UNION ALL SELECT value + 1 FROM numbers WHERE value < 10) SELECT value FROM numbers

package/lib/parser/visitors/clause/with-named/with-named.js

@@ -6,6 +6,7 @@ const {
     identifier,
     assignmentExpression,
     callExpression,
+    stringLiteral,
 } = types;
 
 const isWithClause = (clause) => clause.type !== 'with_clause';
@@ -14,18 +15,30 @@ const convertTable = ({table, expr}) => {
     return assignmentExpression('=', identifier(table.name), convertClause(expr.expr));
 };
 
+// recursive CTE: numbers('value', unionAll(...))
+const convertRecursiveTable = ({table, columns, expr}) => {
+    const colArgs = columns ? columns.expr.items.map((column) => stringLiteral(column.name)) : [];
+    const body = convertClause(expr.expr);
+    
+    return callExpression(identifier(table.name), [...colArgs, body]);
+};
+
 export const convertWithNamed = (stmt) => {
     const withClause = findClause(stmt.clauses, 'with_clause');
+    const isRecursive = Boolean(withClause.recursiveKw);
+    const fnName = isRecursive ? 'withRecursive' : 'withNamed';
     
     const finalStatement = convertClause({
         ...stmt,
         clauses: stmt.clauses.filter(isWithClause),
     });
     
+    const convertCte = isRecursive ? convertRecursiveTable : convertTable;
+    
     const args = [
-        ...withClause.tables.items.map(convertTable),
+        ...withClause.tables.items.map(convertCte),
         finalStatement,
     ];
     
-    return callExpression(identifier('withNamed'), args);
+    return callExpression(identifier(fnName), args);
 };

package/lib/printer/visitors/call-expression/clauses/clauses.js

@@ -14,6 +14,10 @@ import {section} from './section/section.js';
 import {count} from './count/count.js';
 import {returning} from './returning/returning.js';
 import {withNamed} from './with-named/with-named.js';
+import {withRecursive} from './with-recursive/with-recursive.js';
+import {unionAll} from './union-all/union-all.js';
+import {groupBy} from './group-by/group-by.js';
+import {having} from './having/having.js';
 import {createTable} from './create-table/create-table.js';
 import {createSequence} from './create-sequence/create-sequence.js';
 import {column} from './column/column.js';
@@ -48,6 +52,10 @@ export const clauses = {
     section,
     returning,
     withNamed,
+    withRecursive,
+    unionAll,
+    groupBy,
+    having,
     createTable,
     createSequence,
     column,

package/lib/printer/visitors/call-expression/clauses/from/fixture/group-by-having-fix.sql

@@ -0,0 +1,5 @@
+SELECT kind, COUNT(*)
+FROM VariableDeclaration
+WHERE kind = 'const'
+GROUP BY kind
+HAVING COUNT(*) > 1

package/lib/printer/visitors/call-expression/clauses/from/fixture/group-by-having.js

@@ -0,0 +1,22 @@
+[
+    select(
+        kind,
+        count(
+            '*',
+        ),
+        from(
+            VariableDeclaration,
+            where(
+                kind === 'const',
+            ),
+            groupBy(
+                kind,
+            ),
+            having(
+                count(
+                    '*',
+                ) > 1,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/from/from.js

@@ -7,6 +7,14 @@ const printAsExpression = (path, {write, traverse}) => {
     write(` AS ${path.node.typeAnnotation.literal.value}`);
 };
 
+const CLAUSE_NAMES = [
+    'where',
+    'groupBy',
+    'having',
+];
+
+const isClause = ({node}) => node.type === 'CallExpression' && CLAUSE_NAMES.includes(node.callee?.name);
+
 const printArg = (path, ctx) => {
     if (isTSAsExpression(path.node))
         return printAsExpression(path, ctx);
@@ -16,9 +24,8 @@ const printArg = (path, ctx) => {
 
 export const from = (path, {write, traverse}) => {
     const args = path.get('arguments');
-    const lastArg = args.at(-1);
-    const hasWhere = lastArg?.node?.callee?.name === 'where';
-    const tableArgs = hasWhere ? args.slice(0, -1) : args;
+    const tableArgs = args.filter((arg) => !isClause(arg));
+    const clauseArgs = args.filter(isClause);
     
     write('FROM ');
     printArg(tableArgs[0], {
@@ -32,8 +39,8 @@ export const from = (path, {write, traverse}) => {
             traverse,
         });
     
-    if (hasWhere) {
-        write.newline();
-        traverse(lastArg);
+    for (const clause of clauseArgs) {
+        write.breakline();
+        traverse(clause);
     }
 };

package/lib/printer/visitors/call-expression/clauses/group-by/fixture/group-by-fix.sql

@@ -0,0 +1,3 @@
+SELECT kind, COUNT(*)
+FROM VariableDeclaration
+GROUP BY kind

package/lib/printer/visitors/call-expression/clauses/group-by/fixture/group-by-multi-fix.sql

@@ -0,0 +1,3 @@
+SELECT kind, name
+FROM VariableDeclaration
+GROUP BY kind, name

package/lib/printer/visitors/call-expression/clauses/group-by/fixture/group-by-multi.js

@@ -0,0 +1,13 @@
+[
+    select(
+        kind,
+        name,
+        from(
+            VariableDeclaration,
+            groupBy(
+                kind,
+                name,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/group-by/fixture/group-by.js

@@ -0,0 +1,14 @@
+[
+    select(
+        kind,
+        count(
+            '*',
+        ),
+        from(
+            VariableDeclaration,
+            groupBy(
+                kind,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/group-by/group-by.js

@@ -0,0 +1,12 @@
+export const groupBy = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    write('GROUP BY ');
+    
+    for (const [i, arg] of args.entries()) {
+        if (i > 0)
+            write(', ');
+        
+        traverse(arg);
+    }
+};

package/lib/printer/visitors/call-expression/clauses/having/fixture/having-fix.sql

@@ -0,0 +1,3 @@
+SELECT kind, COUNT(*)
+FROM VariableDeclaration
+HAVING COUNT(*) > 1

package/lib/printer/visitors/call-expression/clauses/having/fixture/having.js

@@ -0,0 +1,16 @@
+[
+    select(
+        kind,
+        count(
+            '*',
+        ),
+        from(
+            VariableDeclaration,
+            having(
+                count(
+                    '*',
+                ) > 1,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/having/having.js

@@ -0,0 +1,4 @@
+export const having = (path, {write, traverse}) => {
+    write('HAVING ');
+    traverse(path.get('arguments')[0]);
+};

package/lib/printer/visitors/call-expression/clauses/insert/insert.js

@@ -6,7 +6,7 @@ export const insert = (path, {write, traverse}) => {
     traverse(intoArg);
     
     for (const arg of rest) {
-        write.newline();
+        write.breakline();
         traverse(arg);
     }
 };

package/lib/printer/visitors/call-expression/clauses/join/join.js

@@ -17,7 +17,7 @@ const printTable = (path, ctx) => {
 export const join = (path, {write, traverse}) => {
     const [table, onClause] = path.get('arguments');
     
-    write.newline();
+    write.breakline();
     write('JOIN ');
     printTable(table, {
         write,

package/lib/printer/visitors/call-expression/clauses/select/select.js

@@ -34,7 +34,7 @@ export const select = (path, {write, traverse}) => {
     }
     
     if (fromArg) {
-        write.newline();
+        write.breakline();
         traverse(fromArg);
     }
 };

package/lib/printer/visitors/call-expression/clauses/union-all/fixture/union-all-fix.sql

@@ -0,0 +1,3 @@
+SELECT 1
+UNION ALL
+SELECT 2

package/lib/printer/visitors/call-expression/clauses/union-all/fixture/union-all.js

@@ -0,0 +1 @@
+[unionAll(select(1), select(2))];

package/lib/printer/visitors/call-expression/clauses/union-all/union-all.js

@@ -0,0 +1,9 @@
+export const unionAll = (path, {write, traverse}) => {
+    const [left, right] = path.get('arguments');
+    
+    traverse(left);
+    write.breakline();
+    write('UNION ALL');
+    write.breakline();
+    traverse(right);
+};

package/lib/printer/visitors/call-expression/clauses/with-named/fixture/with-named-insert-fix.sql

@@ -1,12 +1,12 @@
 WITH
     call AS (
         INSERT INTO CallExpression (file, parent_id) VALUES (:file, :parent_id)
-RETURNING id
+        RETURNING id
     ),
     member AS (
         INSERT INTO MemberExpression (file, parent_id) SELECT :file, id
-FROM call
-RETURNING id
+        FROM call
+        RETURNING id
     )
 INSERT INTO Identifier (file, name, parent_id) SELECT :file, 'isNaN', id
 FROM member

package/lib/printer/visitors/call-expression/clauses/with-named/fixture/with-named-select-fix.sql

@@ -0,0 +1,8 @@
+WITH
+    recent AS (
+        SELECT id
+        FROM users
+        WHERE kind = 'const'
+    )
+SELECT id
+FROM recent

package/lib/printer/visitors/call-expression/clauses/with-named/fixture/with-named-select.js

@@ -0,0 +1,19 @@
+[
+    withNamed(
+        recent = select(
+            id,
+            from(
+                users,
+                where(
+                    kind === 'const',
+                ),
+            ),
+        ),
+        select(
+            id,
+            from(
+                recent,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/with-named/fixture/withNamed-fix.sql

@@ -1,12 +1,12 @@
 WITH
     call AS (
         INSERT INTO CallExpression (parent_id) VALUES (:parent_id)
-RETURNING id
+        RETURNING id
     ),
     member AS (
         INSERT INTO MemberExpression (parent_id) SELECT id
-FROM call
-RETURNING id
+        FROM call
+        RETURNING id
     )
 INSERT INTO Identifier (name, parent_id) SELECT 'x', id
 FROM member

package/lib/printer/visitors/call-expression/clauses/with-recursive/fixture/with-recursive-fix.sql

@@ -0,0 +1,10 @@
+WITH RECURSIVE
+    numbers(value) AS (
+        SELECT 1
+        UNION ALL
+        SELECT value + 1
+        FROM numbers
+        WHERE value < 10
+    )
+SELECT value
+FROM numbers

package/lib/printer/visitors/call-expression/clauses/with-recursive/fixture/with-recursive-multi-fix.sql

@@ -0,0 +1,14 @@
+WITH RECURSIVE
+    t AS (
+        SELECT 1
+        UNION ALL
+        SELECT 2
+    ),
+    u(a, b) AS (
+        SELECT 1, 2
+        UNION ALL
+        SELECT a, b
+        FROM t
+    )
+SELECT a, b
+FROM u

package/lib/printer/visitors/call-expression/clauses/with-recursive/fixture/with-recursive-multi.js

@@ -0,0 +1,38 @@
+[
+    withRecursive(
+        t(
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    2,
+                ),
+            ),
+        ),
+        u(
+            'a',
+            'b',
+            unionAll(
+                select(
+                    1,
+                    2,
+                ),
+                select(
+                    a,
+                    b,
+                    from(
+                        t,
+                    ),
+                ),
+            ),
+        ),
+        select(
+            a,
+            b,
+            from(
+                u,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/with-recursive/fixture/with-recursive-no-columns-fix.sql

@@ -0,0 +1,8 @@
+WITH RECURSIVE
+    t AS (
+        SELECT 1
+        UNION ALL
+        SELECT 2
+    )
+SELECT *
+FROM t

package/lib/printer/visitors/call-expression/clauses/with-recursive/fixture/with-recursive-no-columns.js

@@ -0,0 +1,20 @@
+[
+    withRecursive(
+        t(
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    2,
+                ),
+            ),
+        ),
+        select(
+            '*',
+            from(
+                t,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/with-recursive/fixture/with-recursive.js

@@ -0,0 +1,27 @@
+[
+    withRecursive(
+        numbers(
+            'value',
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    value + 1,
+                    from(
+                        numbers,
+                        where(
+                            value < 10,
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        select(
+            value,
+            from(
+                numbers,
+            ),
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/with-recursive/with-recursive.js

@@ -0,0 +1,57 @@
+const isStringLiteral = ({type}) => type === 'StringLiteral';
+
+export const withRecursive = (path, {write, indent, traverse}) => {
+    const args = path.get('arguments');
+    const ctes = args.slice(0, -1);
+    const finalStatement = args.at(-1);
+    
+    write('WITH RECURSIVE');
+    write.newline();
+    
+    const last = ctes.length - 1;
+    
+    for (const [i, cte] of ctes.entries()) {
+        const {name} = cte.node.callee;
+        const cteArgs = cte.get('arguments');
+        const colArgs = cteArgs.filter(isStringLiteral);
+        
+        indent.inc();
+        write.indent();
+        indent.dec();
+        write(name);
+        
+        if (colArgs.length) {
+            write('(');
+            
+            for (const [j, col] of colArgs.entries()) {
+                if (j > 0)
+                    write(', ');
+                
+                write(col.node.value);
+            }
+            
+            write(')');
+        }
+        
+        write(' AS (');
+        write.newline();
+        indent.inc();
+        indent.inc();
+        write.indent();
+        traverse(cteArgs.at(-1));
+        indent.dec();
+        indent.dec();
+        write.newline();
+        indent.inc();
+        write.indent();
+        indent.dec();
+        write(')');
+        
+        if (i < last)
+            write(',');
+        
+        write.newline();
+    }
+    
+    traverse(finalStatement);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-sql",
-  "version": "2.0.8",
+  "version": "2.1.0",
   "type": "module",
   "description": "sql to js ast parser and printer",
   "exports": {
@@ -25,6 +25,7 @@
     "#parser/clause/update": "./lib/parser/visitors/clause/update/update.js",
     "#parser/clause/delete": "./lib/parser/visitors/clause/delete/delete.js",
     "#parser/clause/with-named": "./lib/parser/visitors/clause/with-named/with-named.js",
+    "#parser/clause/union": "./lib/parser/visitors/clause/union/union.js",
     "#parser/clause/create-table": "./lib/parser/visitors/clause/create-table/create-table.js",
     "#parser/clause/create-sequence": "./lib/parser/visitors/clause/create-sequence/create-sequence.js",
     "#parser/clause/column-definition": "./lib/parser/visitors/clause/column-definition/column-definition.js",