@liorandb/core 1.0.19 → 1.1.1

package/dist/queue-YILKSUEI.js

@@ -0,0 +1,179 @@
+import {
+  LioranManager,
+  getDefaultRootPath
+} from "./chunk-2FSI7HX7.js";
+
+// src/ipc/pool.ts
+import { Worker } from "worker_threads";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var IPCWorkerPool = class {
+  workers = [];
+  workerCount;
+  shuttingDown = false;
+  rrIndex = 0;
+  constructor() {
+    this.workerCount = Math.max(2, os.cpus().length);
+  }
+  /* -------------------------------------------------- */
+  /* START POOL                                         */
+  /* -------------------------------------------------- */
+  start() {
+    for (let i = 0; i < this.workerCount; i++) {
+      this.spawnWorker();
+    }
+    console.log(
+      `[WorkerPool] Started ${this.workerCount} worker threads`
+    );
+  }
+  /* -------------------------------------------------- */
+  /* SPAWN WORKER                                       */
+  /* -------------------------------------------------- */
+  spawnWorker() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const workerFile = path.join(__dirname, "worker.js");
+    const worker = new Worker(workerFile);
+    worker.on("exit", (code) => {
+      if (this.shuttingDown) return;
+      console.error(
+        `[WorkerPool] Worker exited (code=${code}). Restarting...`
+      );
+      this.workers = this.workers.filter((w) => w !== worker);
+      setTimeout(() => {
+        this.spawnWorker();
+      }, 500);
+    });
+    worker.on("error", (err) => {
+      console.error("[WorkerPool] Worker error:", err);
+    });
+    this.workers.push(worker);
+  }
+  /* -------------------------------------------------- */
+  /* EXECUTE TASK                                       */
+  /* -------------------------------------------------- */
+  exec(task) {
+    if (this.workers.length === 0) {
+      throw new Error("No workers available");
+    }
+    const worker = this.workers[this.rrIndex];
+    this.rrIndex = (this.rrIndex + 1) % this.workers.length;
+    return new Promise((resolve, reject) => {
+      const id = Date.now() + Math.random();
+      const messageHandler = (msg) => {
+        if (msg.id !== id) return;
+        worker.off("message", messageHandler);
+        if (msg.ok) resolve(msg.result);
+        else reject(new Error(msg.error));
+      };
+      worker.on("message", messageHandler);
+      worker.postMessage({
+        id,
+        task
+      });
+    });
+  }
+  /* -------------------------------------------------- */
+  /* SHUTDOWN                                           */
+  /* -------------------------------------------------- */
+  async shutdown() {
+    this.shuttingDown = true;
+    console.log("[WorkerPool] Shutting down worker threads...");
+    for (const worker of this.workers) {
+      try {
+        await worker.terminate();
+      } catch (err) {
+        console.error("[WorkerPool] Worker terminate error:", err);
+      }
+    }
+    this.workers = [];
+  }
+  /* -------------------------------------------------- */
+  /* INFO                                               */
+  /* -------------------------------------------------- */
+  get size() {
+    return this.workerCount;
+  }
+};
+
+// src/ipc/queue.ts
+var DBQueue = class {
+  constructor(rootPath = getDefaultRootPath()) {
+    this.rootPath = rootPath;
+    this.manager = new LioranManager({ rootPath });
+    this.pool = new IPCWorkerPool();
+    this.pool.start();
+  }
+  manager;
+  pool;
+  destroyed = false;
+  /* -------------------------------- EXEC -------------------------------- */
+  async exec(action, args) {
+    if (this.destroyed) {
+      throw new Error("DBQueue already shutdown");
+    }
+    switch (action) {
+      /* ---------------- DB ---------------- */
+      case "db":
+        await this.manager.db(args.db);
+        return true;
+      /* ---------------- CRUD OPS ---------------- */
+      case "op": {
+        const { db, col, method, params } = args;
+        const collection = (await this.manager.db(db)).collection(col);
+        return await collection[method](...params);
+      }
+      /* ---------------- INDEX OPS ---------------- */
+      case "index": {
+        const { db, col, method, params } = args;
+        const collection = (await this.manager.db(db)).collection(col);
+        return await collection[method](...params);
+      }
+      /* ---------------- COMPACTION ---------------- */
+      case "compact:collection": {
+        const { db, col } = args;
+        const collection = (await this.manager.db(db)).collection(col);
+        await collection.compact();
+        return true;
+      }
+      case "compact:db": {
+        const { db } = args;
+        const database = await this.manager.db(db);
+        await database.compactAll();
+        return true;
+      }
+      case "compact:all": {
+        for (const db of this.manager.openDBs.values()) {
+          await db.compactAll();
+        }
+        return true;
+      }
+      /* ---------------- SNAPSHOT ---------------- */
+      case "snapshot":
+        await this.manager.snapshot(args.path);
+        return true;
+      case "restore":
+        await this.manager.restore(args.path);
+        return true;
+      /* ---------------- CONTROL ---------------- */
+      case "shutdown":
+        await this.shutdown();
+        return true;
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+  /* ------------------------------ SHUTDOWN ------------------------------ */
+  async shutdown() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    await this.manager.closeAll();
+    await this.pool.shutdown();
+  }
+};
+var dbQueue = new DBQueue();
+export {
+  DBQueue,
+  dbQueue
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liorandb/core",
-  "version": "1.0.19",
+  "version": "1.1.1",
   "description": "LioranDB Core Module – Lightweight, local-first, peer-to-peer database management for Node.js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/LioranManager.ts

@@ -4,29 +4,34 @@ import process from "process";
 import { LioranDB } from "./core/database.js";
 import { setEncryptionKey } from "./utils/encryption.js";
 import { getDefaultRootPath } from "./utils/rootpath.js";
-import { dbQueue } from "./ipc/queue.js";
-import { IPCServer } from "./ipc/server.js";
+
+/* ---------------- PROCESS MODE ---------------- */
 
 enum ProcessMode {
   PRIMARY = "primary",
-  CLIENT = "client"
+  CLIENT = "client",
+  READONLY = "readonly"
 }
 
+/* ---------------- OPTIONS ---------------- */
+
 export interface LioranManagerOptions {
   rootPath?: string;
   encryptionKey?: string | Buffer;
+  ipc?: "primary" | "client" | "readonly";
 }
 
+/* ---------------- MANAGER ---------------- */
+
 export class LioranManager {
   rootPath: string;
   openDBs: Map<string, LioranDB>;
   private closed = false;
   private mode: ProcessMode;
   private lockFd?: number;
-  private ipcServer?: IPCServer;
 
   constructor(options: LioranManagerOptions = {}) {
-    const { rootPath, encryptionKey } = options;
+    const { rootPath, encryptionKey, ipc } = options;
 
     this.rootPath = rootPath || getDefaultRootPath();
 
@@ -40,17 +45,48 @@ export class LioranManager {
 
     this.openDBs = new Map();
 
-    this.mode = this.tryAcquireLock()
-      ? ProcessMode.PRIMARY
-      : ProcessMode.CLIENT;
+    /* ---------------- MODE RESOLUTION ---------------- */
+
+    if (ipc === "readonly") {
+      this.mode = ProcessMode.READONLY;
+    } else if (ipc === "client") {
+      this.mode = ProcessMode.CLIENT;
+    } else if (ipc === "primary") {
+      this.mode = ProcessMode.PRIMARY;
+      this.tryAcquireLock();
+    } else {
+      // auto-detect (default behavior)
+      this.mode = this.tryAcquireLock()
+        ? ProcessMode.PRIMARY
+        : ProcessMode.CLIENT;
+    }
 
     if (this.mode === ProcessMode.PRIMARY) {
-      this.ipcServer = new IPCServer(this, this.rootPath);
-      this.ipcServer.start();
       this._registerShutdownHooks();
     }
   }
 
+  /* ---------------- MODE HELPERS ---------------- */
+
+  isPrimary() {
+    return this.mode === ProcessMode.PRIMARY;
+  }
+
+  isClient() {
+    return this.mode === ProcessMode.CLIENT;
+  }
+
+  isReadOnly() {
+    return this.mode === ProcessMode.READONLY;
+  }
+
+  /* ---------------- QUEUE HELPER ---------------- */
+
+  private async getQueue() {
+    const { dbQueue } = await import("./ipc/queue.js");
+    return dbQueue;
+  }
+
   /* ---------------- LOCK MANAGEMENT ---------------- */
 
   private isProcessAlive(pid: number): boolean {
@@ -78,7 +114,7 @@ export class LioranManager {
           fs.writeSync(this.lockFd, String(process.pid));
           return true;
         }
-      } catch { }
+      } catch {}
       return false;
     }
   }
@@ -87,9 +123,11 @@ export class LioranManager {
 
   async db(name: string): Promise<LioranDB> {
     if (this.mode === ProcessMode.CLIENT) {
-      await dbQueue.exec("db", { db: name });
+      const queue = await this.getQueue();
+      await queue.exec("db", { db: name });
       return new IPCDatabase(name) as any;
     }
+
     return this.openDatabase(name);
   }
 
@@ -108,44 +146,51 @@ export class LioranManager {
     return db;
   }
 
-  /* ---------------- SNAPSHOT ORCHESTRATION ---------------- */
+  /* ---------------- SNAPSHOT ---------------- */
 
-  /**
-   * Create TAR snapshot of full DB directory
-   */
   async snapshot(snapshotPath: string) {
     if (this.mode === ProcessMode.CLIENT) {
-      return dbQueue.exec("snapshot", { path: snapshotPath });
+      const queue = await this.getQueue();
+      return queue.exec("snapshot", { path: snapshotPath });
+    }
+
+    if (this.mode === ProcessMode.READONLY) {
+      throw new Error("Snapshot not allowed in readonly mode");
     }
 
-    // Flush all DBs safely
     for (const db of this.openDBs.values()) {
-      for (const col of db.collections.values()) {
-        try { await col.db.close(); } catch { }
-      }
+      try {
+        await db.close();
+      } catch {}
     }
 
-    // Ensure backup directory exists
     fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
 
     const tar = await import("tar");
 
-    await tar.c({
-      gzip: true,
-      file: snapshotPath,
-      cwd: this.rootPath,
-      portable: true
-    }, ["./"]);
+    await tar.c(
+      {
+        gzip: true,
+        file: snapshotPath,
+        cwd: this.rootPath,
+        portable: true
+      },
+      ["./"]
+    );
 
     return true;
   }
 
-  /**
-   * Restore TAR snapshot safely
-   */
+  /* ---------------- RESTORE ---------------- */
+
   async restore(snapshotPath: string) {
     if (this.mode === ProcessMode.CLIENT) {
-      return dbQueue.exec("restore", { path: snapshotPath });
+      const queue = await this.getQueue();
+      return queue.exec("restore", { path: snapshotPath });
+    }
+
+    if (this.mode === ProcessMode.READONLY) {
+      throw new Error("Restore not allowed in readonly mode");
     }
 
     await this.closeAll();
@@ -171,22 +216,26 @@ export class LioranManager {
     this.closed = true;
 
     if (this.mode === ProcessMode.CLIENT) {
-      await dbQueue.shutdown();
+      const queue = await this.getQueue();
+      await queue.shutdown();
       return;
     }
 
     for (const db of this.openDBs.values()) {
-      try { await db.close(); } catch { }
+      try {
+        await db.close();
+      } catch {}
     }
 
     this.openDBs.clear();
 
-    try {
-      if (this.lockFd) fs.closeSync(this.lockFd);
-      fs.unlinkSync(path.join(this.rootPath, ".lioran.lock"));
-    } catch { }
-
-    await this.ipcServer?.close();
+    // Only primary owns lock
+    if (this.mode === ProcessMode.PRIMARY) {
+      try {
+        if (this.lockFd) fs.closeSync(this.lockFd);
+        fs.unlinkSync(path.join(this.rootPath, ".lioran.lock"));
+      } catch {}
+    }
   }
 
   async close(): Promise<void> {
@@ -213,7 +262,7 @@ export class LioranManager {
 /* ---------------- IPC PROXY DB ---------------- */
 
 class IPCDatabase {
-  constructor(private name: string) { }
+  constructor(private name: string) {}
 
   collection(name: string) {
     return new IPCCollection(this.name, name);
@@ -224,10 +273,16 @@ class IPCCollection {
   constructor(
     private db: string,
     private col: string
-  ) { }
+  ) {}
+
+  private async getQueue() {
+    const { dbQueue } = await import("./ipc/queue.js");
+    return dbQueue;
+  }
 
-  private call(method: string, params: any[]) {
-    return dbQueue.exec("op", {
+  private async call(method: string, params: any[]) {
+    const queue = await this.getQueue();
+    return queue.exec("op", {
       db: this.db,
       col: this.col,
       method,

package/src/core/checkpoint.ts

@@ -9,27 +9,56 @@ export interface CheckpointData {
   lsn: number;        // Last durable LSN
   walGen: number;     // WAL generation at checkpoint
   time: number;       // Timestamp (ms)
-  version: number;    // For future format upgrades
+  version: number;    // Format version
+}
+
+interface StoredCheckpoint {
+  data: CheckpointData;
+  crc: number;
 }
 
 /* =========================
    CONSTANTS
 ========================= */
 
-const CHECKPOINT_FILE = "__checkpoint.json";
-const TMP_SUFFIX = ".tmp";
+const CHECKPOINT_A = "__checkpoint_A.json";
+const CHECKPOINT_B = "__checkpoint_B.json";
 const FORMAT_VERSION = 1;
 
+/* =========================
+   CRC32 (no deps)
+========================= */
+
+const CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) {
+      c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(input: string): number {
+  let crc = 0xFFFFFFFF;
+  for (let i = 0; i < input.length; i++) {
+    crc = CRC32_TABLE[(crc ^ input.charCodeAt(i)) & 0xFF] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
 /* =========================
    CHECKPOINT MANAGER
 ========================= */
 
 export class CheckpointManager {
-  private filePath: string;
+  private baseDir: string;
   private data: CheckpointData;
 
   constructor(baseDir: string) {
-    this.filePath = path.join(baseDir, CHECKPOINT_FILE);
+    this.baseDir = baseDir;
     this.data = {
       lsn: 0,
       walGen: 1,
@@ -41,61 +70,84 @@ export class CheckpointManager {
   }
 
   /* -------------------------
-     LOAD (Crash-safe)
+     LOAD (CRC + FALLBACK)
   ------------------------- */
 
   private load() {
-    if (!fs.existsSync(this.filePath)) {
+    const a = this.readCheckpoint(CHECKPOINT_A);
+    const b = this.readCheckpoint(CHECKPOINT_B);
+
+    if (a && b) {
+      // pick newest valid checkpoint
+      this.data = a.data.lsn >= b.data.lsn ? a.data : b.data;
+      return;
+    }
+
+    if (a) {
+      this.data = a.data;
       return;
     }
 
+    if (b) {
+      this.data = b.data;
+      return;
+    }
+
+    console.warn("No valid checkpoint found, starting from zero");
+  }
+
+  private readCheckpoint(file: string): StoredCheckpoint | null {
+    const filePath = path.join(this.baseDir, file);
+    if (!fs.existsSync(filePath)) return null;
+
     try {
-      const raw = fs.readFileSync(this.filePath, "utf8");
-      const parsed = JSON.parse(raw) as CheckpointData;
-
-      if (
-        typeof parsed.lsn === "number" &&
-        typeof parsed.walGen === "number"
-      ) {
-        this.data = parsed;
+      const raw = fs.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw) as StoredCheckpoint;
+
+      if (!parsed?.data || typeof parsed.crc !== "number") {
+        return null;
       }
+
+      const expected = crc32(JSON.stringify(parsed.data));
+      if (expected !== parsed.crc) {
+        console.error(`Checkpoint CRC mismatch: ${file}`);
+        return null;
+      }
+
+      return parsed;
     } catch {
-      console.error("Checkpoint corrupted, starting from zero");
-      this.data = {
-        lsn: 0,
-        walGen: 1,
-        time: 0,
-        version: FORMAT_VERSION
-      };
+      return null;
     }
   }
 
   /* -------------------------
-     SAVE (Atomic Write)
+     SAVE (DUAL WRITE)
   ------------------------- */
 
   save(lsn: number, walGen: number) {
-    const newData: CheckpointData = {
+    const data: CheckpointData = {
       lsn,
       walGen,
       time: Date.now(),
       version: FORMAT_VERSION
     };
 
-    const tmpPath = this.filePath + TMP_SUFFIX;
+    const stored: StoredCheckpoint = {
+      data,
+      crc: crc32(JSON.stringify(data))
+    };
+
+    // alternate between A/B for crash safety
+    const target =
+      lsn % 2 === 0 ? CHECKPOINT_A : CHECKPOINT_B;
 
     try {
-      // Write to temp file first
       fs.writeFileSync(
-        tmpPath,
-        JSON.stringify(newData, null, 2),
-        { encoding: "utf8" }
+        path.join(this.baseDir, target),
+        JSON.stringify(stored, null, 2),
+        "utf8"
       );
-
-      // Atomic rename
-      fs.renameSync(tmpPath, this.filePath);
-
-      this.data = newData;
+      this.data = data;
     } catch (err) {
       console.error("Failed to write checkpoint:", err);
     }