inline-sql-toolkit 0.4.10 → 0.4.12

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 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` |
+  `before`, default `after`) for codebases that want a wrapped item's comma at
+  the start of the next line instead of the end of the previous one. The
+  default reproduces the previous output byte for byte, so existing files do
+  not move until the setting is turned on; `before` emits the comma at the
+  next line's indent in front of the item, and a trailing `-- comment` stays
+  with its own column (`order_id -- note` followed by `, order_date -- note`)
+  rather than pinning the comma behind it.
+- The same choice is exposed everywhere the other options are: the VS Code
+  setting, the CLI flag `--comma-position after|before`, and
+  `"commaPosition"` in `.inline-sql.json`, under the unchanged CLI flags >
+  configuration file > defaults precedence.
+- Safety: `sql-formatter` removed its own `commaPosition` option long ago, so
+  the move is a small post-pass over its output. A scanner locates the
+  wrapping separator comma and never moves one from inside a quoted string
+  (`'...'`, `"..."`, backticks) or from after a `--` line comment, and a
+  candidate whose output still fails to converge to a fixed point is skipped
+  untouched as before, so no file can be rewritten with corrupted SQL.
+
 ## 0.4.10 - 2026-09-19
 
 - CI: the npm publish job is now OIDC-only. The dormant `NPM_TOKEN` path that was

package/README.md

@@ -110,6 +110,13 @@ later atomic precondition.
   aliases (default `true`).
 - `inlineSql.format.dialect`: SQL dialect used by the formatter (`sql`,
   `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.
+- `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
@@ -144,6 +151,8 @@ When run without file arguments, the CLI reads Python source from standard input
 | `--wrap-after <20-500>`       | Preferred expression line width                                   | `88`                       |
 | `--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                                               |                            |
@@ -162,7 +171,9 @@ The CLI automatically searches for a `.inline-sql.json` file in the current work
     "wrapAfter": 88,
     "useSpaceAroundOperators": true,
     "replaceOrdinals": true,
-    "dialect": "postgresql"
+    "dialect": "postgresql",
+    "commaPosition": "after",
+    "keepFunctionsInline": false
   }
 }
 ```

package/dist/cli.js

@@ -494,7 +494,9 @@ function resolveFormatOptions(raw) {
   const useSpaceAroundOperators = raw.useSpaceAroundOperators === void 0 ? true : raw.useSpaceAroundOperators;
   const replaceOrdinals2 = raw.replaceOrdinals === void 0 ? true : raw.replaceOrdinals;
   const dialect = raw.dialect === void 0 ? "postgresql" : raw.dialect;
-  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") {
+  const commaPosition = raw.commaPosition === void 0 ? "after" : raw.commaPosition;
+  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 {
@@ -505,7 +507,9 @@ function resolveFormatOptions(raw) {
       wrapAfter,
       useSpaceAroundOperators,
       replaceOrdinals: replaceOrdinals2,
-      dialect
+      dialect,
+      commaPosition,
+      keepFunctionsInline
     }
   };
 }
@@ -1584,6 +1588,144 @@ function breakTrailingDistributeLines(text) {
 ${indent}${rest}`
   );
 }
+function wrappingComma(line) {
+  let comma = -1;
+  for (let index = 0; index < line.length; index++) {
+    const char = line[index];
+    if (char === "'" || char === '"' || char === "`") {
+      for (index += 1; index < line.length && line[index] !== char; index++) {
+        if (line[index] === "\\") index += 1;
+      }
+      continue;
+    }
+    if (char === "-" && line[index + 1] === "-") break;
+    if (char === ",") comma = index;
+  }
+  if (comma < 0) return -1;
+  return /^[ \t]*(?:--.*)?$/.test(line.slice(comma + 1)) ? comma : -1;
+}
+function moveCommasToLineStarts(text) {
+  const lines = text.split("\n");
+  for (let index = 0; index + 1 < lines.length; index++) {
+    const line = lines[index] ?? "";
+    const next = lines[index + 1] ?? "";
+    if (next.trim() === "") continue;
+    const comma = wrappingComma(line);
+    if (comma < 0 || line.slice(0, comma).trim() === "") continue;
+    const nextParts = /^([ \t]*)([\s\S]*)$/.exec(next);
+    const indent = nextParts?.[1] ?? "";
+    const content = nextParts?.[2] ?? "";
+    lines[index] = `${line.slice(0, comma)}${line.slice(comma + 1)}`.trimEnd();
+    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, {
@@ -1598,6 +1740,12 @@ 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);
+  }
   formatted = breakTrailingDistributeLines(formatted);
   const restored = restoreProtected(formatted, plan);
   const resolved = options.replaceOrdinals ? replaceOrdinals(restored) : restored;
@@ -1824,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} 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 {
@@ -22476,6 +22624,8 @@ var USAGE = `Usage: inline-sql-toolkit [options] [files...]
       --wrap-after <20-500>        (default: 88)
       --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) {
@@ -22534,7 +22684,9 @@ function buildRawOptions(fileOptions, cliValues) {
     indentWidth: cliValues["indent-width"] !== void 0 ? Number(cliValues["indent-width"]) : fileOptions.indentWidth,
     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
+    replaceOrdinals: cliValues["no-ordinals"] ? false : fileOptions.replaceOrdinals,
+    commaPosition: cliValues["comma-position"] ?? fileOptions.commaPosition,
+    keepFunctionsInline: cliValues["keep-functions-inline"] ? true : fileOptions.keepFunctionsInline
   };
 }
 function formatPythonSource(text, options, logger) {
@@ -22570,6 +22722,8 @@ function runCli(argv) {
         "wrap-after": { type: "string" },
         "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.10",
+  "version": "0.4.12",
   "icon": "icon.png",
   "type": "module",
   "bin": {
@@ -104,6 +104,22 @@
           "default": "postgresql",
           "scope": "resource",
           "description": "%configuration.format.dialect.description%"
+        },
+        "inlineSql.format.commaPosition": {
+          "type": "string",
+          "enum": [
+            "after",
+            "before"
+          ],
+          "default": "after",
+          "scope": "resource",
+          "description": "%configuration.format.commaPosition.description%"
+        },
+        "inlineSql.format.keepFunctionsInline": {
+          "type": "boolean",
+          "default": false,
+          "scope": "resource",
+          "description": "%configuration.format.keepFunctionsInline.description%"
         }
       }
     },