@liorandb/core 1.0.12 → 1.0.13

package/dist/index.js

@@ -1,8 +1,793 @@
-import {
-  LioranDB,
-  LioranManager,
-  getBaseDBFolder
-} from "./chunk-ST6KMJQJ.js";
+// src/LioranManager.ts
+import path4 from "path";
+import fs4 from "fs";
+import process2 from "process";
+
+// 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.writeWAL([{ tx: this.txId, applied: true }]);
+    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 raw = await fs.promises.readFile(this.walPath, "utf8");
+    const committed = /* @__PURE__ */ new Set();
+    const applied = /* @__PURE__ */ new Set();
+    const ops = /* @__PURE__ */ new Map();
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = 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 {
+        break;
+      }
+    }
+    for (const tx of committed) {
+      if (applied.has(tx)) continue;
+      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/ipc/client.ts
+import net from "net";
+
+// src/ipc/socketPath.ts
+import os3 from "os";
+import path3 from "path";
+function getIPCSocketPath(rootPath) {
+  if (os3.platform() === "win32") {
+    return `\\\\.\\pipe\\liorandb_${rootPath.replace(/[:\\\/]/g, "_")}`;
+  }
+  return path3.join(rootPath, ".lioran.sock");
+}
+
+// src/ipc/client.ts
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function connectWithRetry(path5) {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await new Promise((resolve, reject) => {
+        const socket = net.connect(path5, () => resolve(socket));
+        socket.once("error", reject);
+      });
+    } catch (err) {
+      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
+        if (attempt++ > 80) {
+          throw new Error("IPC server not reachable");
+        }
+        await delay(50);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+var IPCClient = class {
+  socket;
+  buffer = "";
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  ready;
+  constructor(rootPath) {
+    const socketPath = getIPCSocketPath(rootPath);
+    this.ready = this.init(socketPath);
+  }
+  async init(socketPath) {
+    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, args) {
+    await this.ready;
+    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 {
+    }
+  }
+};
+
+// src/ipc/queue.ts
+var DBQueue = class {
+  client;
+  constructor(rootPath = getDefaultRootPath()) {
+    this.client = new IPCClient(rootPath);
+  }
+  exec(action, args) {
+    return this.client.exec(action, args);
+  }
+  async shutdown() {
+    try {
+      await this.exec("shutdown", {});
+    } catch {
+    }
+    this.client.close();
+  }
+};
+var dbQueue = new DBQueue();
+
+// src/ipc/server.ts
+import net2 from "net";
+import fs3 from "fs";
+var IPCServer = class {
+  server;
+  manager;
+  socketPath;
+  constructor(manager, rootPath) {
+    this.manager = manager;
+    this.socketPath = getIPCSocketPath(rootPath);
+  }
+  start() {
+    if (!this.socketPath.startsWith("\\\\.\\")) {
+      if (fs3.existsSync(this.socketPath)) fs3.unlinkSync(this.socketPath);
+    }
+    this.server = net2.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);
+    });
+  }
+  async handleMessage(socket, msg) {
+    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[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) {
+      socket.write(JSON.stringify({ id, ok: false, error: err.message }) + "\n");
+    }
+  }
+  async close() {
+    if (this.server) this.server.close();
+    if (!this.socketPath.startsWith("\\\\.\\")) {
+      try {
+        fs3.unlinkSync(this.socketPath);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/LioranManager.ts
+var LioranManager = class {
+  rootPath;
+  openDBs;
+  closed = false;
+  mode;
+  lockFd;
+  ipcServer;
+  constructor(options = {}) {
+    const { rootPath, encryptionKey } = options;
+    this.rootPath = rootPath || getDefaultRootPath();
+    if (!fs4.existsSync(this.rootPath)) {
+      fs4.mkdirSync(this.rootPath, { recursive: true });
+    }
+    if (encryptionKey) {
+      setEncryptionKey(encryptionKey);
+    }
+    this.openDBs = /* @__PURE__ */ new Map();
+    this.mode = this.tryAcquireLock() ? "primary" /* PRIMARY */ : "client" /* CLIENT */;
+    if (this.mode === "primary" /* PRIMARY */) {
+      this.ipcServer = new IPCServer(this, this.rootPath);
+      this.ipcServer.start();
+      this._registerShutdownHooks();
+    }
+  }
+  isProcessAlive(pid) {
+    try {
+      process2.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  tryAcquireLock() {
+    const lockPath = path4.join(this.rootPath, ".lioran.lock");
+    try {
+      this.lockFd = fs4.openSync(lockPath, "wx");
+      fs4.writeSync(this.lockFd, String(process2.pid));
+      return true;
+    } catch {
+      try {
+        const pid = Number(fs4.readFileSync(lockPath, "utf8"));
+        if (!this.isProcessAlive(pid)) {
+          fs4.unlinkSync(lockPath);
+          this.lockFd = fs4.openSync(lockPath, "wx");
+          fs4.writeSync(this.lockFd, String(process2.pid));
+          return true;
+        }
+      } catch {
+      }
+      return false;
+    }
+  }
+  async db(name) {
+    if (this.mode === "client" /* CLIENT */) {
+      await dbQueue.exec("db", { db: name });
+      return new IPCDatabase(name);
+    }
+    return this.openDatabase(name);
+  }
+  async openDatabase(name) {
+    this._assertOpen();
+    if (this.openDBs.has(name)) {
+      return this.openDBs.get(name);
+    }
+    const dbPath = path4.join(this.rootPath, name);
+    await fs4.promises.mkdir(dbPath, { recursive: true });
+    const db = new LioranDB(dbPath, name, this);
+    this.openDBs.set(name, db);
+    return db;
+  }
+  async closeAll() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.mode === "client" /* CLIENT */) {
+      await dbQueue.shutdown();
+      return;
+    }
+    for (const db of this.openDBs.values()) {
+      try {
+        await db.close();
+      } catch {
+      }
+    }
+    this.openDBs.clear();
+    try {
+      if (this.lockFd) fs4.closeSync(this.lockFd);
+      fs4.unlinkSync(path4.join(this.rootPath, ".lioran.lock"));
+    } catch {
+    }
+    await this.ipcServer?.close();
+  }
+  async close() {
+    return this.closeAll();
+  }
+  _registerShutdownHooks() {
+    const shutdown = async () => {
+      await this.closeAll();
+    };
+    process2.on("SIGINT", shutdown);
+    process2.on("SIGTERM", shutdown);
+    process2.on("exit", shutdown);
+  }
+  _assertOpen() {
+    if (this.closed) {
+      throw new Error("LioranManager is 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,
   LioranManager,