happy-sql 2.4.1 → 2.5.0

package/ChangeLog

@@ -1,3 +1,9 @@
+2026.11.15, v2.5.0
+
+feature:
+- 1c961c1 happy-sql: apply type checker
+- a4f7d90 happy-sql: where: keep parentheses in nested expressions
+
 2026.11.14, v2.4.1
 
 fix:

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

@@ -89,13 +89,22 @@ const convertCollate = (node) => callExpression(identifier('collate'), [
     convertOperand(node.right),
 ]);
 
-const convertIsNull = (node) => callExpression(identifier('isNull'), [
-    convertOperand(node.left),
-]);
+const isNullLiteral = ({type}) => type === 'null_literal';
 
-const convertIsNotNull = (node) => callExpression(identifier('isNotNull'), [
-    convertOperand(node.left),
-]);
+const createIs = (nullName, name) => (node) => {
+    if (isNullLiteral(node.right))
+        return callExpression(identifier(nullName), [
+            convertOperand(node.left),
+        ]);
+    
+    return callExpression(identifier(name), [
+        convertOperand(node.left),
+        convertOperand(node.right),
+    ]);
+};
+
+const convertIsNull = createIs('isNull', 'is');
+const convertIsNotNull = createIs('isNotNull', 'isNot');
 
 const convertIn = (node) => {
     const inner = node.right.expr;

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

@@ -1,7 +1,9 @@
 import {types} from '@putout/babel';
-import {convertBetween} from '#parser/clause/where';
+import {
+    convertCondition,
+    convertWhere,
+} from '#parser/clause/where';
 import {convertClause} from '#parser/clause';
-import {convertBinary} from '#parser/clause/binary';
 import {
     convertOperand,
     convertMemberExpr,
@@ -20,59 +22,13 @@ import {
 const {
     identifier,
     callExpression,
-    logicalExpression,
     stringLiteral,
     tsAsExpression,
     tsLiteralType,
 } = types;
 
-const isExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'EXISTS';
-const isNotExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'NOT' && isExists(node.expr);
 const isParenExpr = (node) => node.type === 'paren_expr';
 
-const POSTFIX_OP = {
-    ISNULL: 'isNull',
-    NOTNULL: 'isNotNull',
-};
-
-const convertPostfix = (node) => {
-    const {name} = node.operator;
-    const fn = POSTFIX_OP[name];
-    
-    return callExpression(identifier(fn), [
-        convertOperand(node.expr),
-    ]);
-};
-
-const convertCondition = (node) => {
-    if (node.operator && node.operator.name === 'AND')
-        return logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
-    
-    if (node.operator && node.operator.name === 'OR')
-        return logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
-    
-    if (node.type === 'between_expr')
-        return convertBetween(node);
-    
-    if (node.type === 'postfix_op_expr')
-        return convertPostfix(node);
-    
-    if (isNotExists(node))
-        return callExpression(identifier('notExists'), [
-            convertClause(node.expr.expr.expr),
-        ]);
-    
-    if (isExists(node))
-        return callExpression(identifier('exists'), [
-            convertClause(node.expr.expr),
-        ]);
-    
-    if (isParenExpr(node))
-        return convertCondition(node.expr);
-    
-    return convertBinary(node);
-};
-
 const convertOn = (spec) => callExpression(identifier('on'), [
     convertCondition(spec.expr),
 ]);
@@ -241,9 +197,7 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause, ord
     const fromArgs = [];
     
     if (whereClause)
-        fromArgs.push(callExpression(identifier('where'), [
-            convertCondition(whereClause.expr),
-        ]));
+        fromArgs.push(convertWhere(whereClause));
     
     if (groupByClause)
         fromArgs.push(convertGroupBy(groupByClause));

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

@@ -131,6 +131,16 @@ export const convertOperand = (node) => {
             convertClause(node.expr),
         ]);
     
+    if (node.type === 'paren_expr') {
+        const inner = convertOperand(node.expr);
+        
+        inner.extra = {
+            parenthesized: true,
+        };
+        
+        return inner;
+    }
+    
     if (node.type === 'parameter')
         return stringLiteral(node.text);
     

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

@@ -10,6 +10,7 @@ import {convertBinary} from '#parser/clause/binary';
 import {
     convertCondition,
     convertBetween,
+    convertWhere,
 } from '#parser/clause/where';
 import {findClause} from '#parser/clause/find';
 import {convertOrderBy} from '../from/order-by.js';
@@ -312,6 +313,9 @@ export const convertSelect = ({clauses}) => {
     ].filter(Boolean);
     
     if (!fromClause) {
+        if (whereClause)
+            args.push(convertWhere(whereClause));
+        
         if (limitClause)
             args.push(convertLimit(limitClause));
         

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

@@ -7,11 +7,22 @@ const {
     logicalExpression,
     identifier,
     callExpression,
+    isLogicalExpression,
 } = types;
 
 const convertAnd = (node) => logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
 const convertOr = (node) => logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
 
+const isNot = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'NOT';
+
+const keepParens = (node) => {
+    node.extra = {
+        parenthesized: true,
+    };
+    
+    return node;
+};
+
 const isNotBetween = (node) => Array.isArray(node.betweenKw) && node.betweenKw[0].name === 'NOT';
 
 export const convertBetween = (node) => {
@@ -68,12 +79,28 @@ export const convertCondition = (node) => {
             convertClause(node.expr.expr),
         ]);
     
-    if (isParenExpr(node))
-        return convertCondition(node.expr);
+    if (isNot(node) && isParenExpr(node.expr))
+        return callExpression(identifier('not'), [
+            convertCondition(node.expr.expr),
+        ]);
+    
+    if (isParenExpr(node)) {
+        const result = convertCondition(node.expr);
+        
+        if (isLogicalExpression(result))
+            return keepParens(result);
+        
+        return result;
+    }
     
     return convertBinary(node);
 };
 
+const stripParens = (node) => {
+    delete node.extra;
+    return node;
+};
+
 export const convertWhere = (node) => callExpression(identifier('where'), [
-    convertCondition(node.expr),
+    stripParens(convertCondition(node.expr)),
 ]);

package/lib/printer/visitors/binary-expression.js

@@ -1,3 +1,7 @@
+import {types} from '@putout/babel';
+
+const {isBinaryExpression} = types;
+
 const JS_TO_SQL_OP = {
     '===': '=',
     '!==': '!=',
@@ -7,11 +11,30 @@ const JS_TO_SQL_OP = {
     '<': '<',
 };
 
-export const BinaryExpression = (path, {write, traverse}) => {
-    traverse(path.get('left'));
+const ADDITIVE = ['+', '-'];
+const MULTIPLICATIVE = ['*', '/', '%'];
+
+const needsParens = (node, operator) => {
+    if (!isBinaryExpression(node))
+        return false;
+    
+    return MULTIPLICATIVE.includes(operator) && ADDITIVE.includes(node.operator);
+};
+
+const print = (path, operator, {write, traverse}) => {
+    if (!needsParens(path.node, operator))
+        return traverse(path);
     
-    const op = path.node.operator;
+    write('(');
+    traverse(path);
+    write(')');
+};
+
+export const BinaryExpression = (path, printer) => {
+    const {write} = printer;
+    const {operator} = path.node;
     
-    write(` ${JS_TO_SQL_OP[op] || op} `);
-    traverse(path.get('right'));
+    print(path.get('left'), operator, printer);
+    write(` ${JS_TO_SQL_OP[operator] || operator} `);
+    print(path.get('right'), operator, printer);
 };

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

@@ -138,10 +138,15 @@ import {lastInsertRowid} from './last-insert-rowid/last-insert-rowid.js';
 import {lastval} from './lastval/lastval.js';
 import {defaultNextval} from './default-nextval/default-nextval.js';
 import {like} from './like/like.js';
-import {isNull, isNotNull} from './is-null/is-null.js';
 import {orReplace} from './or-replace/or-replace.js';
 import {orIgnore} from './or-ignore/or-ignore.js';
 import {inList} from './in-list/in-list.js';
+import {
+    isNull,
+    isNotNull,
+    is,
+    isNot,
+} from './is-null/is-null.js';
 import {
     identity,
     identityByDefault,
@@ -315,6 +320,8 @@ export const clauses = {
     isDistinctFrom,
     collate,
     isNull,
+    is,
+    isNot,
     isNotNull,
     inList,
     identity,

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

@@ -1,4 +1,5 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '@putout/printer/type-checker';
 
 const {isCallExpression} = types;
 
@@ -6,7 +7,15 @@ const isConcurrently = (arg) => isCallExpression(arg.node) && arg.node.callee.na
 const isIfNotExists = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'ifNotExists';
 const isWhere = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'where';
 const isAccessMethod = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'accessMethod';
-const isCol = (arg) => !isConcurrently(arg) && !isIfNotExists(arg) && !isWhere(arg) && !isAccessMethod(arg);
+
+const isOption = createTypeChecker([
+    ['+: node.callee.name', '=', 'concurrently'],
+    ['+: node.callee.name', '=', 'ifNotExists'],
+    ['+: node.callee.name', '=', 'where'],
+    ['+: node.callee.name', '=', 'accessMethod'],
+]);
+
+const isCol = (arg) => !isOption(arg);
 
 export const printIndexBody = (path, {write, traverse}) => {
     const [name, table, ...rest] = path.get('arguments');

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

@@ -1,14 +1,12 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '@putout/printer/type-checker';
 
-const {
-    isTSAsExpression,
-    isCallExpression,
-} = types;
+const {isTSAsExpression} = types;
 
 const printAsExpression = (path, {write, traverse}) => {
     const expr = path.get('expression');
     
-    if (isTableFunc(expr.node))
+    if (isTableFunc(expr))
         printTableFunc(expr, {
             write,
             traverse,
@@ -16,7 +14,7 @@ const printAsExpression = (path, {write, traverse}) => {
     else
         traverse(expr);
     
-    if (isSubqueryAlias(path.node.expression))
+    if (isSubqueryAlias(expr))
         write(' ');
     else
         write(' AS ');
@@ -24,44 +22,52 @@ const printAsExpression = (path, {write, traverse}) => {
     write(path.node.typeAnnotation.literal.value);
 };
 
-const isSubqueryAlias = (node) => isCallExpression(node) && [
-    'subquery',
-    'lateralSubquery',
-].includes(node.callee.name);
+const isSubqueryAlias = createTypeChecker([
+    ['+: node.callee.name', '=', 'subquery'],
+    ['+: node.callee.name', '=', 'lateralSubquery'],
+]);
 
-const CLAUSE_NAMES = [
-    'where',
-    'groupBy',
-    'having',
-    'namedWindow',
-    'orderBy',
-    'limit',
-    'limitAll',
-    'offset',
-    'fetchFirst',
-    'forUpdate',
-];
+const isTableFunc = createTypeChecker([
+    ['-: node.callee.name', '=', 'where'],
+    ['-: node.callee.name', '=', 'groupBy'],
+    ['-: node.callee.name', '=', 'having'],
+    ['-: node.callee.name', '=', 'namedWindow'],
+    ['-: node.callee.name', '=', 'orderBy'],
+    ['-: node.callee.name', '=', 'limit'],
+    ['-: node.callee.name', '=', 'limitAll'],
+    ['-: node.callee.name', '=', 'offset'],
+    ['-: node.callee.name', '=', 'fetchFirst'],
+    ['-: node.callee.name', '=', 'forUpdate'],
+    ['-: node.callee.name', '=', 'join'],
+    ['-: node.callee.name', '=', 'leftJoin'],
+    ['-: node.callee.name', '=', 'rightJoin'],
+    ['-: node.callee.name', '=', 'rightOuterJoin'],
+    ['-: node.callee.name', '=', 'innerJoin'],
+    ['-: node.callee.name', '=', 'leftOuterJoin'],
+    ['-: node.callee.name', '=', 'fullOuterJoin'],
+    ['-: node.callee.name', '=', 'naturalJoin'],
+    ['-: node.callee.name', '=', 'crossJoin'],
+    ['-: node.callee.name', '=', 'on'],
+    ['-: node.callee.name', '=', 'subquery'],
+    ['-: node.callee.name', '=', 'lateralJoin'],
+    ['-: node.callee.name', '=', 'lateralSubquery'],
+    ['-: node.callee.name', '=', 'indexedBy'],
+    ['-: node.callee.name', '=', 'notIndexed'],
+    '+: node -> CallExpression',
+]);
 
-const TABLE_ARG_NAMES = [
-    ...CLAUSE_NAMES,
-    'join',
-    'leftJoin',
-    'rightJoin',
-    'rightOuterJoin',
-    'innerJoin',
-    'leftOuterJoin',
-    'fullOuterJoin',
-    'naturalJoin',
-    'crossJoin',
-    'on',
-    'subquery',
-    'lateralJoin',
-    'lateralSubquery',
-    'indexedBy',
-    'notIndexed',
-];
-
-const isClause = ({node}) => isCallExpression(node) && CLAUSE_NAMES.includes(node.callee.name);
+const isClause = createTypeChecker([
+    ['+: node.callee.name', '=', 'where'],
+    ['+: node.callee.name', '=', 'groupBy'],
+    ['+: node.callee.name', '=', 'having'],
+    ['+: node.callee.name', '=', 'namedWindow'],
+    ['+: node.callee.name', '=', 'orderBy'],
+    ['+: node.callee.name', '=', 'limit'],
+    ['+: node.callee.name', '=', 'limitAll'],
+    ['+: node.callee.name', '=', 'offset'],
+    ['+: node.callee.name', '=', 'fetchFirst'],
+    ['+: node.callee.name', '=', 'forUpdate'],
+]);
 
 const CAMEL_RE = /([A-Z])/g;
 const toSnake = (a) => a.replace(CAMEL_RE, (_, c) => `_${c.toLowerCase()}`);
@@ -76,8 +82,6 @@ const toFuncName = (name) => {
     return toSnake(name);
 };
 
-const isTableFunc = (node) => isCallExpression(node) && !TABLE_ARG_NAMES.includes(node.callee.name);
-
 const printTableFunc = (path, {write, traverse}) => {
     const {name} = path.node.callee;
     const args = path.get('arguments');
@@ -102,7 +106,7 @@ const printArg = (path, printer) => {
     if (isTSAsExpression(node))
         return printAsExpression(path, printer);
     
-    if (isTableFunc(node))
+    if (isTableFunc(path))
         return printTableFunc(path, printer);
     
     traverse(path);

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

@@ -9,3 +9,17 @@ export const isNotNull = (path, {write, traverse}) => {
     traverse(args[0]);
     write(' IS NOT NULL');
 };
+
+export const is = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    traverse(args[0]);
+    write(' IS ');
+    traverse(args[1]);
+};
+
+export const isNot = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    traverse(args[0]);
+    write(' IS NOT ');
+    traverse(args[1]);
+};

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

@@ -1,21 +1,17 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '@putout/printer/type-checker';
 
-const {
-    isTSAsExpression,
-    isCallExpression,
-} = types;
+const {isTSAsExpression} = types;
 
-const isSubqueryAlias = (node) => isCallExpression(node) && [
-    'subquery',
-    'lateralSubquery',
-].includes(node.callee.name);
+const isSubqueryAlias = createTypeChecker([
+    ['+: node.callee.name', '=', 'subquery'],
+    ['+: node.callee.name', '=', 'lateralSubquery'],
+]);
 
 const printAsExpression = (path, {write, traverse}) => {
-    const {expression} = path.node;
-    
     traverse(path.get('expression'));
     
-    if (isSubqueryAlias(expression))
+    if (isSubqueryAlias(path.get('expression')))
         write(' ');
     else
         write(' AS ');

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

@@ -1,4 +1,16 @@
+import {types} from '@putout/babel';
+
+const {isLogicalExpression} = types;
+
 export const not = (path, {write, traverse}) => {
+    const [arg] = path.get('arguments');
+    
     write('NOT ');
-    traverse(path.get('arguments')[0]);
+    
+    if (!isLogicalExpression(arg.node))
+        return traverse(arg);
+    
+    write('(');
+    traverse(arg);
+    write(')');
 };

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

@@ -29,12 +29,13 @@ const isFrom = createTypeChecker([
     ['+: node.callee.name', '=', 'from'],
 ]);
 
-const isClauseName = (path) => isCallExpression(path.node) && [
-    'limitAll',
-    'offset',
-    'fetchFirst',
-    'forUpdate',
-].includes(path.node.callee.name);
+const isClauseName = createTypeChecker([
+    ['+: node.callee.name', '=', 'limitAll'],
+    ['+: node.callee.name', '=', 'offset'],
+    ['+: node.callee.name', '=', 'fetchFirst'],
+    ['+: node.callee.name', '=', 'forUpdate'],
+    ['+: node.callee.name', '=', 'where'],
+]);
 
 const isDistinctOn = (path) => isCallExpression(path.node) && path.node.callee.name === 'distinctOn';
 

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

@@ -1,15 +1,11 @@
-import {types} from '@putout/babel';
+import {createTypeChecker} from '@putout/printer/type-checker';
 
-const {isCallExpression} = types;
-
-const OR_ACTION_NAMES = [
-    'orReplace',
-    'orIgnore',
-    'orAbort',
-    'orFail',
-];
-
-const isOrAction = (arg) => isCallExpression(arg.node) && OR_ACTION_NAMES.includes(arg.node.callee.name);
+const isOrAction = createTypeChecker([
+    ['+: node.callee.name', '=', 'orReplace'],
+    ['+: node.callee.name', '=', 'orIgnore'],
+    ['+: node.callee.name', '=', 'orAbort'],
+    ['+: node.callee.name', '=', 'orFail'],
+]);
 
 export const update = (path, {write, traverse}) => {
     const args = path.get('arguments');

package/lib/printer/visitors/logical-expression.js

@@ -1,6 +1,11 @@
 import {types} from '@putout/babel';
 
-const {isLogicalExpression} = types;
+const {
+    isLogicalExpression,
+    isCallExpression,
+} = types;
+
+const isInNot = ({parent}) => isCallExpression(parent) && parent.callee.name === 'not';
 const needsParensIn = (node, op) => op === '&&' && isLogicalExpression(node) && node.operator === '||';
 
 const printNestedOr = (node, printer) => {
@@ -18,7 +23,7 @@ export const LogicalExpression = (path, {write, traverse}) => {
     const left = path.get('left');
     const right = path.get('right');
     const hasNestedParen = needsParensIn(left.node, node.operator) || needsParensIn(right.node, node.operator);
-    const separator = hasNestedParen ? ` ${op} ` : `\n${op} `;
+    const separator = hasNestedParen || isInNot(path) ? ` ${op} ` : `\n${op} `;
     
     if (needsParensIn(left.node, node.operator))
         printNestedOr(left, {

package/lib/printer/visitors/string-literal.js

@@ -1,7 +1,21 @@
+import {createTypeChecker} from '@putout/printer/type-checker';
+
+const isValueContext = createTypeChecker([
+    '+: parent -> BinaryExpression',
+    [
+        '+: parent.callee.name',
+        '=',
+        'inList',
+    ],
+]);
+
 export const StringLiteral = (path, {write}) => {
     const {value} = path.node;
     
-    if (value === '*' || value.startsWith(':'))
+    if (value === '*' && !isValueContext(path))
+        return write(value);
+    
+    if (value.startsWith(':'))
         return write(value);
     
     // quoted identifier like "weird col" — written as is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-sql",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "type": "module",
   "description": "sql to js ast parser and printer",
   "exports": {