@liorandb/core 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liorandb/core",
-  "version": "1.0.12",
+  "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",

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]);
-}
+}

package/src/core/database.ts

@@ -6,7 +6,8 @@ import type { ZodSchema } from "zod";
 
 type TXOp = { tx: number; col: string; op: string; args: any[] };
 type TXCommit = { tx: number; commit: true };
-type WALEntry = TXOp | TXCommit;
+type TXApplied = { tx: number; applied: true };
+type WALEntry = TXOp | TXCommit | TXApplied;
 
 class DBTransactionContext {
   private ops: TXOp[] = [];
@@ -35,6 +36,7 @@ class DBTransactionContext {
     await this.db.writeWAL(this.ops);
     await this.db.writeWAL([{ tx: this.txId, commit: true }]);
     await this.db.applyTransaction(this.ops);
+    await this.db.writeWAL([{ tx: this.txId, applied: true }]);
     await this.db.clearWAL();
   }
 }
@@ -76,25 +78,33 @@ export class LioranDB {
   private async recoverFromWAL() {
     if (!fs.existsSync(this.walPath)) return;
 
-    const lines = (await fs.promises.readFile(this.walPath, "utf8"))
-      .split("\n")
-      .filter(Boolean);
+    const raw = await fs.promises.readFile(this.walPath, "utf8");
 
     const committed = new Set<number>();
+    const applied = new Set<number>();
     const ops = new Map<number, TXOp[]>();
 
-    for (const line of lines) {
-      const entry: WALEntry = JSON.parse(line);
-
-      if ("commit" in entry) {
-        committed.add(entry.tx);
-      } else {
-        if (!ops.has(entry.tx)) ops.set(entry.tx, []);
-        ops.get(entry.tx)!.push(entry);
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry: WALEntry = JSON.parse(line);
+
+        if ("commit" in entry) committed.add(entry.tx);
+        else if ("applied" in entry) applied.add(entry.tx);
+        else {
+          if (!ops.has(entry.tx)) ops.set(entry.tx, []);
+          ops.get(entry.tx)!.push(entry);
+        }
+      } catch {
+        // Ignore corrupted WAL tail
+        break;
       }
     }
 
     for (const tx of committed) {
+      if (applied.has(tx)) continue;
+
       const txOps = ops.get(tx);
       if (txOps) await this.applyTransaction(txOps);
     }

package/src/ipc/client.ts

@@ -0,0 +1,85 @@
+import net from "net";
+import { getIPCSocketPath } from "./socketPath.js";
+
+function delay(ms: number) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+async function connectWithRetry(path: string): Promise<net.Socket> {
+  let attempt = 0;
+
+  while (true) {
+    try {
+      return await new Promise((resolve, reject) => {
+        const socket = net.connect(path, () => resolve(socket));
+        socket.once("error", reject);
+      });
+    } catch (err: any) {
+      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
+        if (attempt++ > 80) {
+          throw new Error("IPC server not reachable");
+        }
+        await delay(50);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+
+export class IPCClient {
+  private socket!: net.Socket;
+  private buffer = "";
+  private seq = 0;
+  private pending = new Map<number, (v: any) => void>();
+  private ready: Promise<void>;
+
+  constructor(rootPath: string) {
+    const socketPath = getIPCSocketPath(rootPath);
+    this.ready = this.init(socketPath);
+  }
+
+  private async init(socketPath: string) {
+    this.socket = await connectWithRetry(socketPath);
+
+    this.socket.on("data", data => {
+      this.buffer += data.toString();
+
+      while (this.buffer.includes("\n")) {
+        const idx = this.buffer.indexOf("\n");
+        const raw = this.buffer.slice(0, idx);
+        this.buffer = this.buffer.slice(idx + 1);
+
+        const msg = JSON.parse(raw);
+        const cb = this.pending.get(msg.id);
+
+        if (cb) {
+          this.pending.delete(msg.id);
+          cb(msg);
+        }
+      }
+    });
+
+    this.socket.on("error", err => {
+      console.error("IPC socket error:", err);
+    });
+  }
+
+  async exec(action: string, args: any) {
+    await this.ready;   // 🔥 HARD BARRIER — guarantees socket exists
+
+    return new Promise((resolve, reject) => {
+      const id = ++this.seq;
+
+      this.pending.set(id, msg => {
+        msg.ok ? resolve(msg.result) : reject(new Error(msg.error));
+      });
+
+      this.socket.write(JSON.stringify({ id, action, args }) + "\n");
+    });
+  }
+
+  close() {
+    try { this.socket.end(); } catch {}
+  }
+}

package/src/ipc/queue.ts

@@ -1,137 +1,22 @@
-import { fork, ChildProcess } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-function resolveWorkerPath() {
-  return path.resolve(__dirname, "../dist/worker/dbWorker.js");
-}
+import { IPCClient } from "./client.js";
+import { getDefaultRootPath } from "../utils/rootpath.js";
 
 export class DBQueue {
-  private worker!: ChildProcess;
-  private seq = 0;
-  private pending = new Map<number, (r: any) => void>();
-  private isShutdown = false;
-  private restarting = false;
-  private workerAlive = false;
-
-  constructor() {
-    this.spawnWorker();
+  private client: IPCClient;
 
-    process.once("exit", () => this.shutdown());
-    process.once("SIGINT", () => this.shutdown());
-    process.once("SIGTERM", () => this.shutdown());
+  constructor(rootPath = getDefaultRootPath()) {
+    this.client = new IPCClient(rootPath);
   }
 
-  /* ---------------- Worker Control ---------------- */
-
-  private spawnWorker() {
-    const workerPath = resolveWorkerPath();
-
-    this.worker = fork(workerPath, [], {
-      stdio: ["inherit", "inherit", "inherit", "ipc"],
-    });
-
-    this.workerAlive = true;
-
-    this.worker.on("message", (msg: any) => {
-      const cb = this.pending.get(msg.id);
-      if (cb) {
-        this.pending.delete(msg.id);
-        cb(msg);
-      }
-    });
-
-    this.worker.once("exit", (code, signal) => {
-      this.workerAlive = false;
-
-      if (this.isShutdown) return;
-
-      console.error("DB Worker crashed, restarting...", { code, signal });
-
-      this.restartWorker();
-    });
+  exec(action: string, args: any) {
+    return this.client.exec(action, args);
   }
 
-  private restartWorker() {
-    if (this.restarting || this.isShutdown) return;
-
-    this.restarting = true;
-
-    setTimeout(() => {
-      if (this.isShutdown) return;
-
-      for (const [, cb] of this.pending) {
-        cb({ ok: false, error: "IPC worker crashed" });
-      }
-      this.pending.clear();
-      this.seq = 0;
-
-      this.spawnWorker();
-      this.restarting = false;
-    }, 500);
-  }
-
-  /* ---------------- IPC Exec ---------------- */
-
-  exec(action: string, args: any, timeout = 15000) {
-    if (this.isShutdown) {
-      return Promise.reject(new Error("DBQueue is shutdown"));
-    }
-
-    if (!this.workerAlive) {
-      return Promise.reject(new Error("IPC worker not running"));
-    }
-
-    return new Promise((resolve, reject) => {
-      const id = ++this.seq;
-
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`IPC timeout: ${action}`));
-      }, timeout);
-
-      this.pending.set(id, (msg) => {
-        clearTimeout(timer);
-        this.pending.delete(id);
-        msg.ok ? resolve(msg.result) : reject(new Error(msg.error));
-      });
-
-      try {
-        this.worker.send({ id, action, args });
-      } catch (err) {
-        clearTimeout(timer);
-        this.pending.delete(id);
-        reject(err);
-      }
-    });
-  }
-
-  /* ---------------- Clean Shutdown ---------------- */
-
   async shutdown() {
-    if (this.isShutdown) return;
-    this.isShutdown = true;
-
-    if (this.workerAlive) {
-      try {
-        this.worker.send({ action: "shutdown" });
-      } catch {}
-    }
-
-    await new Promise(resolve => {
-      if (!this.workerAlive) return resolve(null);
-      this.worker.once("exit", resolve);
-      setTimeout(resolve, 250);
-    });
-
-    for (const [, cb] of this.pending) {
-      cb({ ok: false, error: "IPC shutdown" });
-    }
-
-    this.pending.clear();
+    try {
+      await this.exec("shutdown", {});
+    } catch {}
+    this.client.close();
   }
 }
 

package/src/ipc/server.ts

@@ -0,0 +1,84 @@
+import net from "net";
+import fs from "fs";
+import { LioranManager } from "../LioranManager.js";
+import { getIPCSocketPath } from "./socketPath.js";
+
+export class IPCServer {
+  private server!: net.Server;
+  private manager: LioranManager;
+  private socketPath: string;
+
+  constructor(manager: LioranManager, rootPath: string) {
+    this.manager = manager;
+    this.socketPath = getIPCSocketPath(rootPath);
+  }
+
+  start() {
+    if (!this.socketPath.startsWith("\\\\.\\")) {
+      if (fs.existsSync(this.socketPath)) fs.unlinkSync(this.socketPath);
+    }
+
+    this.server = net.createServer(socket => {
+      let buffer = "";
+
+      socket.on("data", async data => {
+        buffer += data.toString();
+
+        while (buffer.includes("\n")) {
+          const idx = buffer.indexOf("\n");
+          const raw = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 1);
+
+          const msg = JSON.parse(raw);
+          this.handleMessage(socket, msg).catch(console.error);
+        }
+      });
+    });
+
+    this.server.listen(this.socketPath, () => {
+      console.log("[IPC] Server listening:", this.socketPath);
+    });
+  }
+
+  private async handleMessage(socket: net.Socket, msg: any) {
+    const { id, action, args } = msg;
+
+    try {
+      let result;
+
+      switch (action) {
+        case "db":
+          await this.manager.db(args.db);
+          result = true;
+          break;
+
+        case "op": {
+          const { db, col, method, params } = args;
+          const collection = (await this.manager.db(db)).collection(col);
+          result = await (collection as any)[method](...params);
+          break;
+        }
+
+        case "shutdown":
+          await this.manager.closeAll();
+          result = true;
+          break;
+
+        default:
+          throw new Error("Unknown IPC action");
+      }
+
+      socket.write(JSON.stringify({ id, ok: true, result }) + "\n");
+    } catch (err: any) {
+      socket.write(JSON.stringify({ id, ok: false, error: err.message }) + "\n");
+    }
+  }
+
+  async close() {
+    if (this.server) this.server.close();
+
+    if (!this.socketPath.startsWith("\\\\.\\")) {
+      try { fs.unlinkSync(this.socketPath); } catch {}
+    }
+  }
+}

package/src/ipc/socketPath.ts

@@ -0,0 +1,10 @@
+import os from "os";
+import path from "path";
+
+export function getIPCSocketPath(rootPath: string) {
+  if (os.platform() === "win32") {
+    return `\\\\.\\pipe\\liorandb_${rootPath.replace(/[:\\\/]/g, "_")}`;
+  }
+
+  return path.join(rootPath, ".lioran.sock");
+}

package/src/worker/dbWorker.ts

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