prettier-plugin-tsql 0.6.6 → 0.6.7

package/dist/printer/expressions.js

@@ -1,6 +1,46 @@
 import { keyword, getDensity, hardSep, softSep, hardline, join, group, indent, line, softline, fill, appendTrailingLines, parenList, aliasDoc, } from '../_core/printer/utils.js';
 import { prop, propArr, propStr, propBool, schemaObjectName, assignmentOp } from './helpers.js';
 // ---------------------------------------------------------------------------
+// Module-level lookup tables (created once, not per call)
+// ---------------------------------------------------------------------------
+const BINARY_OP_MAP = {
+    Add: '+',
+    Subtract: '-',
+    Multiply: '*',
+    Divide: '/',
+    Modulo: '%',
+    BitwiseAnd: '&',
+    BitwiseOr: '|',
+    BitwiseXor: '^',
+    Concatenate: '+',
+    Concat: '||',
+};
+const CMP_OP_MAP = {
+    Equals: '=',
+    NotEqualToBrackets: '<>',
+    NotEqualToExclamation: '!=',
+    GreaterThan: '>',
+    LessThan: '<',
+    GreaterThanOrEqualTo: '>=',
+    LessThanOrEqualTo: '<=',
+    LeftOuterJoin: '*=',
+    RightOuterJoin: '=*',
+    NotLessThan: '!<',
+    NotGreaterThan: '!>',
+};
+const JOIN_TYPE_MAP = {
+    Inner: 'INNER JOIN',
+    LeftOuter: 'LEFT JOIN',
+    RightOuter: 'RIGHT JOIN',
+    FullOuter: 'FULL JOIN',
+};
+const JOIN_TYPE_WORD = {
+    Inner: 'INNER',
+    LeftOuter: 'LEFT',
+    RightOuter: 'RIGHT',
+    FullOuter: 'FULL',
+};
+// ---------------------------------------------------------------------------
 // Scalar expressions
 // ---------------------------------------------------------------------------
 export function printExpression(node, opts, printFn) {
@@ -261,16 +301,25 @@ function printFunctionCall(node, opts, printFn) {
     }
     return argsDoc;
 }
-// Flatten a left-recursive + (Add/Concatenate) chain into its leaf terms.
+// Flatten a left-recursive chain of the given operators into leaf terms.
 // Stops at any other operator so e.g. the `a * b` in `a * b + c` stays grouped.
-function collectConcatChain(node) {
+// Keeping ops separate (Add/Concatenate vs Concat) prevents mixing + and || chains.
+function collectBinaryChain(node, ...ops) {
     const op = propStr(node, 'operator');
-    if (node.type !== 'BinaryExpression' || (op !== 'Add' && op !== 'Concatenate')) {
+    if (node.type !== 'BinaryExpression' || !ops.includes(op ?? '')) {
         return [node];
     }
     const left = prop(node, 'left');
     const right = prop(node, 'right');
-    return [...(left ? collectConcatChain(left) : []), ...(right ? [right] : [])];
+    return [...(left ? collectBinaryChain(left, ...ops) : []), ...(right ? [right] : [])];
+}
+function buildFillChain(termDocs, sep) {
+    const parts = [termDocs[0]];
+    for (let i = 1; i < termDocs.length; i++) {
+        parts.push(indent([line, sep]));
+        parts.push(termDocs[i]);
+    }
+    return fill(parts);
 }
 function printBinaryExpr(node, opts, printFn) {
     const op = propStr(node, 'operator') ?? '+';
@@ -279,17 +328,13 @@ function printBinaryExpr(node, opts, printFn) {
     // term would overflow. Flat: "a + b + c". Filling: "a + b\n+ c + d".
     // This prevents Prettier from descending into function args to break there.
     if (op === 'Add' || op === 'Concatenate') {
-        const terms = collectConcatChain(node);
-        const termDocs = terms.map((t) => printExpression(t, opts, printFn));
-        // Flat: "a + b + c". Wrapping: "a + b\n    + c + d".
-        // Using fill (not group) so outer flat-mode contexts don't suppress breaks.
-        // The indent is on the separator so continuation lines are indented one level.
-        const parts = [termDocs[0]];
-        for (let i = 1; i < termDocs.length; i++) {
-            parts.push(indent([line, '+ ']));
-            parts.push(termDocs[i]);
-        }
-        return fill(parts);
+        const terms = collectBinaryChain(node, 'Add', 'Concatenate');
+        return buildFillChain(terms.map((t) => printExpression(t, opts, printFn)), '+ ');
+    }
+    // || chains work the same way but keep their own operator symbol.
+    if (op === 'Concat') {
+        const terms = collectBinaryChain(node, 'Concat');
+        return buildFillChain(terms.map((t) => printExpression(t, opts, printFn)), '|| ');
     }
     const left = prop(node, 'left');
     const right = prop(node, 'right');
@@ -303,18 +348,7 @@ function printBinaryExpr(node, opts, printFn) {
     ]);
 }
 function mapBinaryOp(op) {
-    const map = {
-        Add: '+',
-        Subtract: '-',
-        Multiply: '*',
-        Divide: '/',
-        Modulo: '%',
-        BitwiseAnd: '&',
-        BitwiseOr: '|',
-        BitwiseXor: '^',
-        Concatenate: '+',
-    };
-    return map[op] ?? op;
+    return BINARY_OP_MAP[op] ?? op;
 }
 function printUnaryExpr(node, opts, printFn) {
     const expr = prop(node, 'expr');
@@ -514,6 +548,8 @@ export function printQueryExpression(node, opts, printFn) {
 }
 function printQuerySpec(node, opts, printFn) {
     const density = getDensity(opts);
+    const compact = density === 'compact';
+    const sep = compact ? line : hardline;
     const uniqueRowFilter = propStr(node, 'uniqueRowFilter');
     const top = prop(node, 'top');
     const selectElements = propArr(node, 'selectElements');
@@ -531,17 +567,16 @@ function printQuerySpec(node, opts, printFn) {
     const selectKw = uniqueRowFilter === 'Distinct' ? keyword('SELECT DISTINCT', opts) : keyword('SELECT', opts);
     const topDoc = top ? printTop(top, opts, printFn) : null;
     const colDocs = selectElements.map((se) => printExpression(se, opts, printFn));
-    if (density === 'compact') {
+    const parts = [selectKw, ...(topDoc ? [' ', topDoc] : [])];
+    if (compact) {
         // Compact: fill-pack each list clause — as many items per line as fit, wrapping only when needed.
         // indent() ensures wrapped lines are indented one level under the keyword.
         const colList = indent(fill(colDocs.flatMap((d, i) => (i === 0 ? [d] : [[',', line], d]))));
-        const parts = [selectKw, ...(topDoc ? [' ', topDoc] : []), ' ', colList];
-        if (intoTarget) {
+        parts.push(' ', colList);
+        if (intoTarget)
             parts.push(line, keyword('INTO', opts), ' ', schemaObjectName(intoTarget));
-        }
         if (from) {
-            const tableRefs = propArr(from, 'tableReferences');
-            const fromDocs = tableRefs.map((tr) => printTableRef(tr, opts, printFn));
+            const fromDocs = propArr(from, 'tableReferences').map((tr) => printTableRef(tr, opts, printFn));
             // Try to keep FROM on one line; if too long, each join on its own line
             parts.push(line, keyword('FROM', opts), ' ', group(indent(join(softSep(opts), fromDocs))));
         }
@@ -550,108 +585,89 @@ function printQuerySpec(node, opts, printFn) {
             parts.push(line, keyword('WHERE', opts), group([indent([line, boolWithTrailing(where, fillBoolChain(where, opts, printFn))])]));
         }
         if (groupBy) {
-            const elems = propArr(groupBy, 'elements');
-            const elemDocs = elems.map((e) => printExpression(e, opts, printFn));
+            const elemDocs = propArr(groupBy, 'elements').map((e) => printExpression(e, opts, printFn));
             parts.push(line, keyword('GROUP BY', opts), ' ', indent(fill(elemDocs.flatMap((d, i) => (i === 0 ? [d] : [[',', line], d])))));
         }
         if (having) {
             parts.push(line, keyword('HAVING', opts), group([indent([line, boolWithTrailing(having, fillBoolChain(having, opts, printFn))])]));
         }
-        if (orderBy) {
-            parts.push(line, printOrderByClause(orderBy, opts, printFn));
-        }
-        if (offsetNode) {
-            parts.push(line, keyword('OFFSET', opts), ' ', printExpression(offsetNode, opts, printFn), ' ', keyword('ROWS', opts));
-            if (fetchNode) {
-                parts.push(line, keyword('FETCH NEXT', opts), ' ', printExpression(fetchNode, opts, printFn), ' ', keyword('ROWS ONLY', opts));
-            }
-        }
-        if (windowDefs.length > 0) {
-            parts.push(line, printWindowClause(windowDefs, opts, printFn));
-        }
-        if (forClause) {
-            parts.push(line, printForClause(forClause, opts));
-        }
-        return group(parts);
-    }
-    // Standard / Spacious: single column stays inline; multiple each on own line.
-    // A CASE expression always expands to multiple lines, so force it onto its own indented line.
-    const singleExprType = (prop(selectElements[0], 'expression') ?? selectElements[0])?.type;
-    const colList = density === 'standard' && colDocs.length === 1 && singleExprType !== 'CaseExpression'
-        ? [' ', colDocs[0]]
-        : indent([hardline, join(hardSep(opts), colDocs)]);
-    const parts = [selectKw, ...(topDoc ? [' ', topDoc] : []), colList];
-    // SELECT INTO target appears after the column list and before the FROM clause
-    if (intoTarget) {
-        parts.push(hardline, keyword('INTO', opts), ' ', schemaObjectName(intoTarget));
-    }
-    if (from) {
-        const tableRefs = propArr(from, 'tableReferences');
-        const fromDocs = tableRefs.map((tr) => printTableRef(tr, opts, printFn));
-        // standard: single table (no joins) stays inline; multiple/joins each on own line
-        // InlineDerivedTable uses a softline so it stays inline when it fits but breaks
-        // FROM onto its own line (with the values block indented) when it doesn't
-        const singleTable = density === 'standard' &&
-            tableRefs.length === 1 &&
-            tableRefs[0].type !== 'QualifiedJoin' &&
-            tableRefs[0].type !== 'UnqualifiedJoin' &&
-            tableRefs[0].type !== 'InlineDerivedTable';
-        if (tableRefs.length === 1 && tableRefs[0].type === 'InlineDerivedTable') {
-            parts.push(hardline, group([keyword('FROM', opts), indent([line, fromDocs[0]])]));
-        }
-        else if (singleTable) {
-            parts.push(hardline, keyword('FROM', opts), ' ', fromDocs[0]);
-        }
-        else {
-            parts.push(hardline, keyword('FROM', opts), indent([hardline, join(hardSep(opts), fromDocs)]));
-        }
-    }
-    if (where) {
-        // standard: single predicate inline; multiple each on own line
-        // spacious: always indented
-        const inline = density === 'standard' && where.type !== 'BooleanBinary';
-        if (inline) {
-            parts.push(hardline, keyword('WHERE', opts), ' ', boolWithTrailing(where, printBoolExpr(where, opts, printFn)));
-        }
-        else {
-            parts.push(hardline, keyword('WHERE', opts), indent([hardline, boolWithTrailing(where, printBoolExpr(where, opts, printFn))]));
-        }
     }
-    if (groupBy) {
-        const elems = propArr(groupBy, 'elements');
-        const elemDocs = elems.map((e) => printExpression(e, opts, printFn));
-        const inline = density === 'standard' && elems.length === 1;
-        if (inline) {
-            parts.push(hardline, keyword('GROUP BY', opts), ' ', elemDocs[0]);
+    else {
+        // Standard / Spacious: single column stays inline; multiple each on own line.
+        // A CASE expression always expands to multiple lines, so force it onto its own indented line.
+        const singleExprType = (prop(selectElements[0], 'expression') ?? selectElements[0])?.type;
+        const colList = density === 'standard' && colDocs.length === 1 && singleExprType !== 'CaseExpression'
+            ? [' ', colDocs[0]]
+            : indent([hardline, join(hardSep(opts), colDocs)]);
+        parts.push(colList);
+        // SELECT INTO target appears after the column list and before the FROM clause
+        if (intoTarget)
+            parts.push(hardline, keyword('INTO', opts), ' ', schemaObjectName(intoTarget));
+        if (from) {
+            const tableRefs = propArr(from, 'tableReferences');
+            const fromDocs = tableRefs.map((tr) => printTableRef(tr, opts, printFn));
+            // standard: single table (no joins) stays inline; multiple/joins each on own line
+            // InlineDerivedTable uses a softline so it stays inline when it fits but breaks
+            // FROM onto its own line (with the values block indented) when it doesn't
+            const singleTable = density === 'standard' &&
+                tableRefs.length === 1 &&
+                tableRefs[0].type !== 'QualifiedJoin' &&
+                tableRefs[0].type !== 'UnqualifiedJoin' &&
+                tableRefs[0].type !== 'InlineDerivedTable';
+            if (tableRefs.length === 1 && tableRefs[0].type === 'InlineDerivedTable') {
+                parts.push(hardline, group([keyword('FROM', opts), indent([line, fromDocs[0]])]));
+            }
+            else if (singleTable) {
+                parts.push(hardline, keyword('FROM', opts), ' ', fromDocs[0]);
+            }
+            else {
+                parts.push(hardline, keyword('FROM', opts), indent([hardline, join(hardSep(opts), fromDocs)]));
+            }
         }
-        else {
-            parts.push(hardline, keyword('GROUP BY', opts), indent([hardline, join(hardSep(opts), elemDocs)]));
+        if (where) {
+            // standard: single predicate inline; multiple each on own line
+            // spacious: always indented
+            const inline = density === 'standard' && where.type !== 'BooleanBinary';
+            if (inline) {
+                parts.push(hardline, keyword('WHERE', opts), ' ', boolWithTrailing(where, printBoolExpr(where, opts, printFn)));
+            }
+            else {
+                parts.push(hardline, keyword('WHERE', opts), indent([hardline, boolWithTrailing(where, printBoolExpr(where, opts, printFn))]));
+            }
         }
-    }
-    if (having) {
-        const inline = density === 'standard' && having.type !== 'BooleanBinary';
-        if (inline) {
-            parts.push(hardline, keyword('HAVING', opts), ' ', boolWithTrailing(having, printBoolExpr(having, opts, printFn)));
+        if (groupBy) {
+            const elems = propArr(groupBy, 'elements');
+            const elemDocs = elems.map((e) => printExpression(e, opts, printFn));
+            if (density === 'standard' && elems.length === 1) {
+                parts.push(hardline, keyword('GROUP BY', opts), ' ', elemDocs[0]);
+            }
+            else {
+                parts.push(hardline, keyword('GROUP BY', opts), indent([hardline, join(hardSep(opts), elemDocs)]));
+            }
         }
-        else {
-            parts.push(hardline, keyword('HAVING', opts), indent([hardline, boolWithTrailing(having, printBoolExpr(having, opts, printFn))]));
+        if (having) {
+            const inline = density === 'standard' && having.type !== 'BooleanBinary';
+            if (inline) {
+                parts.push(hardline, keyword('HAVING', opts), ' ', boolWithTrailing(having, printBoolExpr(having, opts, printFn)));
+            }
+            else {
+                parts.push(hardline, keyword('HAVING', opts), indent([hardline, boolWithTrailing(having, printBoolExpr(having, opts, printFn))]));
+            }
         }
     }
-    if (orderBy) {
-        parts.push(hardline, printOrderByClause(orderBy, opts, printFn));
-    }
+    // Tail clauses — same layout intent for all densities, sep varies
+    if (orderBy)
+        parts.push(sep, printOrderByClause(orderBy, opts, printFn));
     if (offsetNode) {
-        parts.push(hardline, keyword('OFFSET', opts), ' ', printExpression(offsetNode, opts, printFn), ' ', keyword('ROWS', opts));
+        parts.push(sep, keyword('OFFSET', opts), ' ', printExpression(offsetNode, opts, printFn), ' ', keyword('ROWS', opts));
         if (fetchNode) {
-            parts.push(hardline, keyword('FETCH NEXT', opts), ' ', printExpression(fetchNode, opts, printFn), ' ', keyword('ROWS ONLY', opts));
+            parts.push(sep, keyword('FETCH NEXT', opts), ' ', printExpression(fetchNode, opts, printFn), ' ', keyword('ROWS ONLY', opts));
         }
     }
-    if (windowDefs.length > 0) {
-        parts.push(hardline, printWindowClause(windowDefs, opts, printFn));
-    }
-    if (forClause) {
-        parts.push(hardline, printForClause(forClause, opts));
-    }
+    if (windowDefs.length > 0)
+        parts.push(sep, printWindowClause(windowDefs, opts, printFn));
+    if (forClause)
+        parts.push(sep, printForClause(forClause, opts));
     return group(parts);
 }
 function printTop(node, opts, printFn) {
@@ -836,25 +852,14 @@ export function printBoolExpr(node, opts, printFn) {
             return printDistinctPredicate(node, opts, printFn);
         case 'SubqueryComparisonPredicate':
             return printSubqueryComparison(node, opts, printFn);
+        case 'RegexpLikePredicate':
+            return printRegexpLikePredicate(node, opts, printFn);
         default:
             return node.text ?? `/* ${node.type} */`;
     }
 }
 function cmpOp(op) {
-    const map = {
-        Equals: '=',
-        NotEqualToBrackets: '<>',
-        NotEqualToExclamation: '!=',
-        GreaterThan: '>',
-        LessThan: '<',
-        GreaterThanOrEqualTo: '>=',
-        LessThanOrEqualTo: '<=',
-        LeftOuterJoin: '*=',
-        RightOuterJoin: '=*',
-        NotLessThan: '!<',
-        NotGreaterThan: '!>',
-    };
-    return map[op] ?? op;
+    return CMP_OP_MAP[op] ?? op;
 }
 function printBoolComparison(node, opts, printFn) {
     const left = prop(node, 'left');
@@ -1009,6 +1014,16 @@ function printInPredicate(node, opts, printFn) {
     const valueDocs = values.map((v) => printExpression(v, opts, printFn));
     return [...lhs, group([' (', indent([softline, join([',', line], valueDocs)]), softline, ')'])];
 }
+function printRegexpLikePredicate(node, opts, printFn) {
+    const args = [
+        prop(node, 'value') ? printExpression(prop(node, 'value'), opts, printFn) : '',
+        prop(node, 'pattern') ? printExpression(prop(node, 'pattern'), opts, printFn) : '',
+    ];
+    const flags = prop(node, 'flags');
+    if (flags)
+        args.push(printExpression(flags, opts, printFn));
+    return [keyword('regexp_like', opts), parenList(args)];
+}
 function printLikePredicate(node, opts, printFn) {
     const expr = prop(node, 'expr');
     const pattern = prop(node, 'pattern');
@@ -1147,22 +1162,11 @@ function printNamedTableRef(node, opts, printFn) {
     return [nameDoc, temporalDoc, aliasPart, sampleDoc, hintsDoc];
 }
 function joinTypeKeyword(jt, opts, hint) {
-    const typeMap = {
-        Inner: 'INNER',
-        LeftOuter: 'LEFT',
-        RightOuter: 'RIGHT',
-        FullOuter: 'FULL',
-    };
-    const typeWord = typeMap[jt] ?? jt.toUpperCase();
-    if (hint)
+    if (hint) {
+        const typeWord = JOIN_TYPE_WORD[jt] ?? jt.toUpperCase();
         return keyword(`${typeWord} ${hint} JOIN`, opts);
-    const noHintMap = {
-        Inner: 'INNER JOIN',
-        LeftOuter: 'LEFT JOIN',
-        RightOuter: 'RIGHT JOIN',
-        FullOuter: 'FULL JOIN',
-    };
-    return keyword(noHintMap[jt] ?? `${typeWord} JOIN`, opts);
+    }
+    return keyword(JOIN_TYPE_MAP[jt] ?? `${(JOIN_TYPE_WORD[jt] ?? jt.toUpperCase())} JOIN`, opts);
 }
 /**
  * Walk the rightmost path of an AST subtree (props in reverse insertion order)