@liorandb/core 1.0.11 → 1.0.13

package/dist/chunk-ST6KMJQJ.js

@@ -0,0 +1,759 @@
+// src/core/database.ts
+import path from "path";
+import fs from "fs";
+
+// src/core/collection.ts
+import { ClassicLevel } from "classic-level";
+
+// src/core/query.ts
+function getByPath(obj, path5) {
+  return path5.split(".").reduce((o, p) => o ? o[p] : void 0, obj);
+}
+function matchDocument(doc, query) {
+  for (const key of Object.keys(query)) {
+    const cond = query[key];
+    const val = getByPath(doc, key);
+    if (cond && typeof cond === "object" && !Array.isArray(cond)) {
+      for (const op of Object.keys(cond)) {
+        const v = cond[op];
+        if (op === "$gt" && !(val > v)) return false;
+        if (op === "$gte" && !(val >= v)) return false;
+        if (op === "$lt" && !(val < v)) return false;
+        if (op === "$lte" && !(val <= v)) return false;
+        if (op === "$ne" && val === v) return false;
+        if (op === "$eq" && val !== v) return false;
+        if (op === "$in" && (!Array.isArray(v) || !v.includes(val)))
+          return false;
+      }
+    } else {
+      if (val !== cond) return false;
+    }
+  }
+  return true;
+}
+function applyUpdate(oldDoc, update) {
+  const doc = structuredClone(oldDoc);
+  if (update.$set) {
+    for (const k in update.$set) {
+      const parts = k.split(".");
+      let cur = doc;
+      for (let i = 0; i < parts.length - 1; i++) {
+        cur[parts[i]] ??= {};
+        cur = cur[parts[i]];
+      }
+      cur[parts.at(-1)] = update.$set[k];
+    }
+  }
+  if (update.$inc) {
+    for (const k in update.$inc) {
+      const val = getByPath(doc, k) ?? 0;
+      const parts = k.split(".");
+      let cur = doc;
+      for (let i = 0; i < parts.length - 1; i++) {
+        cur[parts[i]] ??= {};
+        cur = cur[parts[i]];
+      }
+      cur[parts.at(-1)] = val + update.$inc[k];
+    }
+  }
+  const hasOp = Object.keys(update).some((k) => k.startsWith("$"));
+  if (!hasOp) {
+    return { ...doc, ...update };
+  }
+  return doc;
+}
+
+// src/core/collection.ts
+import { v4 as uuid } from "uuid";
+
+// src/utils/encryption.ts
+import crypto2 from "crypto";
+
+// src/utils/secureKey.ts
+import crypto from "crypto";
+import os from "os";
+function getMasterKey() {
+  const fingerprint = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()?.[0]?.model ?? "unknown",
+    os.cpus()?.length ?? 0,
+    os.totalmem()
+  ].join("|");
+  return crypto.createHash("sha256").update(fingerprint).digest();
+}
+
+// src/utils/encryption.ts
+var algorithm = "aes-256-gcm";
+var ACTIVE_KEY = getMasterKey();
+function setEncryptionKey(key) {
+  if (!key) return;
+  if (typeof key === "string") {
+    ACTIVE_KEY = crypto2.createHash("sha256").update(key).digest();
+    return;
+  }
+  if (Buffer.isBuffer(key)) {
+    if (key.length !== 32) {
+      throw new Error("Encryption key must be 32 bytes");
+    }
+    ACTIVE_KEY = key;
+    return;
+  }
+  throw new Error("Invalid encryption key format");
+}
+function encryptData(obj) {
+  const iv = crypto2.randomBytes(16);
+  const json = JSON.stringify(obj);
+  if (json.length > 5e6) {
+    throw new Error("Document too large (>5MB)");
+  }
+  const data = Buffer.from(json, "utf8");
+  const cipher = crypto2.createCipheriv(algorithm, ACTIVE_KEY, iv);
+  const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, tag, encrypted]).toString("base64");
+}
+function decryptData(enc) {
+  const buf = Buffer.from(enc, "base64");
+  const iv = buf.subarray(0, 16);
+  const tag = buf.subarray(16, 32);
+  const encrypted = buf.subarray(32);
+  const decipher = crypto2.createDecipheriv(algorithm, ACTIVE_KEY, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([
+    decipher.update(encrypted),
+    decipher.final()
+  ]);
+  return JSON.parse(decrypted.toString("utf8"));
+}
+
+// src/utils/schema.ts
+function validateSchema(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      "Schema validation failed:\n" + JSON.stringify(result.error.format(), null, 2)
+    );
+  }
+  return result.data;
+}
+
+// src/core/collection.ts
+var Collection = class {
+  dir;
+  db;
+  queue = Promise.resolve();
+  schema;
+  constructor(dir, schema) {
+    this.dir = dir;
+    this.db = new ClassicLevel(dir, { valueEncoding: "utf8" });
+    this.schema = schema;
+  }
+  setSchema(schema) {
+    this.schema = schema;
+  }
+  validate(doc) {
+    return this.schema ? validateSchema(this.schema, doc) : doc;
+  }
+  _enqueue(task) {
+    this.queue = this.queue.then(task).catch(console.error);
+    return this.queue;
+  }
+  async close() {
+    try {
+      await this.db.close();
+    } catch {
+    }
+  }
+  async _exec(op, args) {
+    switch (op) {
+      case "insertOne":
+        return this._insertOne(args[0]);
+      case "insertMany":
+        return this._insertMany(args[0]);
+      case "find":
+        return this._find(args[0]);
+      case "findOne":
+        return this._findOne(args[0]);
+      case "updateOne":
+        return this._updateOne(args[0], args[1], args[2]);
+      case "updateMany":
+        return this._updateMany(args[0], args[1]);
+      case "deleteOne":
+        return this._deleteOne(args[0]);
+      case "deleteMany":
+        return this._deleteMany(args[0]);
+      case "countDocuments":
+        return this._countDocuments(args[0]);
+      default:
+        throw new Error(`Unknown operation: ${op}`);
+    }
+  }
+  insertOne(doc) {
+    return this._enqueue(() => this._exec("insertOne", [doc]));
+  }
+  insertMany(docs = []) {
+    return this._enqueue(() => this._exec("insertMany", [docs]));
+  }
+  find(query = {}) {
+    return this._enqueue(() => this._exec("find", [query]));
+  }
+  findOne(query = {}) {
+    return this._enqueue(() => this._exec("findOne", [query]));
+  }
+  updateOne(filter, update, options = {}) {
+    return this._enqueue(
+      () => this._exec("updateOne", [filter, update, options])
+    );
+  }
+  updateMany(filter, update) {
+    return this._enqueue(
+      () => this._exec("updateMany", [filter, update])
+    );
+  }
+  deleteOne(filter) {
+    return this._enqueue(
+      () => this._exec("deleteOne", [filter])
+    );
+  }
+  deleteMany(filter) {
+    return this._enqueue(
+      () => this._exec("deleteMany", [filter])
+    );
+  }
+  countDocuments(filter = {}) {
+    return this._enqueue(
+      () => this._exec("countDocuments", [filter])
+    );
+  }
+  /* ---------------- Storage ---------------- */
+  async _insertOne(doc) {
+    const _id = doc._id ?? uuid();
+    const final = this.validate({ _id, ...doc });
+    await this.db.put(String(_id), encryptData(final));
+    return final;
+  }
+  async _insertMany(docs) {
+    const batch = [];
+    const out = [];
+    for (const d of docs) {
+      const _id = d._id ?? uuid();
+      const final = this.validate({ _id, ...d });
+      batch.push({ type: "put", key: String(_id), value: encryptData(final) });
+      out.push(final);
+    }
+    await this.db.batch(batch);
+    return out;
+  }
+  async _findOne(query) {
+    if (query?._id) {
+      try {
+        const enc = await this.db.get(String(query._id));
+        return enc ? decryptData(enc) : null;
+      } catch {
+        return null;
+      }
+    }
+    for await (const [, enc] of this.db.iterator()) {
+      const v = decryptData(enc);
+      if (matchDocument(v, query)) return v;
+    }
+    return null;
+  }
+  async _updateOne(filter, update, options) {
+    for await (const [key, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) {
+        const updated = this.validate(applyUpdate(value, update));
+        updated._id = value._id;
+        await this.db.put(key, encryptData(updated));
+        return updated;
+      }
+    }
+    if (options?.upsert) {
+      const doc = this.validate({ _id: uuid(), ...applyUpdate({}, update) });
+      await this.db.put(String(doc._id), encryptData(doc));
+      return doc;
+    }
+    return null;
+  }
+  async _updateMany(filter, update) {
+    const out = [];
+    for await (const [key, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) {
+        const updated = this.validate(applyUpdate(value, update));
+        updated._id = value._id;
+        await this.db.put(key, encryptData(updated));
+        out.push(updated);
+      }
+    }
+    return out;
+  }
+  async _find(query) {
+    const out = [];
+    for await (const [, enc] of this.db.iterator()) {
+      const v = decryptData(enc);
+      if (matchDocument(v, query)) out.push(v);
+    }
+    return out;
+  }
+  async _deleteOne(filter) {
+    for await (const [key, enc] of this.db.iterator()) {
+      if (matchDocument(decryptData(enc), filter)) {
+        await this.db.del(key);
+        return true;
+      }
+    }
+    return false;
+  }
+  async _deleteMany(filter) {
+    let count = 0;
+    for await (const [key, enc] of this.db.iterator()) {
+      if (matchDocument(decryptData(enc), filter)) {
+        await this.db.del(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async _countDocuments(filter) {
+    let c = 0;
+    for await (const [, enc] of this.db.iterator()) {
+      if (matchDocument(decryptData(enc), filter)) c++;
+    }
+    return c;
+  }
+};
+
+// src/core/database.ts
+var DBTransactionContext = class {
+  constructor(db, txId) {
+    this.db = db;
+    this.txId = txId;
+  }
+  ops = [];
+  collection(name) {
+    return new Proxy({}, {
+      get: (_, prop) => {
+        return (...args) => {
+          this.ops.push({
+            tx: this.txId,
+            col: name,
+            op: prop,
+            args
+          });
+        };
+      }
+    });
+  }
+  async commit() {
+    await this.db.writeWAL(this.ops);
+    await this.db.writeWAL([{ tx: this.txId, commit: true }]);
+    await this.db.applyTransaction(this.ops);
+    await this.db.clearWAL();
+  }
+};
+var LioranDB = class _LioranDB {
+  basePath;
+  dbName;
+  manager;
+  collections;
+  walPath;
+  static TX_SEQ = 0;
+  constructor(basePath, dbName, manager) {
+    this.basePath = basePath;
+    this.dbName = dbName;
+    this.manager = manager;
+    this.collections = /* @__PURE__ */ new Map();
+    this.walPath = path.join(basePath, "__tx_wal.log");
+    fs.mkdirSync(basePath, { recursive: true });
+    this.recoverFromWAL().catch(console.error);
+  }
+  async writeWAL(entries) {
+    const fd = await fs.promises.open(this.walPath, "a");
+    for (const e of entries) {
+      await fd.write(JSON.stringify(e) + "\n");
+    }
+    await fd.sync();
+    await fd.close();
+  }
+  async clearWAL() {
+    try {
+      await fs.promises.unlink(this.walPath);
+    } catch {
+    }
+  }
+  async recoverFromWAL() {
+    if (!fs.existsSync(this.walPath)) return;
+    const lines = (await fs.promises.readFile(this.walPath, "utf8")).split("\n").filter(Boolean);
+    const committed = /* @__PURE__ */ new Set();
+    const ops = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      const entry = 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 tx of committed) {
+      const txOps = ops.get(tx);
+      if (txOps) await this.applyTransaction(txOps);
+    }
+    await this.clearWAL();
+  }
+  async applyTransaction(ops) {
+    for (const { col, op, args } of ops) {
+      const collection = this.collection(col);
+      await collection._exec(op, args);
+    }
+  }
+  collection(name, schema) {
+    if (this.collections.has(name)) {
+      const col2 = this.collections.get(name);
+      if (schema) col2.setSchema(schema);
+      return col2;
+    }
+    const colPath = path.join(this.basePath, name);
+    fs.mkdirSync(colPath, { recursive: true });
+    const col = new Collection(colPath, schema);
+    this.collections.set(name, col);
+    return col;
+  }
+  async transaction(fn) {
+    const txId = ++_LioranDB.TX_SEQ;
+    const tx = new DBTransactionContext(this, txId);
+    const result = await fn(tx);
+    await tx.commit();
+    return result;
+  }
+  async close() {
+    for (const col of this.collections.values()) {
+      try {
+        await col.close();
+      } catch {
+      }
+    }
+    this.collections.clear();
+  }
+};
+
+// src/utils/rootpath.ts
+import os2 from "os";
+import path2 from "path";
+import fs2 from "fs";
+function getDefaultRootPath() {
+  let dbPath = process.env.LIORANDB_PATH;
+  if (!dbPath) {
+    const homeDir = os2.homedir();
+    dbPath = path2.join(homeDir, "LioranDB", "db");
+    if (!fs2.existsSync(dbPath)) {
+      fs2.mkdirSync(dbPath, { recursive: true });
+    }
+    process.env.LIORANDB_PATH = dbPath;
+  }
+  return dbPath;
+}
+function getBaseDBFolder() {
+  return getDefaultRootPath();
+}
+
+// src/LioranManager.ts
+import path4 from "path";
+import fs3 from "fs";
+
+// src/ipc/queue.ts
+import { fork } from "child_process";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+function resolveWorkerPath() {
+  return path3.resolve(__dirname, "../dist/worker/dbWorker.js");
+}
+var DBQueue = class {
+  worker;
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  isShutdown = false;
+  restarting = false;
+  workerAlive = false;
+  constructor() {
+    this.spawnWorker();
+    process.once("exit", () => this.shutdown());
+    process.once("SIGINT", () => this.shutdown());
+    process.once("SIGTERM", () => this.shutdown());
+  }
+  /* ---------------- Worker Control ---------------- */
+  spawnWorker() {
+    const workerPath = resolveWorkerPath();
+    this.worker = fork(workerPath, [], {
+      stdio: ["inherit", "inherit", "inherit", "ipc"]
+    });
+    this.workerAlive = true;
+    this.worker.on("message", (msg) => {
+      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();
+    });
+  }
+  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, args, timeout = 15e3) {
+    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();
+  }
+};
+var dbQueue = new DBQueue();
+
+// src/LioranManager.ts
+var LioranManager = class {
+  rootPath;
+  openDBs;
+  closed = false;
+  ipc;
+  constructor(options = {}) {
+    const { rootPath, encryptionKey, ipc } = options;
+    this.rootPath = rootPath || getDefaultRootPath();
+    this.ipc = ipc ?? process.env.LIORANDB_IPC === "1";
+    if (!fs3.existsSync(this.rootPath)) {
+      fs3.mkdirSync(this.rootPath, { recursive: true });
+    }
+    if (encryptionKey) {
+      setEncryptionKey(encryptionKey);
+    }
+    this.openDBs = /* @__PURE__ */ new Map();
+    if (!this.ipc) {
+      this._registerShutdownHooks();
+    }
+  }
+  /* -------------------------------- CORE -------------------------------- */
+  async db(name) {
+    if (this.ipc) {
+      await dbQueue.exec("db", { db: name });
+      return new IPCDatabase(name);
+    }
+    return this.openDatabase(name);
+  }
+  async createDatabase(name) {
+    this._assertOpen();
+    const dbPath = path4.join(this.rootPath, name);
+    if (fs3.existsSync(dbPath)) {
+      throw new Error(`Database "${name}" already exists`);
+    }
+    await fs3.promises.mkdir(dbPath, { recursive: true });
+    return this.db(name);
+  }
+  async openDatabase(name) {
+    this._assertOpen();
+    if (this.openDBs.has(name)) {
+      return this.openDBs.get(name);
+    }
+    const dbPath = path4.join(this.rootPath, name);
+    if (!fs3.existsSync(dbPath)) {
+      await fs3.promises.mkdir(dbPath, { recursive: true });
+    }
+    const db = new LioranDB(dbPath, name, this);
+    this.openDBs.set(name, db);
+    return db;
+  }
+  /* -------------------------------- LIFECYCLE -------------------------------- */
+  async closeDatabase(name) {
+    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() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ipc) {
+      await dbQueue.shutdown();
+      return;
+    }
+    for (const db of this.openDBs.values()) {
+      try {
+        await db.close();
+      } catch {
+      }
+    }
+    this.openDBs.clear();
+  }
+  /**
+   * Alias for closeAll() (clean public API)
+   */
+  async close() {
+    return this.closeAll();
+  }
+  _registerShutdownHooks() {
+    const shutdown = async () => {
+      await this.closeAll();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("exit", shutdown);
+  }
+  _assertOpen() {
+    if (this.closed) {
+      throw new Error("LioranManager is closed");
+    }
+  }
+  /* -------------------------------- MANAGEMENT -------------------------------- */
+  async renameDatabase(oldName, newName) {
+    if (this.ipc) {
+      return await dbQueue.exec("renameDatabase", { oldName, newName });
+    }
+    const oldPath = path4.join(this.rootPath, oldName);
+    const newPath = path4.join(this.rootPath, newName);
+    if (!fs3.existsSync(oldPath)) {
+      throw new Error(`Database "${oldName}" not found`);
+    }
+    if (fs3.existsSync(newPath)) {
+      throw new Error(`Database "${newName}" already exists`);
+    }
+    await this.closeDatabase(oldName);
+    await fs3.promises.rename(oldPath, newPath);
+    return true;
+  }
+  async deleteDatabase(name) {
+    return this.dropDatabase(name);
+  }
+  async dropDatabase(name) {
+    if (this.ipc) {
+      return await dbQueue.exec("dropDatabase", { name });
+    }
+    const dbPath = path4.join(this.rootPath, name);
+    if (!fs3.existsSync(dbPath)) return false;
+    await this.closeDatabase(name);
+    await fs3.promises.rm(dbPath, { recursive: true, force: true });
+    return true;
+  }
+  async listDatabases() {
+    if (this.ipc) {
+      return await dbQueue.exec("listDatabases", {});
+    }
+    const items = await fs3.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
+    };
+  }
+};
+var IPCDatabase = class {
+  constructor(name) {
+    this.name = name;
+  }
+  collection(name) {
+    return new IPCCollection(this.name, name);
+  }
+};
+var IPCCollection = class {
+  constructor(db, col) {
+    this.db = db;
+    this.col = col;
+  }
+  call(method, params) {
+    return dbQueue.exec("op", {
+      db: this.db,
+      col: this.col,
+      method,
+      params
+    });
+  }
+  insertOne = (doc) => this.call("insertOne", [doc]);
+  insertMany = (docs) => this.call("insertMany", [docs]);
+  find = (query) => this.call("find", [query]);
+  findOne = (query) => this.call("findOne", [query]);
+  updateOne = (filter, update, options) => this.call("updateOne", [filter, update, options]);
+  updateMany = (filter, update) => this.call("updateMany", [filter, update]);
+  deleteOne = (filter) => this.call("deleteOne", [filter]);
+  deleteMany = (filter) => this.call("deleteMany", [filter]);
+  countDocuments = (filter) => this.call("countDocuments", [filter]);
+};
+
+export {
+  LioranDB,
+  getBaseDBFolder,
+  LioranManager
+};