happy-sql 2.4.0 → 2.4.1

package/ChangeLog

@@ -1,3 +1,31 @@
+2026.11.14, v2.4.1
+
+fix:
+- 10d5818 happy-sql: join
+- 7510903 alter-table: rename table, add constraint, RLS actions
+- a4e14a1 references: ON DELETE and ON UPDATE actions
+- 60cbd74 from: extract capitalizeWord, remove inlined arrow
+- 3ebbea9 with-named: extract convertColumn, remove inlined arrow
+- 8848396 printer/from: remove inlined arrows and ternary
+- 0cc326c window-frame: remove optional chaining
+- 652387a references: remove optional chaining
+- 344f7c3 clause/index: remove optional chaining, nullish coalescing, inlined arrows
+- 313fa5f binary: remove optional chaining and nullish coalescing
+- 12b6f3c insert: remove optional chaining and inlined arrows/ternaries
+- 652bcad create-index: remove optional chaining
+- b5b40ac limit: remove optional chaining
+- 5eb1732 create-table: remove optional chaining and inlined arrows
+- f078532 create-view: extract isMaterializedKind predicate
+- 472e627 order-by: extract nulls order fn name
+- ddcb389 group-by: remove inlined arrow in map
+- 1be75b4 table-func: extract getRawName, remove inlined ternary
+- 10a0b35 column-definition: remove optional chaining, nullish coalescing, inlined arrows
+- 9108d3e operand: remove optional chaining and nullish coalescing
+
+feature:
+- ffaef07 happy-sql: sql-parser-cst v0.44.1
+- 981cf13 happy-sql: @putout/plugin-printer v9.0.0
+
 2026.08.27, v2.4.0
 
 fix:

package/lib/parser/parser.js

@@ -18,19 +18,17 @@ const DIALECTS = [
     'sqlite',
 ];
 
-const parseCstDialect = (source, dialect) => parseCst(source, {
-    dialect,
-    paramTypes: [':name'],
-    includeRange: true,
-    includeComments: true,
-});
-
 export const parseSql = (source) => {
     let cst;
     let error;
     
     for (const dialect of DIALECTS) {
-        [error, cst] = tryCatch(parseCstDialect, source, dialect);
+        [error, cst] = tryCatch(parseCst, source, {
+            dialect,
+            paramTypes: [':name'],
+            includeRange: true,
+            includeComments: true,
+        });
         
         if (cst)
             return convertSource(cst);
@@ -47,9 +45,11 @@ const getSectionName = (leading) => {
     
     const comment = leading.find(isComment);
     
-    return comment ? comment.text
-        .slice(2)
-        .trim() : null;
+    return comment
+        ? comment.text
+            .slice(2)
+            .trim()
+        : null;
 };
 
 const convertSource = (cst) => {

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

@@ -14,14 +14,17 @@ const convertRenameTable = (action) => callExpression(identifier('renameTable'),
 
 const convertAddConstraint = ({name, constraint}) => {
     const node = convertTableConstraint(constraint);
+    const args = [];
     
-    if (!name)
-        return node;
+    if (name)
+        args.push(callExpression(identifier('constraint'), [
+            identifier(name.name.name),
+            node,
+        ]));
+    else
+        args.push(node);
     
-    return callExpression(identifier('constraint'), [
-        identifier(name.name.name),
-        node,
-    ]);
+    return callExpression(identifier('addConstraint'), args);
 };
 
 const convertDropColumn = (action) => callExpression(identifier('dropColumn'), [

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

@@ -31,7 +31,7 @@ export const opName = (op) => {
     return op.name;
 };
 
-const isEscape = (node) => node?.type === 'binary_expr' && opName(node.operator) === 'ESCAPE';
+const isEscape = (node) => node && node.type === 'binary_expr' && opName(node.operator) === 'ESCAPE';
 
 const convertLike = (node) => {
     const args = [
@@ -172,7 +172,7 @@ export const convertBinary = (node) => {
     if (convert)
         return convert(node);
     
-    const jsOp = SQL_TO_JS_OP[op] ?? '===';
+    const jsOp = SQL_TO_JS_OP[op] || '===';
     
     return binaryExpression(
         jsOp,

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

@@ -31,16 +31,18 @@ const convertGenerated = (constraint) => {
     return callExpression(identifier('identity'), []);
 };
 
-const isGeneratedExpr = ({expr}) => expr?.type === 'paren_expr';
+const isGeneratedExpr = ({expr}) => expr && expr.type === 'paren_expr';
+
+const isStored = (constraint) => Boolean(constraint.storageKw) && constraint.storageKw.name === 'STORED';
 
 const convertGeneratedExpr = (constraint) => callExpression(identifier('generatedAlwaysAs'), [
     convertBinary(constraint.expr.expr),
-    booleanLiteral(constraint.storageKw?.name === 'STORED'),
+    booleanLiteral(isStored(constraint)),
 ]);
 
 const convertDefaultNextval = (expr) => {
     const [seq] = expr.args.expr.args.items;
-    const seqName = seq.value ?? seq.name;
+    const seqName = seq.value || seq.name;
     
     return callExpression(identifier('defaultNextval'), [
         identifier(seqName),
@@ -87,15 +89,26 @@ const ACTION_NAMES = {
     SET_DEFAULT: true,
 };
 
-const convertReferentialAction = ({eventKw, actionKw}) => {
-    const event = eventKw.name === 'DELETE' ? 'onDelete' : 'onUpdate';
-    const action = Array.isArray(actionKw) ? actionKw
-        .map(({name}) => name)
-        .join(' ') : actionKw.name;
+const getActionName = (kw) => kw.name;
+
+const normalizeAction = (a) => {
+    if (ACTION_NAMES[a])
+        return a;
     
-    const name = ACTION_NAMES[action] ? action : action
+    return a
         .replace(/\s+/g, '_')
         .toUpperCase();
+};
+
+const convertReferentialAction = ({eventKw, actionKw}) => {
+    const event = eventKw.name === 'DELETE' ? 'onDelete' : 'onUpdate';
+    const action = Array.isArray(actionKw)
+        ? actionKw
+            .map(getActionName)
+            .join(' ')
+        : actionKw.name;
+    
+    const name = normalizeAction(action);
     
     return callExpression(identifier(event), [
         identifier(name),

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

@@ -4,7 +4,7 @@ import {findClause} from '#parser/clause/find';
 
 const {identifier, callExpression} = types;
 
-const isDesc = (item) => item.direction?.type === 'sort_direction_desc';
+const isDesc = (item) => item.direction && item.direction.type === 'sort_direction_desc';
 
 const convertColumns = (columns) => {
     const {items} = columns.expr;

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

@@ -12,7 +12,7 @@ const {
 const isAsClause = ({type}) => type === 'as_clause';
 const isVirtual = (stmt) => stmt.kind && stmt.kind.kindKw.name === 'VIRTUAL';
 const isColumnDefinition = ({type}) => type === 'column_definition';
-const isTemp = (stmt) => ['TEMP', 'TEMPORARY'].includes(stmt.kind?.kindKw.name);
+const isTemp = (stmt) => stmt.kind && ['TEMP', 'TEMPORARY'].includes(stmt.kind.kindKw.name);
 
 const convertColumnListItem = (item) => {
     if (isColumnDefinition(item))
@@ -21,10 +21,15 @@ const convertColumnListItem = (item) => {
     return convertTableConstraint(item);
 };
 
-const isWithoutRowid = (options) => options?.items.some(({name}) => name?.some?.(({name}) => name === 'WITHOUT'));
+const isWithoutName = ({name}) => name === 'WITHOUT';
+const isWithoutKeyword = ({name}) => Array.isArray(name) && name.some(isWithoutName);
+const isWithoutRowid = (options) => options && options.items.some(isWithoutKeyword);
 
 const convertTableArgs = (stmt) => {
-    const colNodes = stmt.columns.expr.items.map(convertColumnListItem);
+    const colNodes = [];
+    
+    for (const item of stmt.columns.expr.items)
+        colNodes.push(convertColumnListItem(item));
     
     if (isWithoutRowid(stmt.options))
         colNodes.push(callExpression(identifier('withoutRowid'), []));
@@ -54,7 +59,7 @@ export const convertCreateTable = (stmt) => {
         ]);
     }
     
-    const asClause = stmt.clauses?.find(isAsClause);
+    const asClause = stmt.clauses && stmt.clauses.find(isAsClause);
     
     if (asClause)
         return callExpression(identifier('createTableAs'), [

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

@@ -3,7 +3,8 @@ import {convertClause} from '#parser/clause';
 
 const {identifier, callExpression} = types;
 
-const isMaterialized = (stmt) => stmt.kinds.some(({kindKw}) => kindKw.name === 'MATERIALIZED');
+const isMaterializedKind = ({kindKw}) => kindKw.name === 'MATERIALIZED';
+const isMaterialized = (stmt) => stmt.kinds.some(isMaterializedKind);
 
 export const convertCreateView = (stmt) => {
     const [asClause] = stmt.clauses;

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

@@ -145,6 +145,11 @@ const joinTypeParts = (operator) => {
     return parts;
 };
 
+const capitalizeWord = (s) => s[0].toUpperCase() +
+    s
+        .slice(1)
+        .toLowerCase();
+
 const convertJoinType = (operator) => {
     const parts = joinTypeParts(operator);
     
@@ -155,14 +160,12 @@ const convertJoinType = (operator) => {
         return 'join';
     
     // 'LEFT OUTER' → 'leftOuter' → 'leftOuterJoin'
-    const camel = parts[0].toLowerCase() +
-        parts
-            .slice(1)
-            .map((s) => s[0].toUpperCase() +
-            s
-                .slice(1)
-                .toLowerCase())
-            .join('');
+    const tail = [];
+    
+    for (const part of parts.slice(1))
+        tail.push(capitalizeWord(part));
+    
+    const camel = parts[0].toLowerCase() + tail.join('');
     
     return `${camel}Join`;
 };
@@ -268,7 +271,11 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause, ord
     
     if (expr.type === 'join_expr') {
         const parts = flattenJoins(expr);
-        return callExpression(identifier('from'), parts);
+        
+        return callExpression(identifier('from'), [
+            ...parts,
+            ...fromArgs,
+        ]);
     }
     
     if (expr.type === 'alias')

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

@@ -3,4 +3,11 @@ import {convertOperand} from '#parser/clause/operand';
 
 const {callExpression, identifier} = types;
 
-export const convertGroupBy = (clause) => callExpression(identifier('groupBy'), clause.columns.items.map(convertOperand));
+export const convertGroupBy = (clause) => {
+    const args = [];
+    
+    for (const item of clause.columns.items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier('groupBy'), args);
+};

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

@@ -7,7 +7,7 @@ const {
 } = types;
 
 export const convertLimit = (limitClause) => {
-    if (limitClause.count?.type === 'limit_all')
+    if (limitClause.count && limitClause.count.type === 'limit_all')
         return callExpression(identifier('limitAll'), []);
     
     const args = [

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

@@ -7,8 +7,9 @@ const isDesc = ({type}) => type === 'sort_direction_desc';
 
 const convertNullsOrder = (col, nullHandlingKw) => {
     const isLast = nullHandlingKw.at(-1).name === 'LAST';
+    const fnName = isLast ? 'nullsLast' : 'nullsFirst';
     
-    return callExpression(identifier(isLast ? 'nullsLast' : 'nullsFirst'), [col]);
+    return callExpression(identifier(fnName), [col]);
 };
 
 const convertOrderItem = (item) => {

package/lib/parser/visitors/clause/from/table-func.js

@@ -6,9 +6,18 @@ const {callExpression, identifier} = types;
 const SNAKE_RE = /_([a-z])/g;
 const toCamel = (s) => s.replace(SNAKE_RE, (_, c) => c.toUpperCase());
 
+const getRawName = (expr) => {
+    const raw = expr.name.name;
+    
+    if (raw.includes('_'))
+        return raw.toLowerCase();
+    
+    return raw;
+};
+
 export const convertTableFunc = (expr) => {
     // multi-word snake_case names are lowercased first (GENERATE_SERIES → generateSeries)
-    const name = toCamel(expr.name.name.includes('_') ? expr.name.name.toLowerCase() : expr.name.name);
+    const name = toCamel(getRawName(expr));
     const args = expr.args.expr.args.items.map(convertOperand);
     
     return callExpression(identifier(name), args);

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

@@ -75,6 +75,8 @@ const convertSelectOrNamed = (stmt) => {
     return convertSelect(stmt);
 };
 
+const getAnalyzeTables = ({tables}) => tables.items || tables;
+
 const clauseVisitors = {
     select_stmt: convertSelectOrNamed,
     insert_stmt: convertInsertOrNamed,
@@ -96,7 +98,14 @@ const clauseVisitors = {
     vacuum_stmt: ({file}) => callExpression(identifier('vacuum'), file ? [
         stringLiteral(file.value),
     ] : []),
-    truncate_stmt: ({tables}) => callExpression(identifier('truncate'), tables.items.map(({name}) => identifier(name))),
+    truncate_stmt: ({tables}) => {
+        const args = [];
+        
+        for (const table of tables.items)
+            args.push(convertTableName(table));
+        
+        return callExpression(identifier('truncate'), args);
+    },
     detach_database_stmt: ({schema}) => callExpression(identifier('detach'), [
         identifier(schema.name),
     ]),
@@ -111,7 +120,14 @@ const clauseVisitors = {
     reindex_stmt: (stmt) => callExpression(identifier('reindex'), stmt.name ? [
         identifier(stmt.name.name),
     ] : []),
-    analyze_stmt: (stmt) => callExpression(identifier('analyze'), (stmt.tables?.items ?? []).map(convertTableName)),
+    analyze_stmt: (stmt) => {
+        const args = [];
+        
+        for (const table of getAnalyzeTables(stmt))
+            args.push(convertTableName(table));
+        
+        return callExpression(identifier('analyze'), args);
+    },
     release_savepoint_stmt: ({savepoint}) => callExpression(identifier('releaseSavepoint'), [
         identifier(savepoint.name),
     ]),

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

@@ -53,12 +53,31 @@ const convertSource = (vc) => {
     return callExpression(identifier('values'), rowArgs);
 };
 
+const getTargetArgs = (target) => {
+    if (!target)
+        return [];
+    
+    const args = [];
+    
+    for (const item of target.expr.items)
+        args.push(convertExprToIdentifier(item));
+    
+    return args;
+};
+
+const convertUpsertAction = (action) => {
+    if (action.type === 'upsert_action_nothing')
+        return identifier('nothing');
+    
+    return convertSet(action.set);
+};
+
 const convertUpsert = (upsertClause) => {
     const target = upsertClause.conflictTarget;
     const {action} = upsertClause;
     
-    const targetArgs = target ? target.expr.items.map(convertExprToIdentifier) : [];
-    const actionNode = action.type === 'upsert_action_nothing' ? identifier('nothing') : convertSet(action.set);
+    const targetArgs = getTargetArgs(target);
+    const actionNode = convertUpsertAction(action);
     
     if (upsertClause.where)
         targetArgs.push(callExpression(identifier('where'), [
@@ -68,14 +87,26 @@ const convertUpsert = (upsertClause) => {
     return callExpression(identifier('onConflict'), [...targetArgs, actionNode]);
 };
 
-const isReplaceInto = ({insertKw, orAction}) => !orAction && insertKw?.name === 'REPLACE';
+const isReplaceInto = ({insertKw, orAction}) => !orAction && insertKw && insertKw.name === 'REPLACE';
+
+const colsToArg = (cols) => {
+    if (cols.length === 1)
+        return identifier(cols[0].name);
+    
+    const args = [];
+    
+    for (const col of cols)
+        args.push(convertColToIdentifier(col));
+    
+    return arrayExpression(args);
+};
 
 const convertReplaceInto = ({clauses}) => {
     const ic = findClause(clauses, 'insert_clause');
     const rc = findClause(clauses, 'returning_clause');
     
     const cols = ic.columns.expr.items;
-    const colArg = cols.length === 1 ? identifier(cols[0].name) : arrayExpression(cols.map(convertColToIdentifier));
+    const colArg = colsToArg(cols);
     const source = convertSource(findClause(clauses, 'values_clause'));
     
     return callExpression(identifier('replaceInto'), [
@@ -88,6 +119,13 @@ const convertReplaceInto = ({clauses}) => {
     ].filter(Boolean));
 };
 
+const getSource = (dc, vc) => {
+    if (dc)
+        return callExpression(identifier('defaultValues'), []);
+    
+    return convertSource(vc);
+};
+
 export const convertInsert = (stmt) => {
     if (isReplaceInto(stmt.clauses[0]))
         return convertReplaceInto(stmt);
@@ -100,7 +138,7 @@ export const convertInsert = (stmt) => {
     const dc = findClause(clauses, 'default_values');
     
     const colArgs = convertColumns(ic);
-    const source = dc ? callExpression(identifier('defaultValues'), []) : convertSource(vc);
+    const source = getSource(dc, vc);
     
     const args = [
         ic.orAction && convertOrAction(ic.orAction),
@@ -134,7 +172,7 @@ const convertColumns = (ic) => {
         return [];
     
     const cols = columns.expr.items;
-    const colArg = cols.length === 1 ? identifier(cols[0].name) : arrayExpression(cols.map(convertColToIdentifier));
+    const colArg = colsToArg(cols);
     
     return [
         colArg,

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

@@ -68,7 +68,7 @@ const convertQuantifier = (node) => {
 
 const convertPrefix = (node) => {
     const {operator} = node;
-    const name = operator?.name ?? operator;
+    const name = operator.name || operator;
     
     if (name === 'EXISTS')
         return callExpression(identifier('exists'), [

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

@@ -145,10 +145,12 @@ const convertFrameBound = (bound) => {
     
     const name = bound.type === 'frame_bound_preceding' ? 'preceding' : 'following';
     
-    const isUnbounded = bound.expr?.type === 'frame_unbounded';
-    const args = !isUnbounded && bound.expr ? [
-        numericLiteral(bound.expr.value),
-    ] : [];
+    const isUnbounded = bound.expr && bound.expr.type === 'frame_unbounded';
+    const args = !isUnbounded && bound.expr
+        ? [
+            numericLiteral(bound.expr.value),
+        ]
+        : [];
     
     return callExpression(identifier(name), args);
 };
@@ -215,8 +217,10 @@ const convertFuncCall = (column) => {
     for (const item of items)
         args.push(convertOperand(item));
     
-    if (column.over)
-        return convertOver(column, callExpression(identifier(LOWERCASE_FUNCS.has(lower) ? lower : name), args));
+    if (column.over) {
+        const funcName = LOWERCASE_FUNCS.has(lower) ? lower : name;
+        return convertOver(column, callExpression(identifier(funcName), args));
+    }
     
     if (LOWERCASE_FUNCS.has(lower))
         return callExpression(identifier(lower), args);
@@ -234,13 +238,16 @@ const convertColumns = (columns) => {
     return columns.items.map(convertColumn);
 };
 
-const isDistinct = (selectClause) => selectClause.modifiers.some(({type}) => type === 'select_distinct');
+const isSelectDistinct = ({type}) => type === 'select_distinct';
+const isSelectDistinctOn = ({type}) => type === 'select_distinct_on';
+
+const isDistinct = (selectClause) => selectClause.modifiers.some(isSelectDistinct);
 
 const convertDistinctOn = ({modifiers}) => {
-    if (!modifiers.some(({type}) => type === 'select_distinct_on'))
+    if (!modifiers.some(isSelectDistinctOn))
         return null;
     
-    const modifier = modifiers.find(({type}) => type === 'select_distinct_on');
+    const modifier = modifiers.find(isSelectDistinctOn);
     const onCols = [];
     
     for (const item of modifier.columns.expr.items) {

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/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';
@@ -278,6 +279,7 @@ export const clauses = {
     createTableAs,
     alterTable,
     addColumn,
+    addConstraint,
     dropColumn,
     renameColumn,
     alterColumnType,

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

@@ -68,7 +68,13 @@ 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 toFuncName = (name) => {
+    if (ALL_CAPS_RE.test(name))
+        return name;
+    
+    return toSnake(name);
+};
 
 const isTableFunc = (node) => isCallExpression(node) && !TABLE_ARG_NAMES.includes(node.callee.name);
 
@@ -104,8 +110,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/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/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/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,7 @@
-const needsParensIn = (node, op) => op === '&&' && node.type === 'LogicalExpression' && node.operator === '||';
+import {types} from '@putout/babel';
+
+const {isLogicalExpression} = types;
+const needsParensIn = (node, op) => op === '&&' && isLogicalExpression(node) && node.operator === '||';
 
 const printNestedOr = (node, printer) => {
     const {write, traverse} = printer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-sql",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "type": "module",
   "description": "sql to js ast parser and printer",
   "exports": {
@@ -83,7 +83,7 @@
   },
   "homepage": "https://github.com/coderaiser/happy-sql",
   "devDependencies": {
-    "@putout/plugin-printer": "^8.22.0",
+    "@putout/plugin-printer": "^9.0.0",
     "@putout/test": "^15.8.2",
     "eslint": "^10.8.1",
     "eslint-plugin-node": "^11.1.0",
@@ -103,7 +103,7 @@
     "@putout/printer": "^18.38.1",
     "just-camel-case": "^6.2.0",
     "redstd": "^1.0.2",
-    "sql-parser-cst": "^0.42.1",
+    "sql-parser-cst": "^0.44.1",
     "try-catch": "^4.0.9"
   }
 }