happy-sql 2.4.0 → 2.5.0

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/parser/visitors/clause/with-named/with-named.js

@@ -15,9 +15,23 @@ const convertTable = ({table, expr}) => {
     return assignmentExpression('=', identifier(table.name), convertClause(expr.expr));
 };
 
+const convertColumn = (column) => stringLiteral(column.name);
+
+const getColArgs = (columns) => {
+    if (!columns)
+        return [];
+    
+    const args = [];
+    
+    for (const col of columns.expr.items)
+        args.push(convertColumn(col));
+    
+    return args;
+};
+
 // recursive CTE: numbers('value', unionAll(...))
 const convertRecursiveTable = ({table, columns, expr}) => {
-    const colArgs = columns ? columns.expr.items.map((column) => stringLiteral(column.name)) : [];
+    const colArgs = getColArgs(columns);
     const body = convertClause(expr.expr);
     
     return callExpression(identifier(table.name), [...colArgs, body]);

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/add-constraint/add-constraint.js

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

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

@@ -108,6 +108,7 @@ import {withoutRowid} from './without-rowid/without-rowid.js';
 import {createTableAs} from './create-table-as/create-table-as.js';
 import {alterTable} from './alter-table/alter-table.js';
 import {addColumn} from './add-column/add-column.js';
+import {addConstraint} from './add-constraint/add-constraint.js';
 import {dropColumn} from './drop-column/drop-column.js';
 import {renameColumn} from './rename-column/rename-column.js';
 import {alterColumnType} from './alter-column-type/alter-column-type.js';
@@ -137,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,
@@ -278,6 +284,7 @@ export const clauses = {
     createTableAs,
     alterTable,
     addColumn,
+    addConstraint,
     dropColumn,
     renameColumn,
     alterColumnType,
@@ -313,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,53 +22,65 @@ 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()}`);
 
 // single-word ALL-CAPS functions (UNNEST) keep their casing
 const ALL_CAPS_RE = /^[A-Z]+$/;
-const toFuncName = (name) => ALL_CAPS_RE.test(name) ? name : toSnake(name);
 
-const isTableFunc = (node) => isCallExpression(node) && !TABLE_ARG_NAMES.includes(node.callee.name);
+const toFuncName = (name) => {
+    if (ALL_CAPS_RE.test(name))
+        return name;
+    
+    return toSnake(name);
+};
 
 const printTableFunc = (path, {write, traverse}) => {
     const {name} = path.node.callee;
@@ -96,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);
@@ -104,8 +114,15 @@ const printArg = (path, printer) => {
 
 export const from = (path, {write, traverse}) => {
     const args = path.get('arguments');
-    const tableArgs = args.filter((arg) => !isClause(arg));
-    const clauseArgs = args.filter(isClause);
+    const tableArgs = [];
+    const clauseArgs = [];
+    
+    for (const arg of args) {
+        if (isClause(arg))
+            clauseArgs.push(arg);
+        else
+            tableArgs.push(arg);
+    }
     
     write('FROM ');
     printArg(tableArgs[0], {

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

@@ -1,6 +1,9 @@
 import {types} from '@putout/babel';
 
-const {isTSAsExpression} = types;
+const {
+    isTSAsExpression,
+    isArrayExpression,
+} = types;
 
 const printTable = (table, {write, traverse}) => {
     if (isTSAsExpression(table.node)) {
@@ -36,7 +39,7 @@ export const into = (path, {write, traverse}) => {
     
     write(' (');
     
-    if (columns.node.type === 'ArrayExpression') {
+    if (isArrayExpression(columns.node)) {
         const colArgs = columns.get('elements');
         
         for (let i = 0; i < colArgs.length; i++) {

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/json-op.js

@@ -1,3 +1,10 @@
+import {types} from '@putout/babel';
+
+const {
+    isStringLiteral,
+    isArrayExpression,
+} = types;
+
 const JSON_OPS = new Set([
     '->',
     '->>',
@@ -11,7 +18,7 @@ const JSON_OPS = new Set([
     '<@',
 ]);
 
-export const isJsonTuple = (node) => node.type === 'ArrayExpression' && node.elements.length === 3 && node.elements[1].type === 'StringLiteral' && JSON_OPS.has(node.elements[1].value);
+export const isJsonTuple = (node) => isArrayExpression(node) && node.elements.length === 3 && isStringLiteral(node.elements[1]) && JSON_OPS.has(node.elements[1].value);
 
 export const printJsonTuple = (path, {write, traverse}) => {
     const elems = path.get('elements');

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/on-conflict/on-conflict.js

@@ -1,4 +1,11 @@
-const isWhereArg = ({node}) => node.type === 'CallExpression' && node.callee.name === 'where';
+import {types} from '@putout/babel';
+
+const {
+    isIdentifier,
+    isCallExpression,
+} = types;
+
+const isWhereArg = ({node}) => isCallExpression(node) && node.callee.name === 'where';
 
 export const onConflict = (path, {write, traverse}) => {
     const args = path.get('arguments');
@@ -34,7 +41,7 @@ export const onConflict = (path, {write, traverse}) => {
     
     write(' DO ');
     
-    if (action.node.type === 'Identifier' && action.node.name === 'nothing') {
+    if (isIdentifier(action.node) && action.node.name === 'nothing') {
         write('NOTHING');
         return;
     }

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

@@ -1,27 +1,39 @@
+const getCalleeName = (node) => {
+    if (!node || !node.callee)
+        return null;
+    
+    return node.callee.name;
+};
+
 export const references = (path, {write, traverse}) => {
     const [first, ...other] = path.get('arguments');
+    const cols = [];
+    const actions = [];
+    
+    for (const arg of other) {
+        const name = getCalleeName(arg.node);
+        
+        if (name === 'onDelete' || name === 'onUpdate')
+            actions.push(arg);
+        else
+            cols.push(arg);
+    }
     
     write('REFERENCES ');
     traverse(first);
     write('(');
     
-    let wroteCol = false;
-    
-    for (const arg of other) {
-        const name = arg.node?.callee?.name;
-        
-        if (name === 'onDelete' || name === 'onUpdate') {
-            write(' ');
-            traverse(arg);
-            continue;
-        }
-        
-        if (wroteCol)
+    for (const [i, col] of cols.entries()) {
+        if (i > 0)
             write(', ');
         
-        traverse(arg);
-        wroteCol = true;
+        traverse(col);
     }
     
     write(')');
+    
+    for (const action of actions) {
+        write(' ');
+        traverse(action);
+    }
 };

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

@@ -1,8 +1,12 @@
+import {types} from '@putout/babel';
+
+const {isArrayExpression} = types;
+
 export const section = (path, {write, traverse}) => {
     const [name, stmt] = path.get('arguments');
     write(`-- ${name.node.value}\n`);
     
-    if (stmt.node.type === 'ArrayExpression') {
+    if (isArrayExpression(stmt.node)) {
         const elements = stmt.get('elements');
         const lastIndex = elements.length - 1;
         

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/call-expression/clauses/window-frame/window-frame.js

@@ -10,7 +10,7 @@ export const rowsBetween = (path, {write, traverse}) => {
 export const preceding = (path, {write, traverse}) => {
     const [expr] = path.get('arguments');
     
-    if (expr?.node) {
+    if (expr && expr.node) {
         traverse(expr);
         write(' PRECEDING');
         
@@ -23,7 +23,7 @@ export const preceding = (path, {write, traverse}) => {
 export const following = (path, {write, traverse}) => {
     const [expr] = path.get('arguments');
     
-    if (expr?.node) {
+    if (expr && expr.node) {
         traverse(expr);
         write(' FOLLOWING');
         

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

@@ -1,4 +1,12 @@
-const needsParensIn = (node, op) => op === '&&' && node.type === 'LogicalExpression' && node.operator === '||';
+import {types} from '@putout/babel';
+
+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) => {
     const {write, traverse} = printer;
@@ -15,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