@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/chunk-JU64Y7HM.mjs

@@ -0,0 +1,299 @@
+import { CDCError } from './chunk-UC3SCMIN.mjs';
+
+// src/core/live/sql-tokens.ts
+var WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "\f", "\v"]);
+function isWordStart(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+}
+function isWordPart(c) {
+  return isWordStart(c) || c >= "0" && c <= "9" || c === "$";
+}
+function isDigit(c) {
+  return c >= "0" && c <= "9";
+}
+function tokenizeSql(sql) {
+  const tokens = [];
+  const n = sql.length;
+  let i = 0;
+  let depth = 0;
+  while (i < n) {
+    const c = sql[i];
+    if (WHITESPACE.has(c)) {
+      i++;
+      continue;
+    }
+    if (c === "-" && sql[i + 1] === "-") {
+      i += 2;
+      while (i < n && sql[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && sql[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(sql[i] === "*" && sql[i + 1] === "/")) i++;
+      i = i < n ? i + 2 : n;
+      continue;
+    }
+    if (c === "'") {
+      const end = skipQuoted(sql, i, "'");
+      tokens.push(token("string", sql.slice(i, end), i, end, depth, false));
+      i = end;
+      continue;
+    }
+    if (c === '"' || c === "`") {
+      const delimited = readDelimited(sql, i, c);
+      tokens.push(token("word", delimited.value, i, delimited.next, depth, true));
+      i = delimited.next;
+      continue;
+    }
+    if (c === "[") {
+      const close = sql.indexOf("]", i + 1);
+      const end = close === -1 ? n : close + 1;
+      tokens.push(token("word", sql.slice(i + 1, end - 1), i, end, depth, true));
+      i = end;
+      continue;
+    }
+    if (c === "(" || c === ")") {
+      const at = depth;
+      if (c === "(") depth++;
+      else if (depth > 0) depth--;
+      tokens.push(token("punct", c, i, i + 1, c === "(" ? at : depth, false));
+      i++;
+      continue;
+    }
+    if (c === "?" || c === ":" || c === "@" || c === "$") {
+      const param = readParam(sql, i);
+      if (param !== null) {
+        tokens.push(token("param", param.name, i, param.next, depth, false));
+        i = param.next;
+        continue;
+      }
+    }
+    if (isDigit(c) || c === "." && isDigit(sql[i + 1] ?? "")) {
+      let j = i;
+      while (j < n && (isDigit(sql[j]) || sql[j] === "." || sql[j] === "e" || sql[j] === "E" || sql[j] === "x")) {
+        if ((sql[j] === "e" || sql[j] === "E") && (sql[j + 1] === "+" || sql[j + 1] === "-")) j++;
+        j++;
+      }
+      tokens.push(token("number", sql.slice(i, j), i, j, depth, false));
+      i = j;
+      continue;
+    }
+    if (isWordStart(c)) {
+      let j = i + 1;
+      while (j < n && isWordPart(sql[j])) j++;
+      const word = sql.slice(i, j);
+      if ((word === "x" || word === "X") && sql[j] === "'") {
+        const end = skipQuoted(sql, j, "'");
+        tokens.push(token("string", sql.slice(i, end), i, end, depth, false));
+        i = end;
+        continue;
+      }
+      tokens.push(token("word", word, i, j, depth, false));
+      i = j;
+      continue;
+    }
+    tokens.push(token("punct", c, i, i + 1, depth, false));
+    i++;
+  }
+  return tokens;
+}
+function token(kind, value, start, end, depth, quoted) {
+  return { kind, value, lower: value.toLowerCase(), start, end, depth, quoted };
+}
+function readParam(sql, start) {
+  const marker = sql[start];
+  let i = start + 1;
+  const n = sql.length;
+  if (marker === "?") {
+    while (i < n && isDigit(sql[i])) i++;
+    return { name: sql.slice(start, i), next: i };
+  }
+  if (marker === ":" && sql[start + 1] === ":") return null;
+  while (i < n && isWordPart(sql[i])) i++;
+  if (i === start + 1) return null;
+  return { name: sql.slice(start, i), next: i };
+}
+function skipQuoted(sql, start, quote) {
+  const n = sql.length;
+  let i = start + 1;
+  while (i < n) {
+    if (sql[i] === quote) {
+      if (sql[i + 1] === quote) {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return n;
+}
+function readDelimited(sql, start, quote) {
+  const n = sql.length;
+  let i = start + 1;
+  let value = "";
+  while (i < n) {
+    if (sql[i] === quote) {
+      if (sql[i + 1] === quote) {
+        value += quote;
+        i += 2;
+        continue;
+      }
+      return { value, next: i + 1 };
+    }
+    value += sql[i];
+    i++;
+  }
+  return { value, next: n };
+}
+function parameterName(token2) {
+  if (token2.kind !== "param") return null;
+  if (token2.value.startsWith("?")) return null;
+  return token2.value.slice(1);
+}
+
+// src/core/live/statement-clauses.ts
+function unsupported(sql, reason) {
+  return new CDCError(`Cannot open a live query for '${sql}': ${reason}`);
+}
+function findClauses(sql, body) {
+  let fromIndex = -1;
+  let whereIndex = -1;
+  let orderIndex = -1;
+  let limitIndex = -1;
+  for (let i = 1; i < body.length; i++) {
+    const token2 = body[i];
+    if (token2.depth !== 0 || token2.kind !== "word" || token2.quoted) continue;
+    if (token2.lower === "from" && fromIndex === -1) fromIndex = i;
+    else if (token2.lower === "where" && whereIndex === -1) whereIndex = i;
+    else if (token2.lower === "order" && body[i + 1]?.lower === "by" && orderIndex === -1) orderIndex = i;
+    else if (token2.lower === "limit" && limitIndex === -1) limitIndex = i;
+  }
+  if (fromIndex === -1) throw unsupported(sql, "a live query reads from a table");
+  const boundaryAfter = (index) => {
+    for (const candidate of [whereIndex, orderIndex, limitIndex]) {
+      if (candidate > index) return body[candidate].start;
+    }
+    return body[body.length - 1].end;
+  };
+  const statementEnd = body[body.length - 1].end;
+  const tailIndex = orderIndex !== -1 ? orderIndex : limitIndex;
+  return {
+    tailStart: tailIndex === -1 ? statementEnd : body[tailIndex].start,
+    statementEnd,
+    selectStart: body[1] === void 0 ? body[0].end : body[1].start,
+    fromKeyword: body[fromIndex].start,
+    fromStart: body[fromIndex].end,
+    fromEnd: boundaryAfter(fromIndex),
+    whereStart: whereIndex === -1 ? null : body[whereIndex].end,
+    whereEnd: whereIndex === -1 ? null : boundaryAfter(whereIndex),
+    orderStart: orderIndex === -1 ? null : body[orderIndex + 1].end,
+    orderEnd: orderIndex === -1 ? null : boundaryAfter(orderIndex),
+    limitStart: limitIndex === -1 ? null : limitIndex
+  };
+}
+function readSource(sql, body, clauses) {
+  const source = body.filter((token2) => token2.start >= clauses.fromStart && token2.end <= clauses.fromEnd);
+  if (source.length === 0 || source[0].kind !== "word") {
+    throw unsupported(sql, "a live query names one table after FROM");
+  }
+  if (source.some((token2) => token2.kind === "punct" && (token2.value === "," || token2.value === "("))) {
+    throw unsupported(sql, "a live query reads one table, so a join or a subquery in FROM is not maintainable");
+  }
+  const table = source[0].value;
+  const rest = source.slice(1);
+  if (rest.length === 0) return { table, alias: null };
+  const labelled = rest[0].lower === "as" && !rest[0].quoted;
+  const aliasToken = labelled ? rest[1] : rest[0];
+  if (rest.length > (labelled ? 2 : 1) || aliasToken === void 0 || aliasToken.kind !== "word") {
+    throw unsupported(sql, "a live query names one table after FROM, with an optional alias");
+  }
+  return { table, alias: aliasToken.value };
+}
+function readSelectItems(sql, body, clauses) {
+  const spans = splitTopLevel(body, clauses.selectStart, clauses.fromKeyword);
+  return spans.map((span) => readSelectItem(sql, span));
+}
+function readSelectItem(sql, span) {
+  const last = span[span.length - 1];
+  const star = span.some((token2) => token2.kind === "punct" && token2.value === "*");
+  if (span.length >= 3 && span[span.length - 2].lower === "as" && last.kind === "word") {
+    return { expression: sql.slice(span[0].start, span[span.length - 2].start).trim(), alias: last.value, star };
+  }
+  if (span.length === 1 && last.kind === "word") {
+    return { expression: sql.slice(span[0].start, last.end), alias: last.value, star: false };
+  }
+  if (span.length === 3 && span[1].value === "." && last.kind === "word" && !star) {
+    return { expression: sql.slice(span[0].start, last.end), alias: last.value, star: false };
+  }
+  return { expression: sql.slice(span[0].start, last.end), alias: null, star };
+}
+function readSortTerms(sql, body, clauses) {
+  const start = clauses.orderStart;
+  const end = clauses.orderEnd;
+  if (start === null || end === null) return [];
+  return splitTopLevel(body, start, end).map((span) => readSortTerm(sql, span));
+}
+function readSortTerm(sql, span) {
+  let end = span.length;
+  let nulls = null;
+  let direction = "asc";
+  if (end >= 2 && span[end - 2].lower === "nulls") {
+    const placement = span[end - 1].lower;
+    if (placement !== "first" && placement !== "last") {
+      throw unsupported(sql, "NULLS in an ORDER BY term is followed by FIRST or LAST");
+    }
+    nulls = placement;
+    end -= 2;
+  }
+  if (end >= 1 && (span[end - 1].lower === "asc" || span[end - 1].lower === "desc")) {
+    direction = span[end - 1].lower === "desc" ? "desc" : "asc";
+    end -= 1;
+  }
+  if (end === 0) throw unsupported(sql, "an ORDER BY term needs an expression");
+  const collation = end >= 2 && span[end - 2].lower === "collate" ? span[end - 1].value : null;
+  return {
+    expression: sql.slice(span[0].start, span[end - 1].end),
+    direction,
+    nulls: nulls ?? (direction === "asc" ? "first" : "last"),
+    collation
+  };
+}
+function readWindow(sql, body, clauses) {
+  if (clauses.limitStart === null) return { limit: null, offset: null };
+  const tail = body.slice(clauses.limitStart + 1);
+  const separator = tail.findIndex((token2) => token2.depth === 0 && (token2.value === "," || token2.lower === "offset"));
+  if (separator === -1) return { limit: readBound(sql, tail), offset: null };
+  const first = readBound(sql, tail.slice(0, separator));
+  const second = readBound(sql, tail.slice(separator + 1));
+  if (tail[separator].value === ",") return { limit: second, offset: first };
+  return { limit: first, offset: second };
+}
+function readBound(sql, span) {
+  const token2 = span.length === 1 ? span[0] : void 0;
+  if (token2?.kind === "number") {
+    const literal = Number(token2.value);
+    if (!Number.isInteger(literal) || literal < 0) {
+      throw unsupported(sql, "LIMIT and OFFSET in a live query take a non-negative whole number");
+    }
+    return { kind: "literal", literal, parameter: "", position: token2.start };
+  }
+  if (token2?.kind === "param") {
+    return { kind: "parameter", literal: 0, parameter: token2.value, position: token2.start };
+  }
+  throw unsupported(sql, "LIMIT and OFFSET in a live query take a number or a bound parameter");
+}
+function splitTopLevel(body, start, end) {
+  const spans = [[]];
+  for (const token2 of body) {
+    if (token2.start < start || token2.end > end) continue;
+    if (token2.depth === 0 && token2.kind === "punct" && token2.value === ",") {
+      spans.push([]);
+      continue;
+    }
+    spans[spans.length - 1].push(token2);
+  }
+  return spans.filter((span) => span.length > 0);
+}
+
+export { findClauses, parameterName, readSelectItems, readSortTerms, readSource, readWindow, tokenizeSql, unsupported };

package/dist/{chunk-CW6S3WL5.mjs → chunk-JZGINXTN.mjs}

@@ -1,5 +1,5 @@
-import { assertSqlAllowed, encodeWireRowsInPlace } from './chunk-GEZUUIKV.mjs';
-import { SirannonError, QueryError } from './chunk-YPYVQJ4C.mjs';
+import { assertSqlAllowed, encodeWireRowsInPlace } from './chunk-D7LAYTKN.mjs';
+import { SirannonError, QueryError } from './chunk-UC3SCMIN.mjs';
 
 // src/core/query-executor.ts
 var STATEMENT_CACHE_CAPACITY = 128;
@@ -69,8 +69,10 @@ async function queryOne(conn, sql, params) {
     throw asQueryError(err, sql);
   }
 }
-async function execute(conn, sql, params) {
-  assertSqlAllowed(sql);
+async function execute(conn, sql, params, trusted = false) {
+  if (!trusted) {
+    assertSqlAllowed(sql);
+  }
   try {
     const stmt = await getStatement(conn, sql);
     const result = await stmt.run(...bindParams(params));
@@ -102,7 +104,7 @@ async function runUnit(conn, unit) {
   const values = new Array(unit.statements.length);
   for (let i = 0; i < unit.statements.length; i++) {
     const statement = unit.statements[i];
-    values[i] = await execute(conn, statement.sql, statement.params);
+    values[i] = await execute(conn, statement.sql, statement.params, statement.trusted === true);
   }
   return values;
 }

package/dist/{chunk-CJLYFDP5.mjs → chunk-LFZ37BSX.mjs}

@@ -1,4 +1,4 @@
-import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+import { SirannonError } from './chunk-UC3SCMIN.mjs';
 
 // src/core/driver/synchronous.ts
 var DEFAULT_SYNCHRONOUS = "normal";

package/dist/chunk-LNY2VVHE.mjs

@@ -0,0 +1,18 @@
+import { MigrationError } from './chunk-UC3SCMIN.mjs';
+
+// src/core/migrations/lazy-down.ts
+var LAZY_DOWN_SQL = /* @__PURE__ */ Symbol("sirannon.file-migration.lazy-down");
+
+// src/core/migrations/filename.ts
+var MIGRATION_FILENAME_PATTERN = /^(\d+)_(\w+)\.(up|down)\.sql$/;
+function parseMigrationFilename(filename) {
+  const match = MIGRATION_FILENAME_PATTERN.exec(filename);
+  if (!match) return null;
+  const version = parseInt(match[1], 10);
+  if (!Number.isFinite(version) || version <= 0 || !Number.isSafeInteger(version)) {
+    throw new MigrationError(`Invalid migration version: ${match[1]}`, version, "MIGRATION_VALIDATION_ERROR");
+  }
+  return { version, name: match[2], direction: match[3] };
+}
+
+export { LAZY_DOWN_SQL, MIGRATION_FILENAME_PATTERN, parseMigrationFilename };