@liorandb/core 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import { ClassicLevel } from 'classic-level';
+
+interface UpdateOptions$1 {
+    upsert?: boolean;
+}
+declare class Collection<T = any> {
+    dir: string;
+    db: ClassicLevel<string, string>;
+    private queue;
+    constructor(dir: string);
+    private _enqueue;
+    close(): Promise<void>;
+    insertOne(doc: T & {
+        _id?: string;
+    }): Promise<T>;
+    insertMany(docs?: (T & {
+        _id?: string;
+    })[]): Promise<T[]>;
+    find(query?: any): Promise<T[]>;
+    findOne(query?: any): Promise<T | null>;
+    updateOne(filter?: any, update?: any, options?: UpdateOptions$1): Promise<T | null>;
+    updateMany(filter?: any, update?: any): Promise<T[]>;
+    deleteOne(filter?: any): Promise<boolean>;
+    deleteMany(filter?: any): Promise<number>;
+    countDocuments(filter?: any): Promise<number>;
+}
+
+declare class LioranDB {
+    basePath: string;
+    dbName: string;
+    manager: LioranManager;
+    collections: Map<string, Collection>;
+    constructor(basePath: string, dbName: string, manager: LioranManager);
+    collection<T = any>(name: string): Collection<T>;
+    createCollection(name: string): Promise<boolean>;
+    deleteCollection(name: string): Promise<boolean>;
+    renameCollection(oldName: string, newName: string): Promise<boolean>;
+    dropCollection(name: string): Promise<boolean>;
+    listCollections(): Promise<string[]>;
+}
+
+interface LioranManagerOptions$1 {
+    rootPath?: string;
+    encryptionKey?: string | Buffer;
+}
+declare class LioranManager {
+    rootPath: string;
+    openDBs: Map<string, LioranDB>;
+    constructor(options?: LioranManagerOptions$1);
+    db(name: string): Promise<LioranDB>;
+    createDatabase(name: string): Promise<LioranDB>;
+    openDatabase(name: string): Promise<LioranDB>;
+    closeDatabase(name: string): Promise<void>;
+    renameDatabase(oldName: string, newName: string): Promise<boolean>;
+    deleteDatabase(name: string): Promise<boolean>;
+    dropDatabase(name: string): Promise<boolean>;
+    listDatabases(): Promise<string[]>;
+}
+
+declare function getBaseDBFolder(): string;
+
+interface LioranManagerOptions {
+    rootPath?: string;
+    encryptionKey?: string | Buffer;
+}
+interface UpdateOptions {
+    upsert?: boolean;
+}
+type Query<T = any> = Partial<T> & {
+    [key: string]: any;
+};
+
+export { LioranDB, LioranManager, type LioranManagerOptions, type Query, type UpdateOptions, getBaseDBFolder };

package/dist/index.js

@@ -0,0 +1,440 @@
+// 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);
+  }
+};
+export {
+  LioranDB,
+  LioranManager,
+  getBaseDBFolder
+};

package/package.json

@@ -1,27 +1,38 @@
-{
-  "name": "@liorandb/core",
-  "version": "1.0.4",
-  "description": "LioranDB is a lightweight, local-first, peer-to-peer, file-based database with a MongoDB-style Node.js API and a simple CLI for seamless distributed development.",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "type": "module",
-  "scripts": {},
-  "bin": {},
-  "keywords": [
-    "p2p-database",
-    "lioran",
-    "liorandb",
-    "p2p-db",
-    "peer-to-peer-db",
-    "peer-to-peer-database",
-    "localfirst-db",
-    "localfirst-database"
-  ],
-  "author": "Swaraj Puppalwar",
-  "license": "LIORANDB LICENSE",
-  "dependencies": {
-    "classic-level": "^1.3.0",
-    "crypto": "^1.0.1",
-    "uuid": "^9.0.0"
-  }
-}
+{
+  "name": "@liorandb/core",
+  "version": "1.0.6",
+  "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",
+    "prepublishOnly": "npm run build"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LioranGroups/Liorandb.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/LioranGroups/Liorandb/issues"
+  },
+  "homepage": "https://github.com/LioranGroups/Liorandb#readme",
+  "dependencies": {
+    "classic-level": "^3.0.0",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}

package/src/{LioranManager.js → LioranManager.ts}

@@ -4,21 +4,24 @@ import { LioranDB } from "./core/database.js";
 import { setEncryptionKey } from "./utils/encryption.js";
 import { getDefaultRootPath } from "./utils/rootpath.js";
 
+export interface LioranManagerOptions {
+  rootPath?: string;
+  encryptionKey?: string | Buffer;
+}
+
 export class LioranManager {
-  constructor(options = {}) {
-    const {
-      rootPath,
-      encryptionKey
-    } = options;
+  rootPath: string;
+  openDBs: Map<string, LioranDB>;
+
+  constructor(options: LioranManagerOptions = {}) {
+    const { rootPath, encryptionKey } = options;
 
-    // Root DB path (custom OR default)
     this.rootPath = rootPath || getDefaultRootPath();
 
     if (!fs.existsSync(this.rootPath)) {
       fs.mkdirSync(this.rootPath, { recursive: true });
     }
 
-    // Optional custom encryption key
     if (encryptionKey) {
       setEncryptionKey(encryptionKey);
     }
@@ -26,11 +29,11 @@ export class LioranManager {
     this.openDBs = new Map();
   }
 
-  async db(name) {
+  async db(name: string): Promise<LioranDB> {
     return this.openDatabase(name);
   }
 
-  async createDatabase(name) {
+  async createDatabase(name: string): Promise<LioranDB> {
     const dbPath = path.join(this.rootPath, name);
 
     if (fs.existsSync(dbPath)) {
@@ -41,7 +44,7 @@ export class LioranManager {
     return this.openDatabase(name);
   }
 
-  async openDatabase(name) {
+  async openDatabase(name: string): Promise<LioranDB> {
     const dbPath = path.join(this.rootPath, name);
 
     if (!fs.existsSync(dbPath)) {
@@ -49,19 +52,18 @@ export class LioranManager {
     }
 
     if (this.openDBs.has(name)) {
-      return this.openDBs.get(name);
+      return this.openDBs.get(name)!;
     }
 
     const db = new LioranDB(dbPath, name, this);
     this.openDBs.set(name, db);
-
     return db;
   }
 
-  async closeDatabase(name) {
+  async closeDatabase(name: string): Promise<void> {
     if (!this.openDBs.has(name)) return;
 
-    const db = this.openDBs.get(name);
+    const db = this.openDBs.get(name)!;
 
     for (const [, col] of db.collections.entries()) {
       await col.close();
@@ -70,7 +72,7 @@ export class LioranManager {
     this.openDBs.delete(name);
   }
 
-  async renameDatabase(oldName, newName) {
+  async renameDatabase(oldName: string, newName: string): Promise<boolean> {
     const oldPath = path.join(this.rootPath, oldName);
     const newPath = path.join(this.rootPath, newName);
 
@@ -86,11 +88,11 @@ export class LioranManager {
     return true;
   }
 
-  async deleteDatabase(name) {
+  async deleteDatabase(name: string): Promise<boolean> {
     return this.dropDatabase(name);
   }
 
-  async dropDatabase(name) {
+  async dropDatabase(name: string): Promise<boolean> {
     const dbPath = path.join(this.rootPath, name);
 
     if (!fs.existsSync(dbPath)) return false;
@@ -100,8 +102,11 @@ export class LioranManager {
     return true;
   }
 
-  async listDatabases() {
-    const items = await fs.promises.readdir(this.rootPath, { withFileTypes: true });
+  async listDatabases(): Promise<string[]> {
+    const items = await fs.promises.readdir(this.rootPath, {
+      withFileTypes: true
+    });
+
     return items.filter(i => i.isDirectory()).map(i => i.name);
   }
 }