@liorandb/core 1.0.11 → 1.0.13

package/dist/worker/dbWorker.js

@@ -1,37 +1,35 @@
 import {
   LioranManager
-} from "../chunk-RIHXIHVF.js";
+} from "../chunk-ST6KMJQJ.js";
 
 // src/worker/dbWorker.ts
-var manager = new LioranManager();
+var manager = new LioranManager({ ipc: false });
 process.on("message", async (msg) => {
   const { id, action, args } = msg;
   try {
     let result;
     switch (action) {
-      case "shutdown": {
+      case "shutdown":
         await manager.closeAll();
         result = true;
         break;
-      }
-      case "db": {
-        const db = await manager.db(args.db);
+      case "db":
+        await manager.db(args.db);
         result = true;
         break;
-      }
-      case "collection": {
-        const db = await manager.db(args.db);
-        result = db.collection(args.collection);
-        break;
-      }
       case "op": {
         const { db, col, method, params } = args;
         const collection = (await manager.db(db)).collection(col);
         result = await collection[method](...params);
         break;
       }
+      case "tx": {
+        const db = await manager.db(args.db);
+        result = await db.transaction(args.fn);
+        break;
+      }
       default:
-        throw new Error("Unknown action");
+        throw new Error("Unknown IPC action");
     }
     process.send?.({ id, ok: true, result });
   } catch (err) {

package/package.json

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

package/src/LioranManager.ts

@@ -1,27 +1,34 @@
 import path from "path";
 import fs from "fs";
+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";
+
+enum ProcessMode {
+  PRIMARY = "primary",
+  CLIENT = "client"
+}
 
 export interface LioranManagerOptions {
   rootPath?: string;
   encryptionKey?: string | Buffer;
-  ipc?: boolean;
 }
 
 export class LioranManager {
   rootPath: string;
   openDBs: Map<string, LioranDB>;
   private closed = false;
-  private ipc: boolean;
+  private mode: ProcessMode;
+  private lockFd?: number;
+  private ipcServer?: IPCServer;
 
   constructor(options: LioranManagerOptions = {}) {
-    const { rootPath, encryptionKey, ipc } = options;
+    const { rootPath, encryptionKey } = options;
 
     this.rootPath = rootPath || getDefaultRootPath();
-    this.ipc = ipc ?? process.env.LIORANDB_IPC === "1";
 
     if (!fs.existsSync(this.rootPath)) {
       fs.mkdirSync(this.rootPath, { recursive: true });
@@ -33,33 +40,56 @@ export class LioranManager {
 
     this.openDBs = new Map();
 
-    if (!this.ipc) {
+    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();
     }
   }
 
-  /* -------------------------------- CORE -------------------------------- */
-
-  async db(name: string): Promise<LioranDB> {
-    if (this.ipc) {
-      await dbQueue.exec("db", { db: name });
-      return new IPCDatabase(name) as any;
+  private isProcessAlive(pid: number): boolean {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
     }
-
-    return this.openDatabase(name);
   }
 
-  async createDatabase(name: string): Promise<LioranDB> {
-    this._assertOpen();
+  private tryAcquireLock(): boolean {
+    const lockPath = path.join(this.rootPath, ".lioran.lock");
 
-    const dbPath = path.join(this.rootPath, name);
+    try {
+      this.lockFd = fs.openSync(lockPath, "wx");
+      fs.writeSync(this.lockFd, String(process.pid));
+      return true;
+    } catch {
+      // Possible stale lock → validate PID
+      try {
+        const pid = Number(fs.readFileSync(lockPath, "utf8"));
+        if (!this.isProcessAlive(pid)) {
+          fs.unlinkSync(lockPath);
+          this.lockFd = fs.openSync(lockPath, "wx");
+          fs.writeSync(this.lockFd, String(process.pid));
+          return true;
+        }
+      } catch {}
 
-    if (fs.existsSync(dbPath)) {
-      throw new Error(`Database "${name}" already exists`);
+      return false;
     }
+  }
 
-    await fs.promises.mkdir(dbPath, { recursive: true });
-    return this.db(name);
+  async db(name: string): Promise<LioranDB> {
+    if (this.mode === ProcessMode.CLIENT) {
+      await dbQueue.exec("db", { db: name });
+      return new IPCDatabase(name) as any;
+    }
+
+    return this.openDatabase(name);
   }
 
   async openDatabase(name: string): Promise<LioranDB> {
@@ -70,54 +100,36 @@ export class LioranManager {
     }
 
     const dbPath = path.join(this.rootPath, name);
-
-    if (!fs.existsSync(dbPath)) {
-      await fs.promises.mkdir(dbPath, { recursive: true });
-    }
+    await fs.promises.mkdir(dbPath, { recursive: true });
 
     const db = new LioranDB(dbPath, name, this);
     this.openDBs.set(name, db);
     return db;
   }
 
-  /* -------------------------------- LIFECYCLE -------------------------------- */
-
-  async closeDatabase(name: string): Promise<void> {
-    if (this.ipc) return;
-
-    if (!this.openDBs.has(name)) return;
-
-    const db = this.openDBs.get(name)!;
-    await db.close();
-    this.openDBs.delete(name);
-  }
-
-  /**
-   * Gracefully shuts down everything.
-   * - Closes all databases
-   * - Terminates IPC worker if running
-   */
   async closeAll(): Promise<void> {
     if (this.closed) return;
     this.closed = true;
 
-    if (this.ipc) {
+    if (this.mode === ProcessMode.CLIENT) {
       await dbQueue.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();
   }
 
-  /**
-   * Alias for closeAll() (clean public API)
-   */
   async close(): Promise<void> {
     return this.closeAll();
   }
@@ -137,73 +149,9 @@ export class LioranManager {
       throw new Error("LioranManager is closed");
     }
   }
-
-  /* -------------------------------- MANAGEMENT -------------------------------- */
-
-  async renameDatabase(oldName: string, newName: string): Promise<boolean> {
-    if (this.ipc) {
-      return (await dbQueue.exec("renameDatabase", { oldName, newName })) as boolean;
-    }
-
-    const oldPath = path.join(this.rootPath, oldName);
-    const newPath = path.join(this.rootPath, newName);
-
-    if (!fs.existsSync(oldPath)) {
-      throw new Error(`Database "${oldName}" not found`);
-    }
-
-    if (fs.existsSync(newPath)) {
-      throw new Error(`Database "${newName}" already exists`);
-    }
-
-    await this.closeDatabase(oldName);
-    await fs.promises.rename(oldPath, newPath);
-    return true;
-  }
-
-  async deleteDatabase(name: string): Promise<boolean> {
-    return this.dropDatabase(name);
-  }
-
-  async dropDatabase(name: string): Promise<boolean> {
-    if (this.ipc) {
-      return (await dbQueue.exec("dropDatabase", { name })) as boolean;
-    }
-
-    const dbPath = path.join(this.rootPath, name);
-
-    if (!fs.existsSync(dbPath)) return false;
-
-    await this.closeDatabase(name);
-    await fs.promises.rm(dbPath, { recursive: true, force: true });
-    return true;
-  }
-
-  async listDatabases(): Promise<string[]> {
-    if (this.ipc) {
-      return (await dbQueue.exec("listDatabases", {})) as string[];
-    }
-
-    const items = await fs.promises.readdir(this.rootPath, {
-      withFileTypes: true
-    });
-
-    return items.filter(i => i.isDirectory()).map(i => i.name);
-  }
-
-  /* -------------------------------- DEBUG -------------------------------- */
-
-  getStats() {
-    return {
-      rootPath: this.rootPath,
-      openDatabases: this.ipc ? ["<ipc>"] : [...this.openDBs.keys()],
-      ipc: this.ipc,
-      closed: this.closed
-    };
-  }
 }
 
-/* -------------------------------- IPC PROXY DB -------------------------------- */
+/* ---------------- IPC PROXY DB ---------------- */
 
 class IPCDatabase {
   constructor(private name: string) {}
@@ -240,4 +188,4 @@ class IPCCollection {
   deleteMany = (filter: any) => this.call("deleteMany", [filter]);
   countDocuments = (filter?: any) =>
     this.call("countDocuments", [filter]);
-}
+}