@liorandb/core 1.0.9 → 1.0.11

package/dist/index.js

@@ -1,438 +1,8 @@
-// src/LioranManager.ts
-import path3 from "path";
-import fs3 from "fs";
-
-// 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, path4) {
-  return path4.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/core/collection.ts
-var Collection = class {
-  dir;
-  db;
-  queue;
-  constructor(dir) {
-    this.dir = dir;
-    this.db = new ClassicLevel(dir);
-    this.queue = Promise.resolve();
-  }
-  _enqueue(task) {
-    this.queue = this.queue.then(task).catch(console.error);
-    return this.queue;
-  }
-  async close() {
-    try {
-      await this.db.close();
-    } catch {
-    }
-  }
-  async insertOne(doc) {
-    return this._enqueue(async () => {
-      const _id = doc._id ?? uuid();
-      const final = { _id, ...doc };
-      await this.db.put(String(_id), encryptData(final));
-      return final;
-    });
-  }
-  async insertMany(docs = []) {
-    return this._enqueue(async () => {
-      const ops = [];
-      const out = [];
-      for (const d of docs) {
-        const _id = d._id ?? uuid();
-        const final = { _id, ...d };
-        ops.push({
-          type: "put",
-          key: String(_id),
-          value: encryptData(final)
-        });
-        out.push(final);
-      }
-      await this.db.batch(ops);
-      return out;
-    });
-  }
-  async find(query = {}) {
-    return this._enqueue(async () => {
-      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 = {}) {
-    return this._enqueue(async () => {
-      for await (const [, enc] of this.db.iterator()) {
-        const value = decryptData(enc);
-        if (matchDocument(value, query)) return value;
-      }
-      return null;
-    });
-  }
-  async updateOne(filter = {}, update = {}, options = { upsert: false }) {
-    return this._enqueue(async () => {
-      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;
-          await this.db.put(key, encryptData(updated));
-          return updated;
-        }
-      }
-      if (options.upsert) {
-        const doc = applyUpdate(filter, update);
-        doc._id ??= uuid();
-        await this.db.put(String(doc._id), encryptData(doc));
-        return doc;
-      }
-      return null;
-    });
-  }
-  async updateMany(filter = {}, update = {}) {
-    return this._enqueue(async () => {
-      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;
-          await this.db.put(key, encryptData(doc));
-          updated.push(doc);
-        }
-      }
-      return updated;
-    });
-  }
-  async deleteOne(filter = {}) {
-    return this._enqueue(async () => {
-      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 = {}) {
-    return this._enqueue(async () => {
-      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 = {}) {
-    return this._enqueue(async () => {
-      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 (!fs.existsSync(basePath)) {
-      fs.mkdirSync(basePath, { recursive: true });
-    }
-  }
-  collection(name) {
-    if (this.collections.has(name)) {
-      return this.collections.get(name);
-    }
-    const colPath = path.join(this.basePath, name);
-    if (!fs.existsSync(colPath)) {
-      fs.mkdirSync(colPath, { recursive: true });
-    }
-    const col = new Collection(colPath);
-    this.collections.set(name, col);
-    return col;
-  }
-  async createCollection(name) {
-    const colPath = path.join(this.basePath, name);
-    if (fs.existsSync(colPath)) {
-      throw new Error("Collection already exists");
-    }
-    await fs.promises.mkdir(colPath, { recursive: true });
-    this.collections.set(name, new Collection(colPath));
-    return true;
-  }
-  async deleteCollection(name) {
-    const colPath = path.join(this.basePath, name);
-    if (!fs.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 fs.promises.rm(colPath, { recursive: true, force: true });
-    return true;
-  }
-  async renameCollection(oldName, newName) {
-    const oldPath = path.join(this.basePath, oldName);
-    const newPath = path.join(this.basePath, newName);
-    if (!fs.existsSync(oldPath)) throw new Error("Collection does not exist");
-    if (fs.existsSync(newPath)) throw new Error("New collection name exists");
-    if (this.collections.has(oldName)) {
-      await this.collections.get(oldName).close();
-      this.collections.delete(oldName);
-    }
-    await fs.promises.rename(oldPath, newPath);
-    this.collections.set(newName, new Collection(newPath));
-    return true;
-  }
-  async dropCollection(name) {
-    return this.deleteCollection(name);
-  }
-  async listCollections() {
-    const dirs = await fs.promises.readdir(this.basePath, {
-      withFileTypes: true
-    });
-    return dirs.filter((d) => d.isDirectory()).map((d) => d.name);
-  }
-};
-
-// 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
-var LioranManager = class {
-  rootPath;
-  openDBs;
-  constructor(options = {}) {
-    const { rootPath, encryptionKey } = options;
-    this.rootPath = rootPath || getDefaultRootPath();
-    if (!fs3.existsSync(this.rootPath)) {
-      fs3.mkdirSync(this.rootPath, { recursive: true });
-    }
-    if (encryptionKey) {
-      setEncryptionKey(encryptionKey);
-    }
-    this.openDBs = /* @__PURE__ */ new Map();
-  }
-  async db(name) {
-    return this.openDatabase(name);
-  }
-  async createDatabase(name) {
-    const dbPath = path3.join(this.rootPath, name);
-    if (fs3.existsSync(dbPath)) {
-      throw new Error(`Database "${name}" already exists`);
-    }
-    await fs3.promises.mkdir(dbPath, { recursive: true });
-    return this.openDatabase(name);
-  }
-  async openDatabase(name) {
-    const dbPath = path3.join(this.rootPath, name);
-    if (!fs3.existsSync(dbPath)) {
-      await fs3.promises.mkdir(dbPath, { recursive: true });
-    }
-    if (this.openDBs.has(name)) {
-      return this.openDBs.get(name);
-    }
-    const db = new LioranDB(dbPath, name, this);
-    this.openDBs.set(name, db);
-    return db;
-  }
-  async closeDatabase(name) {
-    if (!this.openDBs.has(name)) return;
-    const db = this.openDBs.get(name);
-    for (const [, col] of db.collections.entries()) {
-      await col.close();
-    }
-    this.openDBs.delete(name);
-  }
-  async renameDatabase(oldName, newName) {
-    const oldPath = path3.join(this.rootPath, oldName);
-    const newPath = path3.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) {
-    const dbPath = path3.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() {
-    const items = await fs3.promises.readdir(this.rootPath, {
-      withFileTypes: true
-    });
-    return items.filter((i) => i.isDirectory()).map((i) => i.name);
-  }
-};
+import {
+  LioranDB,
+  LioranManager,
+  getBaseDBFolder
+} from "./chunk-RIHXIHVF.js";
 export {
   LioranDB,
   LioranManager,

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export interface LioranUser {
+    id: string;
+    username: string;
+}
+export interface LioranLoginResponse {
+    user: LioranUser;
+    token: string;
+}
+export interface DocumentData {
+    _id?: string;
+    [key: string]: any;
+}
+export type Filter = Record<string, any>;
+export type UpdateQuery = {
+    $set?: Record<string, any>;
+    $inc?: Record<string, number>;
+    $unset?: Record<string, boolean>;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/parseUri.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedURI {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+}
+export declare function parseUri(uri: string): ParsedURI;

package/dist/utils/parseUri.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUri = parseUri;
+function parseUri(uri) {
+    if (!uri.startsWith("lioran://")) {
+        throw new Error("Invalid URI. Must start with lioran://");
+    }
+    const stripped = uri.replace("lioran://", "");
+    const [creds, server] = stripped.split("@");
+    if (!creds || !server) {
+        throw new Error("Invalid LioranDB URI");
+    }
+    const [username, password] = creds.split(":");
+    const [host, portStr] = server.split(":");
+    const port = Number(portStr);
+    if (!username || !password || !host || !port) {
+        throw new Error("Invalid LioranDB URI");
+    }
+    return { username, password, host, port };
+}

package/dist/worker/dbWorker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/worker/dbWorker.js

@@ -0,0 +1,40 @@
+import {
+  LioranManager
+} from "../chunk-RIHXIHVF.js";
+
+// src/worker/dbWorker.ts
+var manager = new LioranManager();
+process.on("message", async (msg) => {
+  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[method](...params);
+        break;
+      }
+      default:
+        throw new Error("Unknown action");
+    }
+    process.send?.({ id, ok: true, result });
+  } catch (err) {
+    process.send?.({ id, ok: false, error: err.message });
+  }
+});

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@liorandb/core",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "**LioranDB Core Module** – Lightweight, local-first, peer-to-peer database management for Node.js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsup src/index.ts --dts --format esm",
+    "build": "tsup src/index.ts src/worker/dbWorker.ts --dts --format esm",
     "prepublishOnly": "npm run build"
   },
   "exports": {
@@ -29,11 +29,12 @@
   "homepage": "https://github.com/LioranGroupOfficial/Liorandb#readme",
   "dependencies": {
     "classic-level": "^3.0.0",
-    "uuid": "^13.0.0"
+    "uuid": "^13.0.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.2.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
-}
+}