@liorandb/core 1.0.9 → 1.0.10

package/dist/chunk-DD5XS45L.js

@@ -0,0 +1,703 @@
+// src/core/database.ts
+import path2 from "path";
+import fs2 from "fs";
+
+// src/core/collection.ts
+import fs from "fs";
+import path from "path";
+import { ClassicLevel } from "classic-level";
+
+// src/core/query.ts
+function getByPath(obj, path6) {
+  return path6.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 data = Buffer.from(JSON.stringify(obj), "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;
+  walPath;
+  schema;
+  constructor(dir, schema) {
+    this.dir = dir;
+    this.db = new ClassicLevel(dir);
+    this.queue = Promise.resolve();
+    this.walPath = path.join(dir, "__wal.log");
+    this.schema = schema;
+    this.recoverFromWAL().catch(console.error);
+  }
+  setSchema(schema) {
+    this.schema = schema;
+  }
+  validate(doc) {
+    return this.schema ? validateSchema(this.schema, doc) : doc;
+  }
+  /* ---------------- WAL ---------------- */
+  async writeWAL(entry) {
+    await fs.promises.appendFile(
+      this.walPath,
+      JSON.stringify(entry) + "\n"
+    );
+  }
+  async clearWAL() {
+    if (fs.existsSync(this.walPath)) {
+      await fs.promises.unlink(this.walPath);
+    }
+  }
+  async recoverFromWAL() {
+    if (!fs.existsSync(this.walPath)) return;
+    const lines = (await fs.promises.readFile(this.walPath, "utf8")).split("\n").filter(Boolean);
+    for (const line of lines) {
+      try {
+        const { op, args } = JSON.parse(line);
+        await this._exec(op, args, false);
+      } catch (err) {
+        console.error("WAL recovery failed:", err);
+      }
+    }
+    await this.clearWAL();
+  }
+  /* ---------------- Queue ---------------- */
+  _enqueue(task) {
+    this.queue = this.queue.then(task).catch(console.error);
+    return this.queue;
+  }
+  /* ---------------- Core Executor ---------------- */
+  async _exec(op, args, log = true) {
+    if (log) await this.writeWAL({ op, args });
+    let result;
+    switch (op) {
+      case "insertOne":
+        result = await this._insertOne(args[0]);
+        break;
+      case "insertMany":
+        result = await this._insertMany(args[0]);
+        break;
+      case "find":
+        result = await this._find(args[0]);
+        break;
+      case "findOne":
+        result = await this._findOne(args[0]);
+        break;
+      case "updateOne":
+        result = await this._updateOne(args[0], args[1], args[2]);
+        break;
+      case "updateMany":
+        result = await this._updateMany(args[0], args[1]);
+        break;
+      case "deleteOne":
+        result = await this._deleteOne(args[0]);
+        break;
+      case "deleteMany":
+        result = await this._deleteMany(args[0]);
+        break;
+      case "countDocuments":
+        result = await this._countDocuments(args[0]);
+        break;
+      default:
+        throw new Error(`Unknown operation: ${op}`);
+    }
+    if (log) await this.clearWAL();
+    return result;
+  }
+  /* ---------------- Public API ---------------- */
+  async close() {
+    try {
+      await this.db.close();
+    } catch {
+    }
+  }
+  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 = { upsert: false }) {
+    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])
+    );
+  }
+  /* ---------------- Internal Ops ---------------- */
+  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 ops = [];
+    const out = [];
+    for (const d of docs) {
+      const _id = d._id ?? uuid();
+      const final = this.validate({ _id, ...d });
+      ops.push({
+        type: "put",
+        key: String(_id),
+        value: encryptData(final)
+      });
+      out.push(final);
+    }
+    await this.db.batch(ops);
+    return out;
+  }
+  async _updateOne(filter, update, options) {
+    for await (const [key, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) {
+        const updated = applyUpdate(value, update);
+        updated._id = value._id;
+        const validated = this.validate(updated);
+        await this.db.put(key, encryptData(validated));
+        return validated;
+      }
+    }
+    if (options?.upsert) {
+      const doc = applyUpdate(filter, update);
+      doc._id ??= uuid();
+      const validated = this.validate(doc);
+      await this.db.put(String(doc._id), encryptData(validated));
+      return validated;
+    }
+    return null;
+  }
+  async _updateMany(filter, update) {
+    const updated = [];
+    for await (const [key, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) {
+        const doc = applyUpdate(value, update);
+        doc._id = value._id;
+        const validated = this.validate(doc);
+        await this.db.put(key, encryptData(validated));
+        updated.push(validated);
+      }
+    }
+    return updated;
+  }
+  async _find(query) {
+    const out = [];
+    for await (const [, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, query)) out.push(value);
+    }
+    return out;
+  }
+  async _findOne(query) {
+    for await (const [, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, query)) return value;
+    }
+    return null;
+  }
+  async _deleteOne(filter) {
+    for await (const [key, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, 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()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) {
+        await this.db.del(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async _countDocuments(filter) {
+    let c = 0;
+    for await (const [, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) c++;
+    }
+    return c;
+  }
+};
+
+// src/core/database.ts
+var LioranDB = class {
+  basePath;
+  dbName;
+  manager;
+  collections;
+  constructor(basePath, dbName, manager) {
+    this.basePath = basePath;
+    this.dbName = dbName;
+    this.manager = manager;
+    this.collections = /* @__PURE__ */ new Map();
+    if (!fs2.existsSync(basePath)) {
+      fs2.mkdirSync(basePath, { recursive: true });
+    }
+  }
+  /* -------------------------------- COLLECTION -------------------------------- */
+  collection(name, schema) {
+    if (this.collections.has(name)) {
+      const col2 = this.collections.get(name);
+      if (schema) col2.setSchema(schema);
+      return col2;
+    }
+    const colPath = path2.join(this.basePath, name);
+    if (!fs2.existsSync(colPath)) {
+      fs2.mkdirSync(colPath, { recursive: true });
+    }
+    const col = new Collection(colPath, schema);
+    this.collections.set(name, col);
+    return col;
+  }
+  async createCollection(name, schema) {
+    const colPath = path2.join(this.basePath, name);
+    if (fs2.existsSync(colPath)) {
+      throw new Error("Collection already exists");
+    }
+    await fs2.promises.mkdir(colPath, { recursive: true });
+    const col = new Collection(colPath, schema);
+    this.collections.set(name, col);
+    return col;
+  }
+  async deleteCollection(name) {
+    const colPath = path2.join(this.basePath, name);
+    if (!fs2.existsSync(colPath)) {
+      throw new Error("Collection does not exist");
+    }
+    if (this.collections.has(name)) {
+      await this.collections.get(name).close();
+      this.collections.delete(name);
+    }
+    await fs2.promises.rm(colPath, { recursive: true, force: true });
+    return true;
+  }
+  async renameCollection(oldName, newName) {
+    const oldPath = path2.join(this.basePath, oldName);
+    const newPath = path2.join(this.basePath, newName);
+    if (!fs2.existsSync(oldPath)) {
+      throw new Error("Collection does not exist");
+    }
+    if (fs2.existsSync(newPath)) {
+      throw new Error("New collection name already exists");
+    }
+    if (this.collections.has(oldName)) {
+      await this.collections.get(oldName).close();
+      this.collections.delete(oldName);
+    }
+    await fs2.promises.rename(oldPath, newPath);
+    const col = new Collection(newPath);
+    this.collections.set(newName, col);
+    return true;
+  }
+  async dropCollection(name) {
+    return this.deleteCollection(name);
+  }
+  async listCollections() {
+    const dirs = await fs2.promises.readdir(this.basePath, {
+      withFileTypes: true
+    });
+    return dirs.filter((d) => d.isDirectory()).map((d) => d.name);
+  }
+  /* -------------------------------- LIFECYCLE -------------------------------- */
+  async close() {
+    for (const col of this.collections.values()) {
+      try {
+        await col.close();
+      } catch {
+      }
+    }
+    this.collections.clear();
+  }
+  /* -------------------------------- DEBUG -------------------------------- */
+  getStats() {
+    return {
+      dbName: this.dbName,
+      basePath: this.basePath,
+      collections: [...this.collections.keys()]
+    };
+  }
+};
+
+// src/utils/rootpath.ts
+import os2 from "os";
+import path3 from "path";
+import fs3 from "fs";
+function getDefaultRootPath() {
+  let dbPath = process.env.LIORANDB_PATH;
+  if (!dbPath) {
+    const homeDir = os2.homedir();
+    dbPath = path3.join(homeDir, "LioranDB", "db");
+    if (!fs3.existsSync(dbPath)) {
+      fs3.mkdirSync(dbPath, { recursive: true });
+    }
+    process.env.LIORANDB_PATH = dbPath;
+  }
+  return dbPath;
+}
+function getBaseDBFolder() {
+  return getDefaultRootPath();
+}
+
+// src/LioranManager.ts
+import path5 from "path";
+import fs4 from "fs";
+
+// src/ipc/queue.ts
+import { fork } from "child_process";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
+function resolveWorkerPath() {
+  return path4.resolve(__dirname, "../worker/dbWorker.js");
+}
+var DBQueue = class {
+  worker;
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  constructor() {
+    const workerPath = resolveWorkerPath();
+    this.worker = fork(workerPath);
+    this.worker.on("message", (msg) => {
+      const cb = this.pending.get(msg.id);
+      if (cb) {
+        this.pending.delete(msg.id);
+        cb(msg);
+      }
+    });
+  }
+  exec(action, args) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.seq;
+      this.pending.set(id, (msg) => {
+        if (msg.ok) resolve(msg.result);
+        else reject(new Error(msg.error));
+      });
+      this.worker.send({ id, action, args });
+    });
+  }
+};
+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 (!fs4.existsSync(this.rootPath)) {
+      fs4.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 = path5.join(this.rootPath, name);
+    if (fs4.existsSync(dbPath)) {
+      throw new Error(`Database "${name}" already exists`);
+    }
+    await fs4.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 = path5.join(this.rootPath, name);
+    if (!fs4.existsSync(dbPath)) {
+      await fs4.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);
+  }
+  async closeAll() {
+    if (this.ipc || this.closed) return;
+    this.closed = true;
+    for (const db of this.openDBs.values()) {
+      try {
+        await db.close();
+      } catch {
+      }
+    }
+    this.openDBs.clear();
+  }
+  _registerShutdownHooks() {
+    const shutdown = async () => {
+      await this.closeAll();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("exit", () => {
+      this.closeAll().catch(() => {
+      });
+    });
+  }
+  _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 = path5.join(this.rootPath, oldName);
+    const newPath = path5.join(this.rootPath, newName);
+    if (!fs4.existsSync(oldPath)) {
+      throw new Error(`Database "${oldName}" not found`);
+    }
+    if (fs4.existsSync(newPath)) {
+      throw new Error(`Database "${newName}" already exists`);
+    }
+    await this.closeDatabase(oldName);
+    await fs4.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 = path5.join(this.rootPath, name);
+    if (!fs4.existsSync(dbPath)) return false;
+    await this.closeDatabase(name);
+    await fs4.promises.rm(dbPath, { recursive: true, force: true });
+    return true;
+  }
+  async listDatabases() {
+    if (this.ipc) {
+      return await dbQueue.exec("listDatabases", {});
+    }
+    const items = await fs4.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
+    };
+  }
+};
+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
+};