happy-sql 1.3.0 → 1.5.0

package/ChangeLog

@@ -1,3 +1,20 @@
+2026.08.15, v1.5.0
+
+fix:
+- b8aff13 printer: test
+
+feature:
+- 465fc93 join: add support
+
+2026.08.14, v1.4.0
+
+feature:
+- 1f764d9 extend support of sqlite and postgres
+- 3a39fbf with: improve
+- c7d966c with: add
+- bf17b06 parser/printer: RETURNING clause
+- d779866 parser/printer: multi-statement sections
+
 2026.07.29, v1.3.0
 
 feature:

package/lib/parser/fixture/comment-fix.js

@@ -0,0 +1,3 @@
+[
+    select('*', from(users)),
+];

package/lib/parser/fixture/comment.sql

@@ -0,0 +1,2 @@
+-- hello world
+SELECT * FROM users;

package/lib/parser/fixture/section-multi-fix.js

@@ -0,0 +1,6 @@
+[
+    section('@fix', [
+        update(Identifier, set(name === 'isNaN'), where(id === ':nan_id')),
+        update(BinaryExpression, set(operator === '==='), where(id === ':id')),
+    ]),
+];

package/lib/parser/fixture/section-multi.sql

@@ -0,0 +1,3 @@
+-- @fix
+UPDATE Identifier SET name = 'isNaN' WHERE id = :nan_id;
+UPDATE BinaryExpression SET operator = '===' WHERE id = :id;

package/lib/parser/fixture/with-named-fix.js

@@ -0,0 +1,11 @@
+[
+    withNamed(call = insert(into(
+        CallExpression,
+        parent_id,
+        values(':parent_id'),
+    ), returning(id)), member = insert(into(
+        MemberExpression,
+        parent_id,
+        select(id, from(call)),
+    ), returning(id)), insert(into(Identifier, [name, parent_id], select('x', id, from(member))))),
+];

package/lib/parser/fixture/with-named.sql

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

package/lib/parser/parser.js

@@ -1,4 +1,5 @@
-import {parse} from 'sql-parser-cst';
+import {tryCatch} from 'try-catch';
+import {parse as parseCst} from 'sql-parser-cst';
 import {types} from '@putout/babel';
 import {convertClause} from '#parser/clause';
 
@@ -12,42 +13,73 @@ const {
     program,
 } = types;
 
+const DIALECTS = [
+    'postgresql',
+    'sqlite',
+];
+
+const parseCstDialect = (source, dialect) => parseCst(source, {
+    dialect,
+    paramTypes: [':name'],
+    includeRange: true,
+    includeComments: true,
+});
+
+export const parseSqlNode = (source) => {
+    for (const dialect of DIALECTS) {
+        const [, cst] = tryCatch(parseCstDialect, source, dialect);
+        
+        if (cst)
+            return convertSource(cst);
+    }
+    
+    throw Error('Cannot parse SQL');
+};
+
 const getSectionName = (leading) => {
-    const comment = leading?.find((c) => c.text.startsWith('-- @'));
+    if (!leading)
+        return null;
+    
+    const comment = leading.find((c) => c.text.startsWith('-- @'));
     
     return comment ? comment.text
         .slice(2)
         .trim() : null;
 };
 
-const wrapSection = (stmtNode, sectionName) => {
-    if (!sectionName)
-        return stmtNode;
-    
-    return callExpression(identifier('section'), [
-        stringLiteral(sectionName),
-        stmtNode,
-    ]);
-};
-
-export const parseSqlNode = (source) => {
-    const cst = parse(source, {
-        dialect: 'sqlite',
-        paramTypes: [':name'],
-        includeRange: true,
-        includeComments: true,
-    });
-    
+const convertSource = (cst) => {
     const elements = [];
+    let currentSection = null;
+    const sectionGroups = new Map();
     
-    for (const [i, statement] of cst.statements.entries()) {
-        if (statement.type === 'empty')
+    for (const [i, stmt] of cst.statements.entries()) {
+        if (stmt.type === 'empty')
             continue;
         
-        const stmtNode = convertClause(statement);
-        const leading = i ? statement.leading : cst.leading;
+        const stmtNode = convertClause(stmt);
+        const leading = i ? stmt.leading : cst.leading;
+        const name = getSectionName(leading);
+        
+        if (name)
+            currentSection = name;
+        
+        if (currentSection) {
+            if (!sectionGroups.has(currentSection))
+                sectionGroups.set(currentSection, []);
+            
+            sectionGroups.get(currentSection).push(stmtNode);
+        } else {
+            elements.push(stmtNode);
+        }
+    }
+    
+    for (const [name, nodes] of sectionGroups) {
+        const inner = nodes.length === 1 ? nodes[0] : arrayExpression(nodes);
         
-        elements.push(wrapSection(stmtNode, getSectionName(leading)));
+        elements.push(callExpression(identifier('section'), [
+            stringLiteral(name),
+            inner,
+        ]));
     }
     
     return file(program([

package/lib/parser/visitors/clause/column-definition/column-definition.js

@@ -0,0 +1,41 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+const getDataType = (dataType) => {
+    if (dataType.type === 'identifier')
+        return dataType;
+    
+    return dataType.name;
+};
+
+const isSerial = (dataType) => getDataType(dataType).name === 'SERIAL';
+
+const convertConstraint = (constraint) => {
+    if (constraint.type === 'constraint_primary_key')
+        return callExpression(identifier('primaryKey'), []);
+    
+    return callExpression(identifier('autoIncrement'), []);
+};
+
+export const convertColumnDefinition = (column) => {
+    const {
+        name,
+        dataType,
+        constraints,
+    } = column;
+    
+    const args = [
+        identifier(name.name),
+    ];
+    
+    if (isSerial(dataType))
+        args.push(callExpression(identifier('serial'), []));
+    else
+        args.push(identifier(getDataType(dataType).text));
+    
+    for (const constraint of constraints)
+        args.push(convertConstraint(constraint));
+    
+    return callExpression(identifier('column'), args);
+};

package/lib/parser/visitors/clause/create-table/create-table.js

@@ -0,0 +1,17 @@
+import {types} from '@putout/babel';
+import {convertColumnDefinition} from '#parser/clause/column-definition';
+
+const {
+    identifier,
+    callExpression,
+    arrayExpression,
+} = types;
+
+export const convertCreateTable = ({name, columns}) => {
+    const colNodes = columns.expr.items.map(convertColumnDefinition);
+    
+    return callExpression(identifier('createTable'), [
+        identifier(name.name),
+        arrayExpression(colNodes),
+    ]);
+};

package/lib/parser/visitors/clause/create-table/fixture/create-table-autoincrement-fix.js

@@ -0,0 +1,5 @@
+[
+    createTable(t, [
+        column(id, INTEGER, primaryKey(), autoIncrement()),
+    ]),
+];

package/lib/parser/visitors/clause/create-table/fixture/create-table-autoincrement.sql

@@ -0,0 +1 @@
+CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT)

package/lib/parser/visitors/clause/create-table/fixture/create-table-serial-fix.js

@@ -0,0 +1,5 @@
+[
+    createTable(t, [
+        column(id, serial(), primaryKey()),
+    ]),
+];

package/lib/parser/visitors/clause/create-table/fixture/create-table-serial.sql

@@ -0,0 +1 @@
+CREATE TABLE t (id SERIAL PRIMARY KEY)

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

@@ -15,5 +15,5 @@ export const convertDelete = ({clauses}) => {
         whereClause && convertWhere(whereClause),
     ].filter(Boolean);
     
-    return callExpression(identifier('delete'), args);
+    return callExpression(identifier('deleteFrom'), args);
 };

package/lib/parser/visitors/clause/delete/fixture/delete-fix.js

@@ -1,3 +1,3 @@
 [
-    delete(from(t), where(id === ':id')),
+    deleteFrom(from(t), where(id === ':id')),
 ];

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

@@ -0,0 +1,6 @@
+[
+    select(bin.id, from(as(
+        BinaryExpression,
+        bin,
+    ), join(as(Identifier, nan_id), on(nan_id.parent_id === bin.id && nan_id.name === 'NaN')))),
+];

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

@@ -0,0 +1,6 @@
+[
+    select(bin.id, arg_id.name, from(as(
+        BinaryExpression,
+        bin,
+    ), join(as(Identifier, nan_id), on(nan_id.parent_id === bin.id)), join(as(Identifier, arg_id), on(arg_id.parent_id === bin.id)))),
+];

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

@@ -0,0 +1 @@
+SELECT bin.id, arg_id.name FROM BinaryExpression bin JOIN Identifier nan_id ON nan_id.parent_id = bin.id JOIN Identifier arg_id ON arg_id.parent_id = bin.id

package/lib/parser/visitors/clause/from/fixture/join.sql

@@ -0,0 +1 @@
+SELECT bin.id FROM BinaryExpression bin JOIN Identifier nan_id ON nan_id.parent_id = bin.id AND nan_id.name = 'NaN'

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

@@ -1,7 +1,83 @@
 import {types} from '@putout/babel';
 
-const {identifier, callExpression} = types;
+const {
+    identifier,
+    callExpression,
+    memberExpression,
+    binaryExpression,
+    logicalExpression,
+    stringLiteral,
+    numericLiteral,
+} = types;
 
-export const convertFrom = (node) => callExpression(identifier('from'), [
-    identifier(node.expr.name),
+const convertOperand = (node) => {
+    if (node.type === 'member_expr')
+        return memberExpression(identifier(node.object.name), identifier(node.property.name));
+    
+    if (node.type === 'parameter')
+        return stringLiteral(node.text);
+    
+    if (node.type === 'number_literal')
+        return numericLiteral(node.value);
+    
+    if (node.type === 'string_literal')
+        return stringLiteral(node.value);
+    
+    return identifier(node.name);
+};
+
+const convertCondition = (node) => {
+    if (node.operator?.name === 'AND')
+        return logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
+    
+    if (node.operator?.name === 'OR')
+        return logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
+    
+    return binaryExpression('===', convertOperand(node.left), convertOperand(node.right));
+};
+
+const convertOn = (spec) => callExpression(identifier('on'), [
+    convertCondition(spec.expr),
 ]);
+
+const convertAlias = (node) => {
+    if (node.type === 'alias')
+        return callExpression(identifier('as'), [
+            identifier(node.expr.name),
+            identifier(node.alias.name),
+        ]);
+    
+    return identifier(node.name);
+};
+
+const flattenJoins = (node, joins = []) => {
+    if (node.type === 'join_expr') {
+        flattenJoins(node.left, joins);
+        joins.push(callExpression(identifier('join'), [
+            convertAlias(node.right),
+            convertOn(node.specification),
+        ]));
+        
+        return joins;
+    }
+    
+    joins.unshift(convertAlias(node));
+    
+    return joins;
+};
+
+export const convertFrom = ({expr}) => {
+    if (expr.type === 'join_expr') {
+        const parts = flattenJoins(expr);
+        return callExpression(identifier('from'), parts);
+    }
+    
+    if (expr.type === 'alias')
+        return callExpression(identifier('from'), [
+            convertAlias(expr),
+        ]);
+    
+    return callExpression(identifier('from'), [
+        identifier(expr.name),
+    ]);
+};

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

@@ -2,6 +2,9 @@ import {convertSelect} from '#parser/clause/select';
 import {convertInsert} from '#parser/clause/insert';
 import {convertUpdate} from '#parser/clause/update';
 import {convertDelete} from '#parser/clause/delete';
+import {convertWithNamed} from '#parser/clause/with-named';
+import {convertCreateTable} from '#parser/clause/create-table';
+import {findClause} from '#parser/clause/find';
 
 export const convertClause = (stmt) => {
     const {type} = stmt;
@@ -13,9 +16,19 @@ export const convertClause = (stmt) => {
     throw Error(`${type} not supported yet`);
 };
 
+const convertInsertOrNamed = (stmt) => {
+    const {clauses} = stmt;
+    
+    if (findClause(clauses, 'with_clause'))
+        return convertWithNamed(stmt);
+    
+    return convertInsert(stmt);
+};
+
 const clauseVisitors = {
     select_stmt: convertSelect,
-    insert_stmt: convertInsert,
+    insert_stmt: convertInsertOrNamed,
     update_stmt: convertUpdate,
     delete_stmt: convertDelete,
+    create_table_stmt: convertCreateTable,
 };

package/lib/parser/visitors/clause/insert/fixture/insert-returning-conflict-fix.js

@@ -0,0 +1,3 @@
+[
+    insert(into(t, x, values(':x')), onConflict(x, set(y === ':y')), returning(id)),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-returning-conflict.sql

@@ -0,0 +1 @@
+INSERT INTO t (x) VALUES (:x) ON CONFLICT (x) DO UPDATE SET y = :y RETURNING id;

package/lib/parser/visitors/clause/insert/fixture/insert-returning-fix.js

@@ -0,0 +1,7 @@
+[
+    insert(into(
+        CallExpression,
+        parent_id,
+        values(':parent_id'),
+    ), returning(as(id, 'call_id'))),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-returning-id-fix.js

@@ -0,0 +1,7 @@
+[
+    insert(into(
+        CallExpression,
+        parent_id,
+        values(':parent_id'),
+    ), returning(id)),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-returning-id.sql

@@ -0,0 +1 @@
+INSERT INTO CallExpression (parent_id) VALUES (:parent_id) RETURNING id;

package/lib/parser/visitors/clause/insert/fixture/insert-returning.sql

@@ -0,0 +1 @@
+INSERT INTO CallExpression (parent_id) VALUES (:parent_id) RETURNING id AS call_id;

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

@@ -1,5 +1,6 @@
 import {types} from '@putout/babel';
 import {convertSet} from '#parser/clause/set';
+import {convertSelect} from '#parser/clause/select';
 import {findClause} from '#parser/clause/find';
 
 const {
@@ -12,6 +13,39 @@ const {
 const convertExprToIdentifier = ({expr}) => identifier(expr.name);
 const convertColToIdentifier = ({name}) => identifier(name);
 
+const convertReturningItem = (item) => {
+    if (item.type === 'alias') {
+        const {name} = item.expr;
+        const aliasName = item.alias.name;
+        
+        return callExpression(identifier('as'), [
+            identifier(name),
+            stringLiteral(aliasName),
+        ]);
+    }
+    
+    return identifier(item.name);
+};
+
+const convertReturning = (returningClause) => {
+    const args = returningClause.columns.items.map(convertReturningItem);
+    
+    return callExpression(identifier('returning'), args);
+};
+
+const convertSource = (vc) => {
+    if (vc.type === 'select_stmt')
+        return convertSelect(vc);
+    
+    const vals = vc.values.items[0].expr.items;
+    const valArgs = [];
+    
+    for (const p of vals)
+        valArgs.push(stringLiteral(p.text));
+    
+    return callExpression(identifier('values'), valArgs);
+};
+
 const convertUpsert = (upsertClause) => {
     const target = upsertClause.conflictTarget;
     const {action} = upsertClause;
@@ -26,23 +60,20 @@ export const convertInsert = ({clauses}) => {
     const [ic] = clauses;
     const [, vc] = clauses;
     const uc = findClause(clauses, 'upsert_clause');
+    const rc = findClause(clauses, 'returning_clause');
     
     const cols = ic.columns.expr.items;
-    const vals = vc.values.items[0].expr.items;
     const colArg = cols.length === 1 ? identifier(cols[0].name) : arrayExpression(cols.map(convertColToIdentifier));
-    const valArgs = [];
-    
-    for (const p of vals) {
-        valArgs.push(stringLiteral(p.text));
-    }
+    const source = convertSource(vc);
     
     const args = [
         callExpression(identifier('into'), [
             identifier(ic.table.name),
             colArg,
-            callExpression(identifier('values'), valArgs),
+            source,
         ]),
         uc && convertUpsert(uc),
+        rc && convertReturning(rc),
     ].filter(Boolean);
     
     return callExpression(identifier('insert'), args);

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

@@ -4,9 +4,13 @@ const {
     identifier,
     stringLiteral,
     numericLiteral,
+    memberExpression,
 } = types;
 
 export const convertOperand = (node) => {
+    if (node.type === 'member_expr')
+        return memberExpression(identifier(node.object.name), identifier(node.property.name));
+    
     if (node.type === 'parameter')
         return stringLiteral(node.text);
     

package/lib/parser/visitors/clause/select/fixture/select-last-insert-rowid-fix.js

@@ -0,0 +1,3 @@
+[
+    select(lastInsertRowid(), from(users)),
+];

package/lib/parser/visitors/clause/select/fixture/select-last-insert-rowid.sql

@@ -0,0 +1 @@
+SELECT last_insert_rowid() FROM users

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

@@ -0,0 +1,3 @@
+[
+    select(lastval(), from(users)),
+];

package/lib/parser/visitors/clause/select/fixture/select-lastval.sql

@@ -0,0 +1 @@
+SELECT LASTVAL() FROM users

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

@@ -10,21 +10,37 @@ const {
     stringLiteral,
     assignmentExpression,
     callExpression,
+    memberExpression,
 } = types;
 
 const convertColumn = (column) => {
     if (isCount(column))
         return convertCount(column);
     
+    if (column.type === 'func_call')
+        return convertFuncCall(column);
+    
     if (column.type === 'alias')
         return assignmentExpression('=', identifier(column.alias.name), convertOperand(column.expr));
     
     if (column.type === 'string_literal')
         return stringLiteral(column.value);
     
+    if (column.type === 'member_expr')
+        return memberExpression(identifier(column.object.name), identifier(column.property.name));
+    
     return identifier(column.name);
 };
 
+const convertFuncCall = (column) => {
+    const {name} = column.name;
+    
+    if (name === 'last_insert_rowid')
+        return callExpression(identifier('lastInsertRowid'), []);
+    
+    return callExpression(identifier('lastval'), []);
+};
+
 const convertColumns = (columns) => {
     if (columns.items.length === 1 && columns.items[0].type === 'all_columns')
         return [

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

@@ -1,30 +1,19 @@
 import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
 
 const {
-    binaryExpression,
     logicalExpression,
     identifier,
-    stringLiteral,
-    numericLiteral,
     callExpression,
 } = types;
 
-const convertOperand = (node) => {
-    if (node.type === 'parameter')
-        return stringLiteral(node.text);
-    
-    if (node.type === 'number_literal')
-        return numericLiteral(node.value);
-    
-    if (node.type === 'string_literal')
-        return stringLiteral(node.value);
-    
-    return identifier(node.name);
-};
-
 const convertAnd = (node) => logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
 const convertOr = (node) => logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
-const convertEq = (node) => binaryExpression('===', convertOperand(node.left), convertOperand(node.right));
+
+const convertEq = (node) => {
+    const {binaryExpression} = types;
+    return binaryExpression('===', convertOperand(node.left), convertOperand(node.right));
+};
 
 const convertCondition = (node) => {
     if (node.operator?.name === 'AND')

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

@@ -0,0 +1,31 @@
+import {types} from '@putout/babel';
+import {convertClause} from '#parser/clause';
+import {findClause} from '#parser/clause/find';
+
+const {
+    identifier,
+    assignmentExpression,
+    callExpression,
+} = types;
+
+const isWithClause = (clause) => clause.type !== 'with_clause';
+
+const convertTable = ({table, expr}) => {
+    return assignmentExpression('=', identifier(table.name), convertClause(expr.expr));
+};
+
+export const convertWithNamed = (stmt) => {
+    const withClause = findClause(stmt.clauses, 'with_clause');
+    
+    const finalStatement = convertClause({
+        ...stmt,
+        clauses: stmt.clauses.filter(isWithClause),
+    });
+    
+    const args = [
+        ...withClause.tables.items.map(convertTable),
+        finalStatement,
+    ];
+    
+    return callExpression(identifier('withNamed'), args);
+};

package/lib/printer/fixture/select.js

@@ -0,0 +1,3 @@
+[
+    select('*', from(users)),
+];