@delali/sirannon-db 0.1.6 → 0.1.7

package/dist/chunk-4IGMIJQK.mjs

@@ -0,0 +1,318 @@
+import { deserializeError } from './chunk-DJLX6CAE.mjs';
+import { BackupManager, BackupScheduler } from './chunk-VLTICJOD.mjs';
+import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+import { Worker } from 'worker_threads';
+import { existsSync } from 'fs';
+import { resolve, dirname, join, sep } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// src/core/driver/statement-cache.ts
+var STATEMENT_CACHE_CAPACITY = 128;
+function createStatementCache(prepare) {
+  const cache = /* @__PURE__ */ new Map();
+  return (sql) => {
+    const cached = cache.get(sql);
+    if (cached !== void 0) {
+      cache.delete(sql);
+      cache.set(sql, cached);
+      return cached;
+    }
+    const prepared = prepare(sql);
+    cache.set(sql, prepared);
+    if (cache.size > STATEMENT_CACHE_CAPACITY) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    return prepared;
+  };
+}
+
+// src/core/driver/values.ts
+var SAFE_INT_BOUND = 9007199254740991n;
+function narrowSafeBigInt(value) {
+  if (typeof value === "bigint" && value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+    return Number(value);
+  }
+  return value;
+}
+function narrowRowIntegers(row) {
+  if (row === null || typeof row !== "object") return row;
+  const obj = row;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === "bigint" && value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+      obj[key] = Number(value);
+    }
+  }
+  return row;
+}
+function narrowRowsIntegers(rows) {
+  for (const row of rows) {
+    narrowRowIntegers(row);
+  }
+  return rows;
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new SirannonError(
+        "Could not locate the package root to spawn the writer worker",
+        "WRITER_WORKER_UNRESOLVED"
+      );
+    }
+    dir = parent;
+  }
+}
+function resolveWorkerScript() {
+  const selfPath = fileURLToPath(import.meta.url);
+  const root = findPackageRoot(dirname(selfPath));
+  const bootstrap = join(root, "src", "core", "worker", "dev-bootstrap.mjs");
+  const built = join(root, "dist", "core", "writer-worker.mjs");
+  const runningFromSource = selfPath.startsWith(`${join(root, "src")}${sep}`);
+  const preferred = runningFromSource ? bootstrap : built;
+  const fallback = runningFromSource ? built : bootstrap;
+  if (existsSync(preferred)) return { url: pathToFileURL(preferred), execArgv: [] };
+  if (existsSync(fallback)) return { url: pathToFileURL(fallback), execArgv: [] };
+  throw new SirannonError(
+    `Writer-worker script not found under '${root}'. Build the package or run from source.`,
+    "WRITER_WORKER_UNRESOLVED"
+  );
+}
+
+// src/core/worker/host.ts
+var DEFAULT_WRITE_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RESTARTS = 5;
+var CLOSE_GRACE_MS = 1e3;
+var WriterWorker = class _WriterWorker {
+  constructor(openRequest, timeoutMs, maxRestarts) {
+    this.openRequest = openRequest;
+    this.timeoutMs = timeoutMs;
+    this.maxRestarts = maxRestarts;
+    this.connection = this.makeConnection();
+  }
+  worker = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  ready = Promise.resolve();
+  starting = true;
+  closed = false;
+  fatal = null;
+  restarts = 0;
+  connection;
+  static async start(entry, path, options, workerOptions) {
+    const worker = new _WriterWorker(
+      { kind: "open", entry, path, options },
+      workerOptions?.writeTimeoutMs ?? DEFAULT_WRITE_TIMEOUT_MS,
+      workerOptions?.maxRestarts ?? DEFAULT_MAX_RESTARTS
+    );
+    worker.spawn();
+    try {
+      await worker.ready;
+    } catch (err) {
+      await worker.close();
+      throw err;
+    }
+    worker.starting = false;
+    return worker;
+  }
+  spawn() {
+    const script = resolveWorkerScript();
+    const worker = new Worker(script.url, { execArgv: script.execArgv });
+    this.worker = worker;
+    worker.on("message", (res) => {
+      if (this.worker === worker) this.onResponse(res);
+    });
+    worker.on("error", (err) => {
+      if (this.worker === worker) this.fault(err);
+    });
+    worker.on("exit", (code) => {
+      if (this.worker === worker && !this.closed) {
+        this.fault(new SirannonError(`Writer worker exited with code ${code}`, "WRITER_WORKER_EXIT"));
+      }
+    });
+    this.ready = this.send(this.openRequest).then(() => void 0);
+    this.ready.catch(() => {
+    });
+  }
+  onResponse(res) {
+    const entry = this.pending.get(res.id);
+    if (!entry) return;
+    this.pending.delete(res.id);
+    if (entry.timer) clearTimeout(entry.timer);
+    if (res.ok) entry.resolve(res.value);
+    else entry.reject(deserializeError(res.error));
+  }
+  rejectPending(id, err) {
+    const entry = this.pending.get(id);
+    if (!entry) return;
+    this.pending.delete(id);
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.reject(err);
+  }
+  fault(errLike) {
+    if (this.closed || this.fatal) return;
+    const err = errLike instanceof Error ? errLike : new SirannonError(String(errLike), "WRITER_WORKER_ERROR");
+    const dead = this.worker;
+    this.worker = null;
+    for (const entry of this.pending.values()) {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.reject(err);
+    }
+    this.pending.clear();
+    dead?.terminate().catch(() => {
+    });
+    if (this.starting) {
+      this.fatal = err;
+      this.ready = Promise.reject(err);
+      this.ready.catch(() => {
+      });
+      return;
+    }
+    this.restarts++;
+    if (this.restarts > this.maxRestarts) {
+      this.fatal = new SirannonError(
+        `Writer worker failed ${this.restarts} times and will not restart: ${err.message}`,
+        "WRITER_WORKER_FATAL"
+      );
+      this.ready = Promise.reject(this.fatal);
+      this.ready.catch(() => {
+      });
+      return;
+    }
+    this.spawn();
+  }
+  send(request) {
+    const worker = this.worker;
+    if (!worker) {
+      return Promise.reject(
+        this.fatal ?? new SirannonError("Writer worker is unavailable", "WRITER_WORKER_UNAVAILABLE")
+      );
+    }
+    const id = this.nextId++;
+    const message = { ...request, id };
+    return new Promise((resolve2, reject) => {
+      let timer = null;
+      if (this.timeoutMs > 0) {
+        timer = setTimeout(() => {
+          this.rejectPending(
+            id,
+            new SirannonError(
+              `Writer worker did not respond within ${this.timeoutMs}ms; the operation's outcome is unknown`,
+              "WRITER_WORKER_TIMEOUT"
+            )
+          );
+        }, this.timeoutMs);
+        timer.unref?.();
+      }
+      this.pending.set(id, { resolve: resolve2, reject, timer });
+      try {
+        worker.postMessage(message);
+      } catch (err) {
+        this.pending.delete(id);
+        if (timer) clearTimeout(timer);
+        reject(
+          new SirannonError(
+            `Failed to hand work to the writer worker: ${err instanceof Error ? err.message : String(err)}`,
+            "WRITER_WORKER_POST_FAILED"
+          )
+        );
+      }
+    });
+  }
+  request(request) {
+    if (this.fatal) return Promise.reject(this.fatal);
+    if (this.closed) return Promise.reject(new SirannonError("Writer worker is closed", "WRITER_WORKER_CLOSED"));
+    return this.ready.then(() => this.send(request)).then((value) => {
+      this.restarts = 0;
+      return value;
+    });
+  }
+  makeConnection() {
+    const conn = {
+      exec: (sql) => this.request({ kind: "exec", sql }),
+      prepare: async (sql) => ({
+        all: (...params) => this.request({ kind: "all", sql, params }),
+        get: (...params) => this.request({ kind: "get", sql, params }),
+        run: (...params) => this.request({ kind: "run", sql, params }),
+        allRaw: (...params) => this.request({ kind: "allRaw", sql, params })
+      }),
+      runBatch: (sql, paramsBatch) => this.request({ kind: "runBatch", sql, paramsBatch }),
+      runBatchSummary: (sql, paramsBatch) => this.request({ kind: "runBatchSummary", sql, paramsBatch }),
+      runGroup: (units) => this.request({
+        kind: "runGroup",
+        units: units.map((unit) => ({
+          statements: unit.statements.map((statement) => ({
+            sql: statement.sql,
+            params: statement.params ? [...statement.params] : []
+          }))
+        }))
+      }),
+      transaction: async (fn) => {
+        await conn.exec("BEGIN");
+        try {
+          const result = await fn(conn);
+          await conn.exec("COMMIT");
+          return result;
+        } catch (err) {
+          try {
+            await conn.exec("ROLLBACK");
+          } catch {
+          }
+          throw err;
+        }
+      },
+      close: () => this.close()
+    };
+    return conn;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const worker = this.worker;
+    if (worker) {
+      try {
+        await Promise.race([
+          this.send({ kind: "close" }),
+          new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new Error("close timed out")), CLOSE_GRACE_MS);
+            timer.unref?.();
+          })
+        ]);
+      } catch {
+      }
+      await worker.terminate().catch(() => {
+      });
+    }
+    this.worker = null;
+    for (const entry of this.pending.values()) {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.reject(new SirannonError("Writer worker is closed", "WRITER_WORKER_CLOSED"));
+    }
+    this.pending.clear();
+  }
+};
+function nodeWriterContext() {
+  const held = new AsyncLocalStorage();
+  return {
+    run: (operation) => held.run(true, operation),
+    isActive: () => held.getStore() === true,
+    exit: (operation) => held.exit(operation)
+  };
+}
+function nodeResolveExtensionPath(extensionPath) {
+  return resolve(extensionPath);
+}
+function nodeBackupEngine() {
+  const manager = new BackupManager();
+  const scheduler = new BackupScheduler(manager);
+  return {
+    backup: (conn, destPath) => manager.backup(conn, destPath),
+    schedule: (conn, options, runExclusive) => scheduler.schedule(conn, options, runExclusive)
+  };
+}
+
+export { WriterWorker, createStatementCache, narrowRowIntegers, narrowRowsIntegers, narrowSafeBigInt, nodeBackupEngine, nodeResolveExtensionPath, nodeWriterContext };

package/dist/chunk-BNUTBHHH.mjs

@@ -0,0 +1,22 @@
+import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+
+// 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 } : {}
+  });
+}
+
+export { defineDriver };

package/dist/chunk-CJLYFDP5.mjs

@@ -0,0 +1,26 @@
+import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+
+// 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;
+}
+function isSynchronousLevel(value) {
+  return value === "off" || value === "normal" || value === "full" || value === "extra";
+}
+
+export { DEFAULT_SYNCHRONOUS, isSynchronousLevel, synchronousPragmaValue };

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-DJLX6CAE.mjs

@@ -0,0 +1,20 @@
+// src/core/worker/protocol.ts
+function serializeError(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    return {
+      message: err.message,
+      name: err.name,
+      ...typeof code === "string" ? { code } : {}
+    };
+  }
+  return { message: String(err) };
+}
+function deserializeError(error) {
+  const err = new Error(error.message);
+  if (error.name) err.name = error.name;
+  if (error.code) err.code = error.code;
+  return err;
+}
+
+export { deserializeError, serializeError };

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 };