tina4-nodejs 3.13.46 → 3.13.47

package/CLAUDE.md

@@ -1,4 +1,4 @@
-# CLAUDE.md - AI Developer Guide for tina4-nodejs (v3.13.46)
+# CLAUDE.md - AI Developer Guide for tina4-nodejs (v3.13.47)
 
 > This file helps AI assistants (Claude, Copilot, Cursor, etc.) understand and work on this codebase effectively.
 

package/package.json

@@ -3,7 +3,7 @@
 
 
 
-  "version": "3.13.46",
+  "version": "3.13.47",
 
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript \u2014 54 built-in features, zero dependencies",

package/packages/core/src/scss.ts

@@ -122,6 +122,9 @@ function compileString(
   // 5. Resolve @include
   scss = resolveIncludes(scss, mixins);
 
+  // 5.5. Resolve #{ ... } interpolation (before $var substitution + nesting).
+  scss = resolveInterpolation(scss, variables);
+
   // 6. Substitute variables
   scss = substituteVariables(scss, variables);
 
@@ -182,6 +185,26 @@ function substituteVariables(scss: string, variables: Record<string, string>): s
   return scss;
 }
 
+/**
+ * Resolve SCSS `#{ ... }` interpolation. Each `#{ expr }` is replaced by its
+ * resolved inner text: a `$variable` inside the braces resolves to its value,
+ * anything else is inlined verbatim (trimmed). This lets a value carry a
+ * variable inside a string context plain `$var` substitution can't reach —
+ * e.g. `calc(100% - #{$gap})` → `calc(100% - 20px)` — and lets a variable
+ * appear in a selector (`.icon-#{$name}` → `.icon-home`). Run BEFORE nested
+ * rule flattening so the literal braces never confuse the block matcher.
+ */
+function resolveInterpolation(scss: string, variables: Record<string, string>): string {
+  const sorted = Object.keys(variables).sort((a, b) => b.length - a.length);
+  return scss.replace(/#\{([^{}]*)\}/g, (_m, inner: string) => {
+    let resolved = inner.trim();
+    for (const name of sorted) {
+      resolved = resolved.replaceAll(`$${name}`, variables[name]);
+    }
+    return resolved;
+  });
+}
+
 // ── Mixins ───────────────────────────────────────────────────────
 
 function extractMixins(

package/packages/orm/src/migration.ts

@@ -569,54 +569,137 @@ export function normalizeQuotes(sql: string): string {
 }
 
 /**
- * Split SQL text into individual statements on the given delimiter.
+ * Split SQL text into individual statements with a single-pass, quote- and
+ * comment-aware scanner. The split decision is made character by character so
+ * the delimiter only ever fires in real statement position.
  *
- * Strips line comments (`-- ...`) and block comments, handles stored
- * procedure blocks delimited by `$$` or `//`.
+ * This is the fix for issue #54: the old implementation split on `delimiter`
+ * BEFORE stripping `-- …` line comments, so a `;` inside a line comment
+ * fragmented one statement into several broken pieces. A scanner that knows
+ * where it is (code / comment / string) cannot make that mistake.
+ *
+ * Handled, in priority order, only when NOT already inside a stored-proc block:
+ * - `$$ … $$` and `// … //` stored-proc blocks are kept intact (inner `;` never
+ *   splits). A `//` preceded by `:` is a URL scheme (`https://…`), not a delimiter.
+ * - `/* … *​/` block comments are stripped.
+ * - `-- …` line comments are stripped to end of line (the newline is kept).
+ * - `'…'` single-quoted strings and `"…"` double-quoted identifiers are copied
+ *   verbatim, honouring the SQL doubled-quote escape (`''` / `""`); a `;`, `--`
+ *   or `/*` inside a literal is data, not a delimiter or comment.
+ * Mirrors the tina4-python `_split_statements` / tina4-php scanner (parity).
  */
 export function splitStatements(sql: string, delimiter = ";"): string[] {
   // Normalize smart/curly quotes to straight ASCII first, so SQL pasted from
-  // an editor/doc (which converts " → “ ” and ' → ‘ ’) actually runs. Mirrors
-  // Python's _split_statements applying _normalize_quotes as its first line.
+  // an editor/doc (which converts " → “ ” and ' → ‘ ’) actually runs.
   sql = normalizeQuotes(sql);
 
-  // Extract blocks delimited by $$ or // first, replacing with placeholders
-  const blocks: string[] = [];
-  const saveBlock = (_match: string, _p1: string): string => {
-    blocks.push(_match);
-    return `__BLOCK_${blocks.length - 1}__`;
-  };
+  const statements: string[] = [];
+  let current = "";
+  const n = sql.length;
+  const dlen = delimiter.length;
+  let i = 0;
+  let inDollarBlock = false;
+  let inSlashBlock = false;
+
+  while (i < n) {
+    const ch = sql[i];
+
+    // $$ … $$ stored-proc block (toggle).
+    if (!inSlashBlock && ch === "$" && i + 1 < n && sql[i + 1] === "$") {
+      current += "$$";
+      i += 2;
+      inDollarBlock = !inDollarBlock;
+      continue;
+    }
+
+    // // … // stored-proc block (toggle) — but NOT a `://` URL scheme.
+    if (
+      !inDollarBlock && ch === "/" && i + 1 < n && sql[i + 1] === "/" &&
+      !(i > 0 && sql[i - 1] === ":")
+    ) {
+      current += "//";
+      i += 2;
+      inSlashBlock = !inSlashBlock;
+      continue;
+    }
 
-  let processed = sql.replace(/\$\$([\s\S]*?)\$\$/g, saveBlock);
-  // The `//` delimiters must NOT be preceded by a colon, so a URL scheme
-  // (`https://…`) or other `://` literal inside a migration is never captured
-  // as an opaque stored-proc block (it would otherwise swallow everything
-  // between two `//` occurrences and skip statement splitting/cleaning).
-  // Negative lookbehind `(?<!:)` mirrors Python's runner.
-  processed = processed.replace(/(?<!:)\/\/([\s\S]*?)(?<!:)\/\//g, saveBlock);
+    // Inside a stored-proc block: consume verbatim (inner ; never splits).
+    if (inDollarBlock || inSlashBlock) {
+      current += ch;
+      i += 1;
+      continue;
+    }
 
-  // Remove block comments (/* ... */)
-  const clean = processed.replace(/\/\*[\s\S]*?\*\//g, "");
+    // Block comment /* … */ — stripped.
+    if (ch === "/" && i + 1 < n && sql[i + 1] === "*") {
+      const end = sql.indexOf("*/", i + 2);
+      i = end !== -1 ? end + 2 : n;
+      continue;
+    }
 
-  const statements: string[] = [];
-  for (const part of clean.split(delimiter)) {
-    const lines: string[] = [];
-    for (const line of part.split("\n")) {
-      const stripped = line.trim();
-      if (!stripped || stripped.startsWith("--")) continue;
-      // Remove inline comments
-      const commentPos = line.indexOf("--");
-      lines.push(commentPos >= 0 ? line.slice(0, commentPos) : line);
+    // Line comment -- … — stripped to end of line; the newline is left for the
+    // next iteration so line structure (and NEXT-line boundaries) survive.
+    if (ch === "-" && i + 1 < n && sql[i + 1] === "-") {
+      const end = sql.indexOf("\n", i + 2);
+      i = end !== -1 ? end : n;
+      continue;
     }
-    let cleaned = lines.join("\n").trim();
 
-    // Restore block placeholders
-    for (let i = 0; i < blocks.length; i++) {
-      cleaned = cleaned.replace(`__BLOCK_${i}__`, blocks[i]);
+    // Single-quoted string literal — '' escapes a quote. Copied verbatim.
+    if (ch === "'") {
+      current += "'";
+      i += 1;
+      while (i < n) {
+        if (sql[i] === "'" && i + 1 < n && sql[i + 1] === "'") {
+          current += "''";
+          i += 2;
+        } else if (sql[i] === "'") {
+          current += "'";
+          i += 1;
+          break;
+        } else {
+          current += sql[i];
+          i += 1;
+        }
+      }
+      continue;
+    }
+
+    // Double-quoted identifier — "" escapes a quote. Same verbatim handling.
+    if (ch === '"') {
+      current += '"';
+      i += 1;
+      while (i < n) {
+        if (sql[i] === '"' && i + 1 < n && sql[i + 1] === '"') {
+          current += '""';
+          i += 2;
+        } else if (sql[i] === '"') {
+          current += '"';
+          i += 1;
+          break;
+        } else {
+          current += sql[i];
+          i += 1;
+        }
+      }
+      continue;
     }
 
-    if (cleaned) statements.push(cleaned);
+    // Statement delimiter — only reached outside blocks/comments/strings.
+    if (dlen > 0 && sql.startsWith(delimiter, i)) {
+      const stmt = current.trim();
+      if (stmt) statements.push(stmt);
+      current = "";
+      i += dlen;
+      continue;
+    }
+
+    current += ch;
+    i += 1;
   }
+
+  const stmt = current.trim();
+  if (stmt) statements.push(stmt);
   return statements;
 }