@everystack/server 0.4.30 → 0.4.32

package/src/sql-lex.ts

@@ -0,0 +1,217 @@
+/**
+ * A dollar-quote-, string-, and comment-aware SQL lexer — deliberately DUPLICATED from
+ * `packages/cli/src/cli/derived-source.ts`'s `lex`/`splitSqlStatements`, not imported.
+ *
+ * `@everystack/server` ships into a consumer's Lambda; `@everystack/cli` is a devDependency
+ * there (see `packages/server/src/ssr.ts` for the one place server crosses this boundary
+ * today, TYPE-ONLY). Pulling a runtime function across that boundary would make `@everystack/cli`
+ * a real runtime dependency of every server bundle, for a handful of lexer lines — so this is a
+ * deliberate fork, not an oversight. SQL comment/string/dollar-quote grammar is stable; a future
+ * change to the CLI's copy (a new quoting form, a bug fix) needs its counterpart applied here by
+ * hand. `packages/server/__tests__/sql-lex.test.ts` exercises this copy directly (comments,
+ * strings, dollar-quoted bodies, nested block comments) so a REGRESSION in this file is caught
+ * even without a cross-package comparison.
+ *
+ * The E-string fix below (an `E`/`e` prefix only counts when it stands alone before the quote)
+ * now lives in BOTH copies — the CLI's `lex` also feeds `db:exec` and `db:backfill`, which run a
+ * file one statement at a time, so a miscounted boundary sends the wrong text to the database.
+ * Each copy carries the same cases in its own test file.
+ *
+ * Used by `db:query`'s write guard (plugin.ts): a payload comment-prefixed before a write
+ * keyword, or two statements joined by `;` where only the first is a harmless read, must not
+ * defeat a `^`-anchored keyword regex the way a plain `.trim()` does.
+ */
+
+export type LexState =
+  | { in: 'normal' }
+  | { in: 'single'; escaped: boolean }
+  | { in: 'double' }
+  | { in: 'dollar'; tag: string }
+  | { in: 'line-comment' }
+  | { in: 'block-comment'; depth: number };
+
+function dollarTagAt(text: string, i: number): string | null {
+  if (text[i] !== '$') return null;
+  const m = /^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/.exec(text.slice(i, i + 64));
+  return m ? m[0] : null;
+}
+
+export function lex(
+  text: string,
+  emit: (ch: string, state: LexState['in'], index: number) => void,
+): void {
+  let state: LexState = { in: 'normal' };
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    const next = text[i + 1];
+
+    if (state.in === 'normal') {
+      if (ch === '-' && next === '-') {
+        state = { in: 'line-comment' };
+        emit(ch, 'line-comment', i); i++;
+        emit(next, 'line-comment', i); i++;
+        continue;
+      }
+      if (ch === '/' && next === '*') {
+        state = { in: 'block-comment', depth: 1 };
+        emit(ch, 'block-comment', i); i++;
+        emit(next, 'block-comment', i); i++;
+        continue;
+      }
+      const tag = dollarTagAt(text, i);
+      if (tag) {
+        state = { in: 'dollar', tag };
+        for (const c of tag) { emit(c, 'dollar', i); i++; }
+        continue;
+      }
+      if (ch === "'") {
+        // `E'...'` is PostgreSQL's backslash-escaping string literal — but the `E` only counts
+        // when it STANDS ALONE before the quote. Testing the single preceding character glued
+        // that rule onto the tail of any identifier or keyword ending in `e`, which in English
+        // is most of them: `date'2024-01-01'`, `store'x'`, `xe'y'`. A backslash inside such a
+        // literal then swallowed the closing quote, the lexer stayed "inside a string" past the
+        // real end, and `splitSqlStatements` stopped seeing the `;` boundaries after it — a
+        // multi-statement payload counted as ONE, which is exactly what db:query's one-statement
+        // rule exists to catch. So require the character BEFORE the `E`/`e` to be a
+        // non-identifier character, or absent (the `E` starts the text).
+        const prev = text[i - 1];
+        const beforePrev = text[i - 2];
+        const standaloneE = (prev === 'E' || prev === 'e')
+          && (beforePrev === undefined || !/[A-Za-z0-9_$]/.test(beforePrev));
+        state = { in: 'single', escaped: standaloneE };
+        emit(ch, 'single', i); i++;
+        continue;
+      }
+      if (ch === '"') {
+        state = { in: 'double' };
+        emit(ch, 'double', i); i++;
+        continue;
+      }
+      emit(ch, 'normal', i); i++;
+      continue;
+    }
+
+    if (state.in === 'line-comment') {
+      emit(ch, 'line-comment', i); i++;
+      if (ch === '\n') state = { in: 'normal' };
+      continue;
+    }
+
+    if (state.in === 'block-comment') {
+      if (ch === '/' && next === '*') {
+        state = { in: 'block-comment', depth: state.depth + 1 };
+        emit(ch, 'block-comment', i); i++;
+        emit(next, 'block-comment', i); i++;
+        continue;
+      }
+      if (ch === '*' && next === '/') {
+        const newDepth: number = state.depth - 1;
+        emit(ch, 'block-comment', i); i++;
+        emit(next, 'block-comment', i); i++;
+        state = newDepth === 0 ? { in: 'normal' } : { in: 'block-comment', depth: newDepth };
+        continue;
+      }
+      emit(ch, 'block-comment', i); i++;
+      continue;
+    }
+
+    if (state.in === 'single') {
+      if (state.escaped && ch === '\\') {
+        emit(ch, 'single', i); i++;
+        if (i < text.length) { emit(text[i], 'single', i); i++; }
+        continue;
+      }
+      if (ch === "'" && next === "'") {
+        emit(ch, 'single', i); i++;
+        emit(next, 'single', i); i++;
+        continue;
+      }
+      emit(ch, 'single', i); i++;
+      if (ch === "'") state = { in: 'normal' };
+      continue;
+    }
+
+    if (state.in === 'double') {
+      if (ch === '"' && next === '"') {
+        emit(ch, 'double', i); i++;
+        emit(next, 'double', i); i++;
+        continue;
+      }
+      emit(ch, 'double', i); i++;
+      if (ch === '"') state = { in: 'normal' };
+      continue;
+    }
+
+    // dollar
+    if (ch === '$') {
+      const tag = dollarTagAt(text, i);
+      if (tag === state.tag) {
+        for (const c of tag) { emit(c, 'dollar', i); i++; }
+        state = { in: 'normal' };
+        continue;
+      }
+    }
+    emit(ch, 'dollar', i); i++;
+  }
+}
+
+/**
+ * Split SQL text into statements on top-level semicolons. Statements come back trimmed.
+ *
+ * A fragment counts as a statement only if it carries something OTHER than whitespace and
+ * comments. `SELECT 1; -- done` is ONE statement, not two: the trailing comment accumulates
+ * into the next-statement buffer, and counting that buffer as a statement made an ordinary
+ * query with a trailing comment fail `db:query`'s "exactly one statement" rule. A fragment
+ * with no executable text cannot hide a write, so dropping it costs the guard nothing.
+ */
+export function splitSqlStatements(text: string): string[] {
+  const statements: string[] = [];
+  let current = '';
+  const flush = (): void => {
+    const s = current.trim();
+    current = '';
+    // Comments are stripped for the emptiness TEST only — the statement itself is pushed
+    // verbatim, so the executor still runs exactly what the caller wrote.
+    if (s && stripSqlComments(s).trim()) statements.push(s);
+  };
+  lex(text, (ch, state) => {
+    if (state === 'normal' && ch === ';') {
+      flush();
+      return;
+    }
+    current += ch;
+  });
+  flush();
+  return statements;
+}
+
+/**
+ * Strip `--` and `/* *\/` comments from a single statement (line/block only — a dollar-quoted
+ * or string-literal body is left byte-for-byte since it is data, not SQL syntax). Everything
+ * else survives verbatim, including whitespace, so a stripped statement still starts with its
+ * real first keyword for a `^`-anchored check — comment removal, not normalization.
+ *
+ * Each comment run is replaced by ONE SPACE, never by nothing. PostgreSQL treats a comment as
+ * whitespace, so `INSERT/**\/INTO t VALUES (1)` is a plain INSERT to the engine. Deleting the
+ * comment outright produced `INSERTINTO t VALUES (1)`, which no longer matched a keyword check
+ * — the checked text and the executed text disagreed, and the write ran. One space keeps the
+ * two in agreement.
+ */
+export function stripSqlComments(text: string): string {
+  let out = '';
+  let inComment = false;
+  lex(text, (ch, state) => {
+    const isComment = state === 'line-comment' || state === 'block-comment';
+    if (isComment) {
+      if (!inComment) {
+        out += ' ';
+        inComment = true;
+      }
+      return;
+    }
+    inComment = false;
+    out += ch;
+  });
+  return out;
+}