@liorandb/core 1.1.0 → 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.1.0",
+  "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/collection.ts

@@ -23,6 +23,10 @@ export interface UpdateOptions {
   upsert?: boolean;
 }
 
+export interface CollectionOptions {
+  readonly?: boolean;
+}
+
 export class Collection<T = any> {
   dir: string;
   db: ClassicLevel<string, string>;
@@ -33,16 +37,31 @@ export class Collection<T = any> {
   private migrations: Migration<T>[] = [];
 
   private indexes = new Map<string, Index>();
+  private readonlyMode: boolean;
 
   constructor(
     dir: string,
     schema?: ZodSchema<T>,
-    schemaVersion: number = 1
+    schemaVersion: number = 1,
+    options?: CollectionOptions
   ) {
     this.dir = dir;
-    this.db = new ClassicLevel(dir, { valueEncoding: "utf8" });
     this.schema = schema;
     this.schemaVersion = schemaVersion;
+    this.readonlyMode = options?.readonly ?? false;
+
+    this.db = new ClassicLevel(dir, {
+      valueEncoding: "utf8",
+      readOnly: this.readonlyMode
+    } as any);
+  }
+
+  /* ===================== INTERNAL ===================== */
+
+  private assertWritable() {
+    if (this.readonlyMode) {
+      throw new Error("Collection is in readonly replica mode");
+    }
   }
 
   /* ===================== SCHEMA ===================== */
@@ -106,6 +125,7 @@ export class Collection<T = any> {
   }
 
   private async _updateIndexes(oldDoc: any, newDoc: any) {
+    if (this.readonlyMode) return;
     for (const index of this.indexes.values()) {
       await index.update(oldDoc, newDoc);
     }
@@ -114,6 +134,8 @@ export class Collection<T = any> {
   /* ===================== COMPACTION ===================== */
 
   async compact(): Promise<void> {
+    this.assertWritable();
+
     return this._enqueue(async () => {
       try { await this.db.close(); } catch {}
 
@@ -145,6 +167,8 @@ export class Collection<T = any> {
   /* ===================== STORAGE ===================== */
 
   private async _insertOne(doc: any) {
+    this.assertWritable();
+
     const _id = doc._id ?? uuid();
     const final = this.validate({
       _id,
@@ -159,6 +183,8 @@ export class Collection<T = any> {
   }
 
   private async _insertMany(docs: any[]) {
+    this.assertWritable();
+
     const batch: any[] = [];
     const out = [];
 
@@ -214,14 +240,13 @@ export class Collection<T = any> {
   }
 
   private async _readAndMigrate(id: string) {
-    const enc = await this.db.get(id);
+    const enc = await this.db.get(id).catch(() => null);
     if (!enc) return null;
 
     const raw = decryptData(enc);
     const migrated = this.migrateIfNeeded(raw);
 
-    // Lazy write-back if migrated
-    if (raw.__v !== this.schemaVersion) {
+    if (!this.readonlyMode && raw.__v !== this.schemaVersion) {
       await this.db.put(id, encryptData(migrated));
       await this._updateIndexes(raw, migrated);
     }
@@ -247,9 +272,7 @@ export class Collection<T = any> {
 
   private async _findOne(query: any) {
     if (query?._id) {
-      try {
-        return await this._readAndMigrate(String(query._id));
-      } catch { return null; }
+      return this._readAndMigrate(String(query._id));
     }
 
     const ids = await this._getCandidateIds(query);
@@ -285,6 +308,8 @@ export class Collection<T = any> {
   /* ===================== UPDATE ===================== */
 
   private async _updateOne(filter: any, update: any, options: UpdateOptions) {
+    this.assertWritable();
+
     const ids = await this._getCandidateIds(filter);
 
     for (const id of ids) {
@@ -313,6 +338,8 @@ export class Collection<T = any> {
   }
 
   private async _updateMany(filter: any, update: any) {
+    this.assertWritable();
+
     const ids = await this._getCandidateIds(filter);
     const out = [];
 
@@ -340,6 +367,8 @@ export class Collection<T = any> {
   /* ===================== DELETE ===================== */
 
   private async _deleteOne(filter: any) {
+    this.assertWritable();
+
     const ids = await this._getCandidateIds(filter);
 
     for (const id of ids) {
@@ -357,6 +386,8 @@ export class Collection<T = any> {
   }
 
   private async _deleteMany(filter: any) {
+    this.assertWritable();
+
     const ids = await this._getCandidateIds(filter);
     let count = 0;