@liorandb/core 1.0.11 → 1.0.13

package/src/core/transaction.ts

@@ -0,0 +1,34 @@
+import { Collection } from "./collection.js";
+
+let TX_SEQ = 0;
+
+export class TransactionContext {
+  private txId = ++TX_SEQ;
+  private ops: (() => Promise<any>)[] = [];
+
+  constructor(private db: any) {}
+
+  collection(name: string) {
+    const col = this.db.collection(name);
+
+    return new Proxy(col, {
+      get: (target, prop: any) => {
+        if (typeof (target as any)[prop] !== "function") return target[prop];
+
+        return (...args: any[]) => {
+          this.ops.push(() => (target as any)[prop](...args));
+        };
+      }
+    });
+  }
+
+  async run<T>(fn: (tx: TransactionContext) => Promise<T>): Promise<T> {
+    const result = await fn(this);
+
+    for (const op of this.ops) {
+      await op();
+    }
+
+    return result;
+  }
+}

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,45 +0,0 @@
-import { LioranManager } from "../LioranManager.js";
-
-const manager = new LioranManager();
-
-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": {
-        const 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 as any)[method](...params);
-        break;
-      }
-
-      default:
-        throw new Error("Unknown action");
-    }
-
-    process.send?.({ id, ok: true, result });
-  } catch (err: any) {
-    process.send?.({ id, ok: false, error: err.message });
-  }
-});