@delali/sirannon-db 0.1.5 → 0.1.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A production-grade library that turns SQLite databases into a networked data layer with real-time subscriptions.",
   "author": "Delali (https://sondelali.com)",
   "license": "Apache-2.0",
@@ -95,7 +95,6 @@
     "@bufbuild/protobuf": ">=2.0.0",
     "@grpc/grpc-js": ">=1.10.0",
     "better-sqlite3": ">=12.0.0",
-    "croner": ">=10.0.0",
     "expo-sqlite": ">=14.0.0",
     "etcd3": ">=1.1.2",
     "grpc-health-check": ">=2.0.0",
@@ -112,9 +111,6 @@
     "better-sqlite3": {
       "optional": true
     },
-    "croner": {
-      "optional": true
-    },
     "expo-sqlite": {
       "optional": true
     },
@@ -136,17 +132,12 @@
     "@grpc/grpc-js": "1.14.3",
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "25.3.3",
-    "@types/pg": "8.20.0",
     "@vitest/coverage-v8": "4.0.18",
     "better-sqlite3": "12.6.2",
-    "croner": "10.0.1",
     "etcd3": "1.1.2",
     "grpc-health-check": "2.1.0",
     "grpc-tools": "1.13.1",
-    "pg": "8.20.0",
     "selfsigned": "5.5.0",
-    "simple-statistics": "7.8.7",
-    "tinybench": "6.0.0",
     "ts-proto": "2.11.6",
     "tsup": "8.5.1",
     "tsx": "4.21.0",
@@ -156,27 +147,16 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsup",
+    "check:bundle": "node scripts/assert-browser-bundle.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
     "test:failover": "vitest run --config vitest.failover.config.ts",
     "test:soak": "vitest run --config vitest.soak.config.ts",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
-    "lint": "biome check .",
+    "lint": "biome check --error-on-warnings .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
-    "bench": "node --expose-gc --import tsx benchmarks/run-all.ts",
-    "bench:micro": "node --expose-gc --import tsx benchmarks/micro/point-select.ts",
-    "bench:ycsb": "node --expose-gc --import tsx benchmarks/ycsb/workload-a.ts",
-    "bench:oltp": "node --expose-gc --import tsx benchmarks/oltp/tpc-c-lite.ts",
-    "bench:scaling": "node --expose-gc --import tsx benchmarks/scaling/concurrency.ts",
-    "bench:pool": "node --expose-gc --import tsx benchmarks/scaling/pool-sweep.ts",
-    "bench:cdc": "node --expose-gc --import tsx benchmarks/sirannon/cdc-latency.ts",
-    "bench:docker": "node --import tsx benchmarks/run-docker.ts",
-    "bench:docker:e2e": "node --import tsx benchmarks/run-e2e.ts",
-    "bench:docker:engine": "node --expose-gc --import tsx benchmarks/run-engine.ts",
-    "bench:statistical": "node --expose-gc --import tsx benchmarks/run-statistical.ts",
-    "bench:charts": "python3 benchmarks/scripts/generate-charts.py benchmarks/results/",
     "proto:gen": "grpc_tools_node_protoc --plugin=protoc-gen-ts_proto=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=src/transport/grpc/generated --ts_proto_opt=forceLong=bigint --ts_proto_opt=esModuleInterop=true --ts_proto_opt=outputServices=grpc-js --ts_proto_opt=env=node -I src/transport/grpc/proto src/transport/grpc/proto/replication.proto"
   }
 }

package/dist/chunk-3MCMONVP.mjs

@@ -1,115 +0,0 @@
-import { QueryError } from './chunk-O7BHI3CF.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];
-}
-async function query(conn, sql, params) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    return await stmt.all(...bindParams(params));
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-async function queryOne(conn, sql, params) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    return await stmt.get(...bindParams(params));
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-async function execute(conn, sql, params) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    const result = await stmt.run(...bindParams(params));
-    return {
-      changes: result.changes,
-      lastInsertRowId: result.lastInsertRowId
-    };
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-async function executeBatch(conn, sql, paramsBatch) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    const results = [];
-    for (const params of paramsBatch) {
-      const result = await stmt.run(...bindParams(params));
-      results.push({
-        changes: result.changes,
-        lastInsertRowId: result.lastInsertRowId
-      });
-    }
-    return results;
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-
-// src/core/transaction.ts
-var Transaction = class _Transaction {
-  constructor(conn) {
-    this.conn = conn;
-  }
-  _lastInsertRowId = 0;
-  async query(sql, params) {
-    return query(this.conn, sql, params);
-  }
-  async execute(sql, params) {
-    const result = await execute(this.conn, sql, params);
-    this._lastInsertRowId = result.lastInsertRowId;
-    return result;
-  }
-  async executeBatch(sql, paramsBatch) {
-    const results = await executeBatch(this.conn, sql, paramsBatch);
-    if (results.length > 0) {
-      this._lastInsertRowId = results[results.length - 1].lastInsertRowId;
-    }
-    return results;
-  }
-  get lastInsertRowId() {
-    return this._lastInsertRowId;
-  }
-  static async run(conn, fn) {
-    return conn.transaction(async (txConn) => {
-      const tx = new _Transaction(txConn);
-      return fn(tx);
-    });
-  }
-};
-
-export { Transaction, execute, executeBatch, query, queryOne };

package/dist/chunk-74UN4DIE.mjs

@@ -1,14 +0,0 @@
-import { SirannonError } from './chunk-O7BHI3CF.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");
-  }
-  return Object.freeze({
-    capabilities: Object.freeze({ ...config.capabilities }),
-    open: config.open
-  });
-}
-
-export { defineDriver };

package/dist/chunk-FB2U2Q3Y.mjs

@@ -1,21 +0,0 @@
-// 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");
-  }
-  return Object.freeze({
-    capabilities: Object.freeze({ ...config.capabilities }),
-    open: config.open
-  });
-}
-
-export { defineDriver };

package/dist/chunk-GS7T5YMI.mjs

@@ -1,51 +0,0 @@
-// src/core/cdc/encoding.ts
-var BLOB_TAG = "__sirannon_blob";
-var INT_TAG = "__sirannon_int";
-var SAFE_INT_BOUND_TEXT = "9007199254740991";
-var HEX_BYTES_RE = /^[0-9a-fA-F]*$/;
-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") {
-      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 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 { SAFE_INT_BOUND_TEXT, decodeTaggedValues };

package/dist/chunk-PXKAKK2V.mjs

@@ -1,124 +0,0 @@
-import { BackupError } from './chunk-O7BHI3CF.mjs';
-import { existsSync, mkdirSync, rmSync, readdirSync, lstatSync } from 'fs';
-import { resolve, dirname, join } from 'path';
-import { Cron } from 'croner';
-
-var BACKUP_FILE_PREFIX = "backup";
-function hasControlCharacters(s) {
-  for (let i = 0; i < s.length; i++) {
-    const code = s.charCodeAt(i);
-    if (code <= 31) return true;
-  }
-  return false;
-}
-var BackupManager = class {
-  async backup(conn, destPath) {
-    if (hasControlCharacters(destPath)) {
-      throw new BackupError("Backup path contains invalid characters");
-    }
-    const segments = destPath.split(/[/\\]/);
-    if (segments.includes("..")) {
-      throw new BackupError("Backup path must not contain directory traversal segments");
-    }
-    const resolved = resolve(destPath);
-    const dir = dirname(resolved);
-    if (!existsSync(dir)) {
-      try {
-        mkdirSync(dir, { recursive: true });
-      } catch (err) {
-        throw new BackupError(
-          `Failed to create backup directory '${dir}': ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    if (existsSync(resolved)) {
-      throw new BackupError(`Backup destination '${destPath}' already exists`);
-    }
-    const escaped = resolved.replace(/'/g, "''");
-    try {
-      await conn.exec(`VACUUM INTO '${escaped}'`);
-    } catch (err) {
-      try {
-        rmSync(resolved, { force: true });
-      } catch {
-      }
-      throw new BackupError(`Backup to '${destPath}' failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  generateFilename() {
-    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    return `${BACKUP_FILE_PREFIX}-${ts}.db`;
-  }
-  rotate(dir, maxFiles) {
-    if (maxFiles <= 0) return;
-    const resolved = resolve(dir);
-    if (!existsSync(resolved)) return;
-    let entries;
-    try {
-      entries = readdirSync(resolved).filter((f) => f.startsWith(`${BACKUP_FILE_PREFIX}-`) && f.endsWith(".db")).map((f) => {
-        const filePath = join(resolved, f);
-        return { path: filePath, mtimeMs: lstatSync(filePath).mtimeMs };
-      }).sort((a, b) => b.mtimeMs - a.mtimeMs);
-    } catch (err) {
-      throw new BackupError(
-        `Failed to list backup files in '${dir}': ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    for (const entry of entries.slice(maxFiles)) {
-      try {
-        rmSync(entry.path, { force: true });
-      } catch {
-      }
-    }
-  }
-};
-var DEFAULT_MAX_FILES = 5;
-var BackupScheduler = class {
-  manager;
-  constructor(manager) {
-    this.manager = manager ?? new BackupManager();
-  }
-  schedule(conn, options) {
-    const { cron: cronExpr, destDir, maxFiles = DEFAULT_MAX_FILES, onError } = options;
-    const resolvedDir = resolve(destDir);
-    if (!existsSync(resolvedDir)) {
-      try {
-        mkdirSync(resolvedDir, { recursive: true });
-      } catch (err) {
-        throw new BackupError(
-          `Failed to create backup directory '${destDir}': ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    let job;
-    try {
-      job = new Cron(
-        cronExpr,
-        {
-          unref: true,
-          catch: (err) => {
-            if (onError) {
-              const error = err instanceof Error ? err : new BackupError(typeof err === "string" ? err : "Scheduled backup failed");
-              onError(error);
-            }
-          }
-        },
-        async () => {
-          const filename = this.manager.generateFilename();
-          const destPath = join(resolvedDir, filename);
-          await this.manager.backup(conn, destPath);
-          this.manager.rotate(resolvedDir, maxFiles);
-        }
-      );
-    } catch (err) {
-      throw new BackupError(
-        `Invalid cron expression '${cronExpr}': ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    return () => {
-      job.stop();
-    };
-  }
-};
-
-export { BackupManager, BackupScheduler };

package/dist/index-CLdNrcPz.d.ts

@@ -1,16 +0,0 @@
-import { a as SQLiteConnection } from './types-BFSsG77t.js';
-import { m as BackupScheduleOptions } from './types-D-74JiXb.js';
-
-declare class BackupManager {
-    backup(conn: SQLiteConnection, destPath: string): Promise<void>;
-    generateFilename(): string;
-    rotate(dir: string, maxFiles: number): void;
-}
-
-declare class BackupScheduler {
-    private readonly manager;
-    constructor(manager?: BackupManager);
-    schedule(conn: SQLiteConnection, options: BackupScheduleOptions): () => void;
-}
-
-export { BackupManager as B, BackupScheduler as a };

package/dist/types-BFSsG77t.d.ts

@@ -1,29 +0,0 @@
-interface RunResult {
-    changes: number;
-    lastInsertRowId: number | bigint;
-}
-interface SQLiteStatement {
-    all<T = unknown>(...params: unknown[]): Promise<T[]>;
-    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
-    run(...params: unknown[]): Promise<RunResult>;
-}
-interface SQLiteConnection {
-    exec(sql: string): Promise<void>;
-    prepare(sql: string): Promise<SQLiteStatement>;
-    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
-}
-interface OpenOptions {
-    readonly?: boolean;
-    walMode?: boolean;
-}
-interface DriverCapabilities {
-    multipleConnections: boolean;
-    extensions: boolean;
-}
-interface SQLiteDriver {
-    readonly capabilities: DriverCapabilities;
-    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
-}
-
-export type { DriverCapabilities as D, OpenOptions as O, RunResult as R, SQLiteDriver as S, SQLiteConnection as a, SQLiteStatement as b };