inline-sql-toolkit 0.4.11 → 0.4.13

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.4.13 - 2026-09-25
+
+- Changed: `inlineSql.format.commaPosition: "before"` now emits the moved
+  comma with no following space — `id` / `    ,name` instead of `, name` —
+  per user feedback. The default `after` output is byte-for-byte unchanged,
+  and the mover's safety rules are identical: commas inside string literals,
+  `$$ … $$` bodies, and comments are still never touched.
+
+## 0.4.12 - 2026-09-24
+
+- Feature: added the `inlineSql.format.keepFunctionsInline` setting (default
+  `false`). `sql-formatter` has no option that holds function arguments on
+  one line — it breaks `CASE` structurally regardless of `wrapAfter` — so the
+  extension re-joins the line breaks the engine inserts inside `word(...)`
+  groups as a post-pass over its output. With the setting on,
+  `COUNT(CASE WHEN a THEN 1 ELSE 0 END)` stays on a single line while select
+  lists, clause breaks, and `AND` / `OR` chains keep their usual layout.
+- The same choice is exposed everywhere the other options are: the VS Code
+  setting, the CLI flag `--keep-functions-inline`, and
+  `"keepFunctionsInline"` in `.inline-sql.json`, under the unchanged CLI
+  flags > configuration file > defaults precedence.
+- Safety: only newlines in code state are removed. A newline inside a string
+  literal, a `$$ … $$` body, or a block comment is copied verbatim, and the
+  newline that terminates a `-- line comment` is kept, so literal content can
+  never change and no code can fall into a comment. The default `false`
+  reproduces the previous output byte for byte, and the fixed-point loop still
+  skips any candidate whose formatting does not converge.
+
 ## 0.4.11 - 2026-09-24
 
 - Feature: added the `inlineSql.format.commaPosition` setting (`after` |

package/README.md

@@ -112,7 +112,11 @@ later atomic precondition.
   `mysql`, `postgresql`, or `sqlite`; default `postgresql`).
 - `inlineSql.format.commaPosition`: `after` (default) keeps a wrapping comma at
   the end of the previous line; `before` moves it to the start of the next
-  line.
+  line, with no space after the comma (`id` / `    ,name`).
+- `inlineSql.format.keepFunctionsInline`: re-join the formatter's line breaks
+  inside `word(...)` groups so `SUM(...)`, `COUNT(CASE ... END)`, and nested
+  calls stay on one line (default `false`). Newlines inside string literals and
+  comments are never removed.
 
 The extension highlights inline SQL with an injected TextMate grammar: SQL
 strings that start with `-- sql` (or a leading SQL keyword) are embedded as
@@ -148,6 +152,7 @@ When run without file arguments, the CLI reads Python source from standard input
 | `--no-space-around-operators` | Keep dense operators                                              | spaced                     |
 | `--no-ordinals`               | Do not replace `GROUP BY` / `ORDER BY` ordinals with column names | replace                    |
 | `--comma-position <pos>`      | Where a wrapping comma sits: `after` or `before`                  | `after`                    |
+| `--keep-functions-inline`     | Keep `SUM(...)` / `COUNT(CASE ... END)` on one line               | off                        |
 | `-c, --config <file>`         | Configuration JSON file                                           | Nearest `.inline-sql.json` |
 | `-h, --help`                  | Show usage help                                                   |                            |
 | `--version`                   | Show version number                                               |                            |
@@ -167,7 +172,8 @@ The CLI automatically searches for a `.inline-sql.json` file in the current work
     "useSpaceAroundOperators": true,
     "replaceOrdinals": true,
     "dialect": "postgresql",
-    "commaPosition": "after"
+    "commaPosition": "after",
+    "keepFunctionsInline": false
   }
 }
 ```

package/dist/cli.js

@@ -495,7 +495,8 @@ function resolveFormatOptions(raw) {
   const replaceOrdinals2 = raw.replaceOrdinals === void 0 ? true : raw.replaceOrdinals;
   const dialect = raw.dialect === void 0 ? "postgresql" : raw.dialect;
   const commaPosition = raw.commaPosition === void 0 ? "after" : raw.commaPosition;
-  if (keywordCase !== "upper" && keywordCase !== "lower" && keywordCase !== "preserve" || !integerBetween(indentWidth, 1, 8) || !integerBetween(wrapAfter, 20, 500) || typeof useSpaceAroundOperators !== "boolean" || typeof replaceOrdinals2 !== "boolean" || dialect !== "sql" && dialect !== "mysql" && dialect !== "postgresql" && dialect !== "sqlite" || commaPosition !== "after" && commaPosition !== "before") {
+  const keepFunctionsInline = raw.keepFunctionsInline === void 0 ? false : raw.keepFunctionsInline;
+  if (keywordCase !== "upper" && keywordCase !== "lower" && keywordCase !== "preserve" || !integerBetween(indentWidth, 1, 8) || !integerBetween(wrapAfter, 20, 500) || typeof useSpaceAroundOperators !== "boolean" || typeof replaceOrdinals2 !== "boolean" || dialect !== "sql" && dialect !== "mysql" && dialect !== "postgresql" && dialect !== "sqlite" || commaPosition !== "after" && commaPosition !== "before" || typeof keepFunctionsInline !== "boolean") {
     return { ok: false, reason: "INVALID_CONFIGURATION" };
   }
   return {
@@ -507,7 +508,8 @@ function resolveFormatOptions(raw) {
       useSpaceAroundOperators,
       replaceOrdinals: replaceOrdinals2,
       dialect,
-      commaPosition
+      commaPosition,
+      keepFunctionsInline
     }
   };
 }
@@ -1614,10 +1616,116 @@ function moveCommasToLineStarts(text) {
     const indent = nextParts?.[1] ?? "";
     const content = nextParts?.[2] ?? "";
     lines[index] = `${line.slice(0, comma)}${line.slice(comma + 1)}`.trimEnd();
-    lines[index + 1] = `${indent}, ${content}`;
+    lines[index + 1] = `${indent},${content}`;
   }
   return lines.join("\n");
 }
+var DOLLAR_QUOTE = /\$[A-Za-z_][A-Za-z0-9_]*\$|\$\$/y;
+function rejoinFunctionCalls(text) {
+  const stack = [];
+  let out = "";
+  let i = 0;
+  const at = (index) => text.charAt(index);
+  const isCallOpener = () => {
+    const match = /[A-Za-z_][A-Za-z0-9_]*\s*$/.exec(out);
+    if (match === null) return false;
+    const before = out.slice(0, match.index);
+    return before === "" || !/[A-Za-z0-9_]$/.test(before);
+  };
+  while (i < text.length) {
+    const ch = at(i);
+    if (ch === "'" || ch === '"' || ch === "`") {
+      const quote = ch;
+      out += ch;
+      i += 1;
+      while (i < text.length) {
+        if (at(i) === quote && at(i + 1) === quote) {
+          out += at(i) + at(i + 1);
+          i += 2;
+          continue;
+        }
+        out += at(i);
+        i += 1;
+        if (at(i - 1) === quote) break;
+        if (at(i - 1) === "\\" && quote !== "`" && i < text.length) {
+          out += at(i);
+          i += 1;
+        }
+      }
+      continue;
+    }
+    if (ch === "$") {
+      DOLLAR_QUOTE.lastIndex = i;
+      const dollar = DOLLAR_QUOTE.exec(text);
+      if (dollar !== null) {
+        const end = text.indexOf(dollar[0], i + dollar[0].length);
+        const stop = end === -1 ? text.length : end + dollar[0].length;
+        out += text.slice(i, stop);
+        i = stop;
+        continue;
+      }
+    }
+    if (ch === "-" && at(i + 1) === "-" || ch === "#") {
+      while (i < text.length && at(i) !== "\n") {
+        out += at(i);
+        i += 1;
+      }
+      if (i < text.length) {
+        out += at(i);
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && at(i + 1) === "*") {
+      out += "/*";
+      i += 2;
+      while (i < text.length && !(at(i) === "*" && at(i + 1) === "/")) {
+        out += at(i);
+        i += 1;
+      }
+      if (i < text.length) {
+        out += "*/";
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === "\n") {
+      if (stack.includes(true)) {
+        let indent = i + 1;
+        while (indent < text.length && (at(indent) === " " || at(indent) === "	")) {
+          indent += 1;
+        }
+        let peek = indent;
+        while (peek < text.length && (at(peek) === "\n" || at(peek) === " " || at(peek) === "	")) {
+          peek += 1;
+        }
+        const next = at(peek);
+        const prev = out.slice(-1);
+        i = indent;
+        if (prev !== "(" && next !== "," && next !== ")") out += " ";
+      } else {
+        out += ch;
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "(") {
+      stack.push(isCallOpener());
+      out += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === ")") {
+      stack.pop();
+      out += ch;
+      i += 1;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
 function formatOnce(analysis, literal, detection, options, nonce, sqlFormatter) {
   const plan = buildProtectionPlan(analysis.sourceMap, literal, detection, nonce);
   let formatted = sqlFormatter(plan.protectedSql, {
@@ -1632,6 +1740,9 @@ function formatOnce(analysis, literal, detection, options, nonce, sqlFormatter)
   }
   formatted = breakTrailingFieldMarkers(formatted);
   formatted = moveCommasBeforeLineComments(formatted);
+  if (options.keepFunctionsInline) {
+    formatted = rejoinFunctionCalls(formatted);
+  }
   if (options.commaPosition === "before") {
     formatted = moveCommasToLineStarts(formatted);
   }
@@ -1861,7 +1972,7 @@ function formatDocument(source, options, target, nonce, sqlFormatter, logger) {
   };
   if (logger !== void 0) {
     logger(
-      `format: dialect=${options.dialect} keywordCase=${options.keywordCase} indentWidth=${options.indentWidth} wrapAfter=${options.wrapAfter} useSpaceAroundOperators=${options.useSpaceAroundOperators} replaceOrdinals=${options.replaceOrdinals} commaPosition=${options.commaPosition} discovered=${summary.discovered} selected=${summary.selected} changed=${summary.changed} unchanged=${summary.unchanged} skipped=${summary.skipped}${skipReasons.length > 0 ? ` reasons=[${skipReasons.join(", ")}]` : ""}`
+      `format: dialect=${options.dialect} keywordCase=${options.keywordCase} indentWidth=${options.indentWidth} wrapAfter=${options.wrapAfter} useSpaceAroundOperators=${options.useSpaceAroundOperators} replaceOrdinals=${options.replaceOrdinals} commaPosition=${options.commaPosition} keepFunctionsInline=${options.keepFunctionsInline} discovered=${summary.discovered} selected=${summary.selected} changed=${summary.changed} unchanged=${summary.unchanged} skipped=${summary.skipped}${skipReasons.length > 0 ? ` reasons=[${skipReasons.join(", ")}]` : ""}`
     );
   }
   return {
@@ -22514,6 +22625,7 @@ var USAGE = `Usage: inline-sql-toolkit [options] [files...]
       --no-space-around-operators  keep dense operators (default: spaced)
       --no-ordinals                do not replace GROUP BY / ORDER BY ordinals
       --comma-position <pos>       after | before (default: after)
+      --keep-functions-inline      keep SUM(...) / COUNT(CASE ...) on one line
   -c, --config <file>              config JSON (default: nearest .inline-sql.json)
   -h, --help / --version`;
 function printError(message) {
@@ -22573,7 +22685,8 @@ function buildRawOptions(fileOptions, cliValues) {
     wrapAfter: cliValues["wrap-after"] !== void 0 ? Number(cliValues["wrap-after"]) : fileOptions.wrapAfter,
     useSpaceAroundOperators: cliValues["no-space-around-operators"] ? false : fileOptions.useSpaceAroundOperators,
     replaceOrdinals: cliValues["no-ordinals"] ? false : fileOptions.replaceOrdinals,
-    commaPosition: cliValues["comma-position"] ?? fileOptions.commaPosition
+    commaPosition: cliValues["comma-position"] ?? fileOptions.commaPosition,
+    keepFunctionsInline: cliValues["keep-functions-inline"] ? true : fileOptions.keepFunctionsInline
   };
 }
 function formatPythonSource(text, options, logger) {
@@ -22610,6 +22723,7 @@ function runCli(argv) {
         "no-space-around-operators": { type: "boolean", default: false },
         "no-ordinals": { type: "boolean", default: false },
         "comma-position": { type: "string" },
+        "keep-functions-inline": { type: "boolean", default: false },
         config: { type: "string", short: "c" },
         help: { type: "boolean", short: "h", default: false },
         version: { type: "boolean", default: false }

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/hidenobunagai/inline-sql-toolkit/issues"
   },
-  "version": "0.4.11",
+  "version": "0.4.13",
   "icon": "icon.png",
   "type": "module",
   "bin": {
@@ -114,6 +114,12 @@
           "default": "after",
           "scope": "resource",
           "description": "%configuration.format.commaPosition.description%"
+        },
+        "inlineSql.format.keepFunctionsInline": {
+          "type": "boolean",
+          "default": false,
+          "scope": "resource",
+          "description": "%configuration.format.keepFunctionsInline.description%"
         }
       }
     },