@delali/sirannon-db 0.1.6 → 0.1.8

package/dist/chunk-CW6S3WL5.mjs

@@ -0,0 +1,222 @@
+import { assertSqlAllowed, encodeWireRowsInPlace } from './chunk-GEZUUIKV.mjs';
+import { SirannonError, QueryError } from './chunk-YPYVQJ4C.mjs';
+
+// src/core/query-executor.ts
+var STATEMENT_CACHE_CAPACITY = 128;
+var statementCaches = /* @__PURE__ */ new WeakMap();
+async function getStatement(conn, sql) {
+  let cache = statementCaches.get(conn);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    statementCaches.set(conn, cache);
+  }
+  const cached = cache.get(sql);
+  if (cached) {
+    cache.delete(sql);
+    cache.set(sql, cached);
+    return cached;
+  }
+  const pending = conn.prepare(sql);
+  cache.set(sql, pending);
+  if (cache.size > STATEMENT_CACHE_CAPACITY) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) {
+      cache.delete(oldest);
+    }
+  }
+  try {
+    return await pending;
+  } catch (err) {
+    cache.delete(sql);
+    throw err;
+  }
+}
+function bindParams(params) {
+  if (params === void 0) return [];
+  if (Array.isArray(params)) return params;
+  return [params];
+}
+function asQueryError(err, sql) {
+  if (err instanceof SirannonError) return err;
+  return new QueryError(err instanceof Error ? err.message : String(err), sql);
+}
+async function query(conn, sql, params) {
+  assertSqlAllowed(sql);
+  try {
+    const stmt = await getStatement(conn, sql);
+    return await stmt.all(...bindParams(params));
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
+}
+async function queryForWire(conn, sql, params) {
+  assertSqlAllowed(sql);
+  try {
+    const stmt = await getStatement(conn, sql);
+    const bound = bindParams(params);
+    const rows = stmt.allRaw ? await stmt.allRaw(...bound) : await stmt.all(...bound);
+    return encodeWireRowsInPlace(rows);
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
+}
+async function queryOne(conn, sql, params) {
+  assertSqlAllowed(sql);
+  try {
+    const stmt = await getStatement(conn, sql);
+    return await stmt.get(...bindParams(params));
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
+}
+async function execute(conn, sql, params) {
+  assertSqlAllowed(sql);
+  try {
+    const stmt = await getStatement(conn, sql);
+    const result = await stmt.run(...bindParams(params));
+    return {
+      changes: result.changes,
+      lastInsertRowId: result.lastInsertRowId
+    };
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
+}
+async function executeGroup(conn, units) {
+  const outcomes = new Array(units.length);
+  try {
+    await conn.exec("BEGIN");
+    for (let i = 0; i < units.length; i++) {
+      outcomes[i] = { ok: true, values: await runUnit(conn, units[i]) };
+    }
+  } catch {
+    await rollbackQuietly(conn);
+    return executeGroupIsolated(conn, units);
+  }
+  const failure = await execControl(conn, "COMMIT");
+  if (!failure) return outcomes;
+  await rollbackQuietly(conn);
+  return outcomes.map(() => ({ ok: false, error: failure }));
+}
+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);
+  }
+  return values;
+}
+function controlError(err, sql) {
+  return asQueryError(err, sql);
+}
+async function execControl(conn, sql) {
+  try {
+    await conn.exec(sql);
+    return null;
+  } catch (err) {
+    return controlError(err, sql);
+  }
+}
+async function rollbackQuietly(conn) {
+  try {
+    await conn.exec("ROLLBACK");
+  } catch {
+  }
+}
+async function executeGroupIsolated(conn, units) {
+  const outcomes = new Array(units.length);
+  await conn.exec("BEGIN");
+  for (let i = 0; i < units.length; i++) {
+    const attempt = await runIsolatedUnit(conn, units[i], `sirannon_gc_${i}`);
+    outcomes[i] = attempt.outcome;
+    if (!attempt.contained) return rerunSurvivorsAlone(conn, units, outcomes, i);
+  }
+  const failure = await execControl(conn, "COMMIT");
+  if (!failure) return outcomes;
+  await rollbackQuietly(conn);
+  return outcomes.map((outcome) => outcome.ok ? { ok: false, error: failure } : outcome);
+}
+async function runIsolatedUnit(conn, unit, savepoint) {
+  const notOpened = await execControl(conn, `SAVEPOINT ${savepoint}`);
+  if (notOpened) return { outcome: { ok: false, error: notOpened }, contained: false };
+  let values;
+  try {
+    values = await runUnit(conn, unit);
+  } catch (err) {
+    return { outcome: { ok: false, error: err }, contained: await unwind(conn, savepoint) };
+  }
+  const notReleased = await execControl(conn, `RELEASE ${savepoint}`);
+  if (notReleased) return { outcome: { ok: false, error: notReleased }, contained: false };
+  return { outcome: { ok: true, values }, contained: true };
+}
+async function unwind(conn, savepoint) {
+  if (await execControl(conn, `ROLLBACK TO ${savepoint}`)) return false;
+  return await execControl(conn, `RELEASE ${savepoint}`) === null;
+}
+async function rerunSurvivorsAlone(conn, units, outcomes, failed) {
+  await rollbackQuietly(conn);
+  for (let i = 0; i < units.length; i++) {
+    if (i === failed) continue;
+    outcomes[i] = await runUnitAlone(conn, units[i]);
+  }
+  return outcomes;
+}
+async function runUnitAlone(conn, unit) {
+  const notBegun = await execControl(conn, "BEGIN");
+  if (notBegun) return { ok: false, error: notBegun };
+  let values;
+  try {
+    values = await runUnit(conn, unit);
+  } catch (err) {
+    await rollbackQuietly(conn);
+    return { ok: false, error: err };
+  }
+  const notCommitted = await execControl(conn, "COMMIT");
+  if (!notCommitted) return { ok: true, values };
+  await rollbackQuietly(conn);
+  return { ok: false, error: notCommitted };
+}
+async function forEachBatchRow(conn, sql, paramsBatch, sink) {
+  assertSqlAllowed(sql);
+  try {
+    const stmt = await getStatement(conn, sql);
+    for (const params of paramsBatch) {
+      const result = await stmt.run(...bindParams(params));
+      sink(result.changes, result.lastInsertRowId);
+    }
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
+}
+async function executeBatch(conn, sql, paramsBatch) {
+  if (conn.runBatch) {
+    assertSqlAllowed(sql);
+    try {
+      return await conn.runBatch(sql, paramsBatch.map(bindParams));
+    } catch (err) {
+      throw asQueryError(err, sql);
+    }
+  }
+  const results = [];
+  await forEachBatchRow(conn, sql, paramsBatch, (changes, lastInsertRowId) => {
+    results.push({ changes, lastInsertRowId });
+  });
+  return results;
+}
+async function executeBatchSummary(conn, sql, paramsBatch) {
+  if (conn.runBatchSummary) {
+    assertSqlAllowed(sql);
+    try {
+      return await conn.runBatchSummary(sql, paramsBatch.map(bindParams));
+    } catch (err) {
+      throw asQueryError(err, sql);
+    }
+  }
+  let changes = 0;
+  await forEachBatchRow(conn, sql, paramsBatch, (rowChanges) => {
+    changes += rowChanges;
+  });
+  return { rowsLoaded: paramsBatch.length, changes };
+}
+
+export { bindParams, execute, executeBatch, executeBatchSummary, executeGroup, query, queryForWire, queryOne };

package/dist/chunk-DVWQD3GF.mjs

@@ -0,0 +1,49 @@
+// src/core/errors.ts
+var SirannonError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SirannonError";
+  }
+};
+
+// src/core/driver/define.ts
+function defineDriver(config) {
+  if (!config.capabilities || typeof config.open !== "function") {
+    throw new SirannonError("Driver must define capabilities and open()", "INVALID_DRIVER");
+  }
+  if (config.worker !== void 0 && typeof config.worker.specifier !== "string") {
+    throw new SirannonError("Driver worker entry must define a string specifier", "INVALID_DRIVER");
+  }
+  return Object.freeze({
+    capabilities: Object.freeze({ ...config.capabilities }),
+    open: config.open,
+    ...config.worker ? { worker: Object.freeze({ ...config.worker }) } : {},
+    ...config.startWriterHost ? { startWriterHost: config.startWriterHost } : {},
+    ...config.createWriterContext ? { createWriterContext: config.createWriterContext } : {},
+    ...config.createBackupEngine ? { createBackupEngine: config.createBackupEngine } : {},
+    ...config.resolveExtensionPath ? { resolveExtensionPath: config.resolveExtensionPath } : {}
+  });
+}
+
+// src/core/driver/synchronous.ts
+var DEFAULT_SYNCHRONOUS = "normal";
+var SYNCHRONOUS_PRAGMA_VALUES = {
+  off: "OFF",
+  normal: "NORMAL",
+  full: "FULL",
+  extra: "EXTRA"
+};
+function synchronousPragmaValue(level) {
+  const resolved = level ?? DEFAULT_SYNCHRONOUS;
+  const value = SYNCHRONOUS_PRAGMA_VALUES[resolved];
+  if (value === void 0) {
+    throw new SirannonError(
+      `Invalid synchronous level '${String(resolved)}': expected 'off', 'normal', 'full', or 'extra'`,
+      "INVALID_SYNCHRONOUS"
+    );
+  }
+  return value;
+}
+
+export { defineDriver, synchronousPragmaValue };

package/dist/chunk-GEZUUIKV.mjs

@@ -0,0 +1,268 @@
+import { ForbiddenSqlError } from './chunk-YPYVQJ4C.mjs';
+
+// src/core/internal-tables.ts
+var INTERNAL_TABLE_PREFIX = "_sirannon_";
+var CHANGES_TABLE = "_sirannon_changes";
+var META_TABLE = "_sirannon_meta";
+var MIGRATIONS_TABLE = "_sirannon_migrations";
+var PEER_STATE_TABLE = "_sirannon_peer_state";
+var APPLIED_CHANGES_TABLE = "_sirannon_applied_changes";
+var COLUMN_VERSIONS_TABLE = "_sirannon_column_versions";
+var SYNC_STATE_TABLE = "_sirannon_sync_state";
+var CDC_TRIGGER_PREFIX = "_sirannon_trg_";
+var SIRANNON_PREFIX = "_sirannon";
+var SQLITE_PREFIX = "sqlite_";
+var SIRANNON_MESSAGE = "Access to internal tables is not permitted: identifiers beginning with '_sirannon' are reserved";
+var SQLITE_WRITE_MESSAGE = "The SQLite schema catalogue is read-only: statements that modify a 'sqlite_' identifier are not permitted";
+var ATTACH_MESSAGE = "ATTACH and DETACH statements are not permitted";
+var WRITABLE_SCHEMA_MESSAGE = "PRAGMA writable_schema is not permitted";
+var WRITE_VERBS = /* @__PURE__ */ new Set(["insert", "update", "delete", "replace", "create", "alter", "drop", "vacuum", "reindex"]);
+function reservedKind(name) {
+  const lower = name.toLowerCase();
+  if (lower.startsWith(SIRANNON_PREFIX)) return "sirannon";
+  if (lower.startsWith(SQLITE_PREFIX)) return "sqlite";
+  return null;
+}
+function isReservedIdentifier(name) {
+  return reservedKind(name) !== null;
+}
+function reservedSqlError(sql) {
+  const lower = sql.toLowerCase();
+  if (!lower.includes("_sirannon") && !lower.includes("sqlite_") && !lower.includes("attach") && !lower.includes("detach") && !lower.includes("writable_schema")) {
+    return null;
+  }
+  return scan(sql);
+}
+function assertSqlAllowed(sql) {
+  const reason = reservedSqlError(sql);
+  if (reason) {
+    throw new ForbiddenSqlError(reason);
+  }
+}
+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 referenceError(kind, verb) {
+  if (kind === "sirannon") return SIRANNON_MESSAGE;
+  if (kind === "sqlite" && WRITE_VERBS.has(verb)) return SQLITE_WRITE_MESSAGE;
+  return null;
+}
+function scan(sql) {
+  const n = sql.length;
+  let i = 0;
+  let statementStart = true;
+  let verb = "";
+  while (i < n) {
+    const c = sql[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === "\v") {
+      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 += 2;
+      continue;
+    }
+    if (c === "'") {
+      i = skipQuoted(sql, i, "'");
+      statementStart = false;
+      continue;
+    }
+    if (c === '"' || c === "`") {
+      const delimited = readDelimited(sql, i, c);
+      const error = referenceError(reservedKind(delimited.value), verb);
+      if (error) return error;
+      i = delimited.next;
+      statementStart = false;
+      continue;
+    }
+    if (c === "[") {
+      const end = sql.indexOf("]", i + 1);
+      const stop = end === -1 ? n : end;
+      const error = referenceError(reservedKind(sql.slice(i + 1, stop)), verb);
+      if (error) return error;
+      i = stop + 1;
+      statementStart = false;
+      continue;
+    }
+    if (c === ";") {
+      i++;
+      statementStart = true;
+      verb = "";
+      continue;
+    }
+    if (isWordStart(c)) {
+      let j = i + 1;
+      while (j < n && isWordPart(sql[j])) j++;
+      const word = sql.slice(i, j);
+      const lowerWord = word.toLowerCase();
+      if (statementStart) {
+        verb = lowerWord;
+        if (lowerWord === "attach" || lowerWord === "detach") return ATTACH_MESSAGE;
+      } else if (verb === "pragma" && lowerWord === "writable_schema") {
+        return WRITABLE_SCHEMA_MESSAGE;
+      }
+      const error = referenceError(reservedKind(word), verb);
+      if (error) return error;
+      i = j;
+      statementStart = false;
+      continue;
+    }
+    i++;
+    statementStart = false;
+  }
+  return null;
+}
+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 };
+}
+
+// src/core/cdc/encoding.ts
+var BLOB_TAG = "__sirannon_blob";
+var INT_TAG = "__sirannon_int";
+var SAFE_INT_BOUND_TEXT = "9007199254740991";
+var SAFE_INT_BOUND = 9007199254740991n;
+var HEX_BYTES_RE = /^[0-9a-fA-F]*$/;
+var INT_PAYLOAD_RE = /^-?\d{1,19}$/;
+function encodeTaggedValues(value) {
+  if (typeof value === "bigint" || isBinaryValue(value)) {
+    return encodeTaggedLeaf(value);
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map(encodeTaggedValues);
+  }
+  if (typeof value.toJSON === "function") {
+    return value;
+  }
+  const obj = value;
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    out[k] = encodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function encodeTaggedLeaf(value) {
+  if (typeof value === "bigint") {
+    if (value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+      return Number(value);
+    }
+    return { [INT_TAG]: value.toString() };
+  }
+  if (isBinaryValue(value)) {
+    return { [BLOB_TAG]: encodeHexBytes(value) };
+  }
+  return value;
+}
+function encodeWireRowsInPlace(rows) {
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row === null || typeof row !== "object") continue;
+    const obj = row;
+    for (const k of Object.keys(obj)) {
+      const cell = obj[k];
+      if (typeof cell === "bigint" || isBinaryValue(cell)) {
+        obj[k] = encodeTaggedLeaf(cell);
+      }
+    }
+  }
+  return rows;
+}
+function decodeTaggedValues(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (isBinaryValue(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map(decodeTaggedValues);
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  if (keys.length === 1) {
+    const tag = keys[0];
+    const tagValue = obj[tag];
+    if (tag === BLOB_TAG && typeof tagValue === "string") {
+      return decodeHexBytes(tagValue);
+    }
+    if (tag === INT_TAG && typeof tagValue === "string") {
+      if (!INT_PAYLOAD_RE.test(tagValue)) {
+        throw new Error("Invalid tagged integer payload");
+      }
+      return BigInt(tagValue);
+    }
+  }
+  const out = {};
+  for (const k of keys) {
+    out[k] = decodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function isBinaryValue(value) {
+  return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
+}
+function encodeHexBytes(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("hex").toUpperCase();
+  }
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex.toUpperCase();
+}
+function decodeHexBytes(hex) {
+  if (hex.length % 2 !== 0 || !HEX_BYTES_RE.test(hex)) {
+    throw new Error("Invalid CDC BLOB hex payload");
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(hex, "hex");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Invalid CDC BLOB hex payload");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+
+export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, INTERNAL_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, SAFE_INT_BOUND_TEXT, SYNC_STATE_TABLE, assertSqlAllowed, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, isReservedIdentifier };

package/dist/{chunk-UVMVN3OT.mjs → chunk-H5AB6NIR.mjs}

@@ -1,4 +1,4 @@
-import { SirannonError } from './chunk-O7BHI3CF.mjs';
+import { SirannonError } from './chunk-YPYVQJ4C.mjs';
 
 // src/replication/errors.ts
 var ReplicationError = class extends SirannonError {