@liorandb/core 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liorandb/core",
-  "version": "1.0.3",
+  "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",

package/src/LioranManager.js

@@ -1,34 +1,35 @@
 import path from "path";
 import fs from "fs";
 import { LioranDB } from "./core/database.js";
+import { setEncryptionKey } from "./utils/encryption.js";
+import { getDefaultRootPath } from "./utils/rootpath.js";
 
 export class LioranManager {
-  constructor() {
-    this.rootPath = path.join(
-      process.env.LIORANDB_PATH ||
-        path.join(process.env.HOME || process.env.USERPROFILE),
-      "LioranDB",
-      "db"
-    );
+  constructor(options = {}) {
+    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);
+    }
+
     this.openDBs = new Map();
   }
 
-  // -----------------------------------------
-  // MongoDB-style: client.db("name")
-  // Auto-create database if not exists
-  // -----------------------------------------
   async db(name) {
     return this.openDatabase(name);
   }
 
-  // -----------------------------------------
-  // Create a new database (returns db instance)
-  // -----------------------------------------
   async createDatabase(name) {
     const dbPath = path.join(this.rootPath, name);
 
@@ -40,13 +41,9 @@ export class LioranManager {
     return this.openDatabase(name);
   }
 
-  // -----------------------------------------
-  // Open DB - AUTO CREATE if missing
-  // -----------------------------------------
   async openDatabase(name) {
     const dbPath = path.join(this.rootPath, name);
 
-    // Auto-create if not exists
     if (!fs.existsSync(dbPath)) {
       await fs.promises.mkdir(dbPath, { recursive: true });
     }
@@ -61,9 +58,6 @@ export class LioranManager {
     return db;
   }
 
-  // -----------------------------------------
-  // Close database
-  // -----------------------------------------
   async closeDatabase(name) {
     if (!this.openDBs.has(name)) return;
 
@@ -76,25 +70,22 @@ export class LioranManager {
     this.openDBs.delete(name);
   }
 
-  // -----------------------------------------
-  // Rename database
-  // -----------------------------------------
   async renameDatabase(oldName, newName) {
     const oldPath = path.join(this.rootPath, oldName);
     const newPath = path.join(this.rootPath, newName);
 
-    if (!fs.existsSync(oldPath)) throw new Error(`Database "${oldName}" not found`);
-    if (fs.existsSync(newPath)) throw new Error(`Database "${newName}" already exists`);
+    if (!fs.existsSync(oldPath)) {
+      throw new Error(`Database "${oldName}" not found`);
+    }
+    if (fs.existsSync(newPath)) {
+      throw new Error(`Database "${newName}" already exists`);
+    }
 
     await this.closeDatabase(oldName);
     await fs.promises.rename(oldPath, newPath);
-
     return true;
   }
 
-  // -----------------------------------------
-  // Delete / Drop database
-  // -----------------------------------------
   async deleteDatabase(name) {
     return this.dropDatabase(name);
   }
@@ -106,13 +97,9 @@ export class LioranManager {
 
     await this.closeDatabase(name);
     await fs.promises.rm(dbPath, { recursive: true, force: true });
-
     return true;
   }
 
-  // -----------------------------------------
-  // List all databases
-  // -----------------------------------------
   async listDatabases() {
     const items = await fs.promises.readdir(this.rootPath, { withFileTypes: true });
     return items.filter(i => i.isDirectory()).map(i => i.name);

package/src/index.d.ts

@@ -1,107 +1,19 @@
-// ================================================
-// @liorandb/core - Type Definitions
-// ================================================
-
 declare module "@liorandb/core" {
-  // --------------------------
-  // Generic Query Operators
-  // --------------------------
-
-  export interface QueryOperators<T> {
-    $gt?: T;
-    $gte?: T;
-    $lt?: T;
-    $lte?: T;
-    $ne?: T;
-    $in?: T[];
-  }
-
-  export type FilterQuery<T> = {
-    [K in keyof T]?: T[K] | QueryOperators<T[K]>;
-  };
 
-  // --------------------------
-  // Update Operators
-  // --------------------------
-
-  export interface UpdateSet<T> {
-    $set?: Partial<T>;
-  }
-
-  export interface UpdateInc<T> {
-    $inc?: {
-      [K in keyof T]?: number;
-    };
+  export interface LioranManagerOptions {
+    rootPath?: string;
+    encryptionKey?: string | Buffer;
   }
 
-  export type UpdateQuery<T> = Partial<T> | (UpdateSet<T> & UpdateInc<T>);
-
-  // --------------------------
-  // Collection Class
-  // --------------------------
-
-  export class Collection<T extends { _id?: string }> {
-    constructor(dir: string);
-
-    close(): Promise<void>;
-
-    insertOne(doc: T): Promise<T>;
-    insertMany(docs: T[]): Promise<T[]>;
-
-    find(query?: FilterQuery<T>): Promise<T[]>;
-    findOne(query?: FilterQuery<T>): Promise<T | null>;
-
-    updateOne(
-      filter: FilterQuery<T>,
-      update: UpdateQuery<T>,
-      options?: { upsert?: boolean }
-    ): Promise<T | null>;
-
-    updateMany(
-      filter: FilterQuery<T>,
-      update: UpdateQuery<T>
-    ): Promise<T[]>;
-
-    deleteOne(filter: FilterQuery<T>): Promise<boolean>;
-    deleteMany(filter: FilterQuery<T>): Promise<number>;
-
-    countDocuments(filter?: FilterQuery<T>): Promise<number>;
-  }
-
-  // --------------------------
-  // LioranDB: Database Instance
-  // --------------------------
-
-  export class LioranDB {
-    basePath: string;
-    dbName: string;
-
-    constructor(basePath: string, dbName: string, manager: LioranManager);
-
-    collection<T extends { _id?: string }>(name: string): Collection<T>;
-
-    createCollection(name: string): Promise<boolean>;
-    deleteCollection(name: string): Promise<boolean>;
-    dropCollection(name: string): Promise<boolean>;
-    renameCollection(oldName: string, newName: string): Promise<boolean>;
-
-    listCollections(): Promise<string[]>;
-  }
-
-  // --------------------------
-  // LioranManager
-  // --------------------------
-
   export class LioranManager {
     rootPath: string;
 
-    constructor();
+    constructor(options?: LioranManagerOptions);
 
-    // MongoDB-style
-    db(name: string): Promise<LioranDB>;
+    db(name: string): Promise<any>;
 
-    createDatabase(name: string): Promise<LioranDB>;
-    openDatabase(name: string): Promise<LioranDB>;
+    createDatabase(name: string): Promise<any>;
+    openDatabase(name: string): Promise<any>;
     closeDatabase(name: string): Promise<void>;
 
     renameDatabase(oldName: string, newName: string): Promise<boolean>;
@@ -111,13 +23,4 @@ declare module "@liorandb/core" {
 
     listDatabases(): Promise<string[]>;
   }
-
-  // --------------------------
-  // Utils
-  // --------------------------
-
-  export function getBaseDBFolder(): string;
-
-  // Package exports
-  export { LioranManager, LioranDB, getBaseDBFolder };
 }

package/src/utils/encryption.js

@@ -2,17 +2,40 @@ import crypto from "crypto";
 import { getMasterKey } from "./secureKey.js";
 
 const algorithm = "aes-256-gcm";
-const key = Buffer.from(getMasterKey(), "hex");
+
+// 🔐 Runtime-configurable key
+let ACTIVE_KEY = getMasterKey();
+
+/**
+ * Allows LioranManager to inject a custom encryption key
+ */
+export function setEncryptionKey(key) {
+  if (!key) return;
+
+  if (typeof key === "string") {
+    ACTIVE_KEY = crypto.createHash("sha256").update(key).digest();
+    return;
+  }
+
+  if (Buffer.isBuffer(key)) {
+    if (key.length !== 32) {
+      throw new Error("Encryption key must be 32 bytes (256-bit)");
+    }
+    ACTIVE_KEY = key;
+    return;
+  }
+
+  throw new Error("Invalid encryption key format");
+}
 
 export function encryptData(plainObj) {
-  const iv = crypto.randomBytes(16); // random 16-byte IV
+  const iv = crypto.randomBytes(16);
   const data = Buffer.from(JSON.stringify(plainObj), "utf8");
 
-  const cipher = crypto.createCipheriv(algorithm, key, iv);
+  const cipher = crypto.createCipheriv(algorithm, ACTIVE_KEY, iv);
   const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
   const tag = cipher.getAuthTag();
 
-  // store as iv + tag + data, base64 encoded
   return Buffer.concat([iv, tag, encrypted]).toString("base64");
 }
 
@@ -22,9 +45,13 @@ export function decryptData(encStr) {
   const tag = buf.slice(16, 32);
   const encrypted = buf.slice(32);
 
-  const decipher = crypto.createDecipheriv(algorithm, key, iv);
+  const decipher = crypto.createDecipheriv(algorithm, ACTIVE_KEY, iv);
   decipher.setAuthTag(tag);
 
-  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  const decrypted = Buffer.concat([
+    decipher.update(encrypted),
+    decipher.final()
+  ]);
+
   return JSON.parse(decrypted.toString("utf8"));
 }

package/src/utils/secureKey.js

@@ -2,21 +2,20 @@ import crypto from "crypto";
 import os from "os";
 
 /**
- * Returns a 256-bit master key derived from machine hardware.
- * No env vars. No files. Machine-bound.
+ * Default machine-bound key (used ONLY if user does not supply one)
  */
 export function getMasterKey() {
-  const hardwareFingerprint = [
+  const fingerprint = [
     os.hostname(),
     os.platform(),
     os.arch(),
-    os.cpus()?.[0]?.model || "unknown-cpu",
-    os.cpus()?.length.toString() || "0",
-    os.totalmem().toString()
+    os.cpus()?.[0]?.model || "unknown",
+    os.cpus()?.length || 0,
+    os.totalmem()
   ].join("|");
 
   return crypto
     .createHash("sha256")
-    .update(hardwareFingerprint)
+    .update(fingerprint)
     .digest(); // 32 bytes
 }