@liorandb/core 1.0.4 → 1.0.6

package/src/core/collection.ts

@@ -0,0 +1,163 @@
+import { ClassicLevel } from "classic-level";
+import { matchDocument, applyUpdate } from "./query.js";
+import { v4 as uuid } from "uuid";
+import { encryptData, decryptData } from "../utils/encryption.js";
+
+export interface UpdateOptions {
+  upsert?: boolean;
+}
+
+export class Collection<T = any> {
+  dir: string;
+  db: ClassicLevel<string, string>;
+  private queue: Promise<any>;
+
+  constructor(dir: string) {
+    this.dir = dir;
+    this.db = new ClassicLevel(dir);
+    this.queue = Promise.resolve();
+  }
+
+  private _enqueue<R>(task: () => Promise<R>): Promise<R> {
+    this.queue = this.queue.then(task).catch(console.error);
+    return this.queue;
+  }
+
+  async close(): Promise<void> {
+    try {
+      await this.db.close();
+    } catch {}
+  }
+
+  async insertOne(doc: T & { _id?: string }): Promise<T> {
+    return this._enqueue(async () => {
+      const _id = doc._id ?? uuid();
+      const final = { _id, ...doc } as T;
+      await this.db.put(String(_id), encryptData(final));
+      return final;
+    });
+  }
+
+  async insertMany(docs: (T & { _id?: string })[] = []): Promise<T[]> {
+    return this._enqueue(async () => {
+      const ops: Array<{ type: "put"; key: string; value: string }> = [];
+      const out: T[] = [];
+
+      for (const d of docs) {
+        const _id = d._id ?? uuid();
+        const final = { _id, ...d } as T;
+        ops.push({
+          type: "put",
+          key: String(_id),
+          value: encryptData(final)
+        });
+        out.push(final);
+      }
+
+      await this.db.batch(ops);
+      return out;
+    });
+  }
+
+  async find(query: any = {}): Promise<T[]> {
+    return this._enqueue(async () => {
+      const out: T[] = [];
+      for await (const [, enc] of this.db.iterator()) {
+        const value = decryptData(enc);
+        if (matchDocument(value, query)) out.push(value);
+      }
+      return out;
+    });
+  }
+
+  async findOne(query: any = {}): Promise<T | null> {
+    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: any = {},
+    update: any = {},
+    options: UpdateOptions = { upsert: false }
+  ): Promise<T | null> {
+    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: any = {}, update: any = {}): Promise<T[]> {
+    return this._enqueue(async () => {
+      const updated: T[] = [];
+      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: any = {}): Promise<boolean> {
+    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: any = {}): Promise<number> {
+    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: any = {}): Promise<number> {
+    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;
+    });
+  }
+}

package/src/core/{database.js → database.ts}

@@ -1,9 +1,15 @@
 import path from "path";
 import fs from "fs";
 import { Collection } from "./collection.js";
+import type { LioranManager } from "../LioranManager.js";
 
 export class LioranDB {
-  constructor(basePath, dbName, manager) {
+  basePath: string;
+  dbName: string;
+  manager: LioranManager;
+  collections: Map<string, Collection>;
+
+  constructor(basePath: string, dbName: string, manager: LioranManager) {
     this.basePath = basePath;
     this.dbName = dbName;
     this.manager = manager;
@@ -14,66 +20,51 @@ export class LioranDB {
     }
   }
 
-  /** Get or auto-create collection object */
-  collection(name) {
+  collection<T = any>(name: string): Collection<T> {
     if (this.collections.has(name)) {
-      return this.collections.get(name);
+      return this.collections.get(name)!;
     }
 
     const colPath = path.join(this.basePath, name);
 
-    // auto-create directory
     if (!fs.existsSync(colPath)) {
       fs.mkdirSync(colPath, { recursive: true });
     }
 
-    const col = new Collection(colPath);
+    const col = new Collection<T>(colPath);
     this.collections.set(name, col);
     return col;
   }
 
-  /** Create collection manually */
-  async createCollection(name) {
+  async createCollection(name: string): Promise<boolean> {
     const colPath = path.join(this.basePath, name);
 
     if (fs.existsSync(colPath)) {
       throw new Error("Collection already exists");
     }
 
-    // create folder
     await fs.promises.mkdir(colPath, { recursive: true });
-
-    // load into memory map
-    const col = new Collection(colPath);
-    this.collections.set(name, col);
-
+    this.collections.set(name, new Collection(colPath));
     return true;
   }
 
-  /** Delete collection fully */
-  async deleteCollection(name) {
+  async deleteCollection(name: string): Promise<boolean> {
     const colPath = path.join(this.basePath, name);
 
     if (!fs.existsSync(colPath)) {
       throw new Error("Collection does not exist");
     }
 
-    // close LevelDB instance if opened
     if (this.collections.has(name)) {
-      const col = this.collections.get(name);
-      await col.close().catch(() => {});
-      await col.db.clear().catch(() => {});
+      await this.collections.get(name)!.close();
       this.collections.delete(name);
     }
 
-    // force delete directory
     await fs.promises.rm(colPath, { recursive: true, force: true });
-
     return true;
   }
 
-  /** Rename collection */
-  async renameCollection(oldName, newName) {
+  async renameCollection(oldName: string, newName: string): Promise<boolean> {
     const oldPath = path.join(this.basePath, oldName);
     const newPath = path.join(this.basePath, newName);
 
@@ -81,29 +72,24 @@ export class LioranDB {
     if (fs.existsSync(newPath)) throw new Error("New collection name exists");
 
     if (this.collections.has(oldName)) {
-      await this.collections.get(oldName).close().catch(() => {});
+      await this.collections.get(oldName)!.close();
       this.collections.delete(oldName);
     }
 
     await fs.promises.rename(oldPath, newPath);
-
-    const newCol = new Collection(newPath);
-    this.collections.set(newName, newCol);
-
+    this.collections.set(newName, new Collection(newPath));
     return true;
   }
 
-  /** Drop a collection (alias deleteCollection) */
-  async dropCollection(name) {
+  async dropCollection(name: string): Promise<boolean> {
     return this.deleteCollection(name);
   }
 
-  /** List all collections */
-  async listCollections() {
-    const dirs = await fs.promises.readdir(this.basePath, { withFileTypes: true });
+  async listCollections(): Promise<string[]> {
+    const dirs = await fs.promises.readdir(this.basePath, {
+      withFileTypes: true
+    });
 
-    return dirs
-      .filter(dirent => dirent.isDirectory())
-      .map(dirent => dirent.name);
+    return dirs.filter(d => d.isDirectory()).map(d => d.name);
   }
 }

package/src/core/{query.js → query.ts}

@@ -1,8 +1,8 @@
-function getByPath(obj, path) {
+function getByPath(obj: any, path: string): any {
   return path.split(".").reduce((o, p) => (o ? o[p] : undefined), obj);
 }
 
-export function matchDocument(doc, query) {
+export function matchDocument(doc: any, query: any): boolean {
   for (const key of Object.keys(query)) {
     const cond = query[key];
     const val = getByPath(doc, key);
@@ -14,9 +14,10 @@ export function matchDocument(doc, query) {
         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 === "$ne" && val === v) return false;
         if (op === "$eq" && val !== v) return false;
-        if (op === "$in" && (!Array.isArray(v) || !v.includes(val))) return false;
+        if (op === "$in" && (!Array.isArray(v) || !v.includes(val)))
+          return false;
       }
     } else {
       if (val !== cond) return false;
@@ -25,38 +26,35 @@ export function matchDocument(doc, query) {
   return true;
 }
 
-export function applyUpdate(oldDoc, update) {
+export function applyUpdate(oldDoc: any, update: any): any {
   const doc = structuredClone(oldDoc);
 
-  // $set
   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[parts[i]] ?? {};
+        cur[parts[i]] ??= {};
         cur = cur[parts[i]];
       }
-      cur[parts.at(-1)] = update.$set[k];
+      cur[parts.at(-1)!] = update.$set[k];
     }
   }
 
-  // $inc
   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[parts[i]] ?? {};
+        cur[parts[i]] ??= {};
         cur = cur[parts[i]];
       }
-      cur[parts.at(-1)] = val + update.$inc[k];
+      cur[parts.at(-1)!] = val + update.$inc[k];
     }
   }
 
-  // Direct merge (no operators)
-  const hasOp = Object.keys(update).some((k) => k.startsWith("$"));
+  const hasOp = Object.keys(update).some(k => k.startsWith("$"));
   if (!hasOp) {
     return { ...doc, ...update };
   }

package/src/index.ts

@@ -0,0 +1,5 @@
+export { LioranManager } from "./LioranManager.js"
+export { LioranDB } from "./core/database.js"
+export { getBaseDBFolder } from "./utils/rootpath.js"
+
+export * from "./types/index.js"

package/src/types/index.ts

@@ -0,0 +1,12 @@
+export interface LioranManagerOptions {
+  rootPath?: string
+  encryptionKey?: string | Buffer
+}
+
+export interface UpdateOptions {
+  upsert?: boolean
+}
+
+export type Query<T = any> = Partial<T> & {
+  [key: string]: any
+}

package/src/utils/{encryption.js → encryption.ts}

@@ -2,14 +2,9 @@ import crypto from "crypto";
 import { getMasterKey } from "./secureKey.js";
 
 const algorithm = "aes-256-gcm";
+let ACTIVE_KEY: Buffer = getMasterKey();
 
-// 🔐 Runtime-configurable key
-let ACTIVE_KEY = getMasterKey();
-
-/**
- * Allows LioranManager to inject a custom encryption key
- */
-export function setEncryptionKey(key) {
+export function setEncryptionKey(key: string | Buffer): void {
   if (!key) return;
 
   if (typeof key === "string") {
@@ -19,7 +14,7 @@ export function setEncryptionKey(key) {
 
   if (Buffer.isBuffer(key)) {
     if (key.length !== 32) {
-      throw new Error("Encryption key must be 32 bytes (256-bit)");
+      throw new Error("Encryption key must be 32 bytes");
     }
     ACTIVE_KEY = key;
     return;
@@ -28,9 +23,9 @@ export function setEncryptionKey(key) {
   throw new Error("Invalid encryption key format");
 }
 
-export function encryptData(plainObj) {
+export function encryptData(obj: any): string {
   const iv = crypto.randomBytes(16);
-  const data = Buffer.from(JSON.stringify(plainObj), "utf8");
+  const data = Buffer.from(JSON.stringify(obj), "utf8");
 
   const cipher = crypto.createCipheriv(algorithm, ACTIVE_KEY, iv);
   const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
@@ -39,11 +34,11 @@ export function encryptData(plainObj) {
   return Buffer.concat([iv, tag, encrypted]).toString("base64");
 }
 
-export function decryptData(encStr) {
-  const buf = Buffer.from(encStr, "base64");
-  const iv = buf.slice(0, 16);
-  const tag = buf.slice(16, 32);
-  const encrypted = buf.slice(32);
+export function decryptData(enc: string): any {
+  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 = crypto.createDecipheriv(algorithm, ACTIVE_KEY, iv);
   decipher.setAuthTag(tag);

package/src/utils/rootpath.ts

@@ -0,0 +1,54 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+export function getDefaultRootPath(): string {
+  let dbPath = process.env.LIORANDB_PATH;
+
+  if (!dbPath) {
+    const homeDir = os.homedir();
+    dbPath = path.join(homeDir, "LioranDB", "db");
+
+    if (!fs.existsSync(dbPath)) {
+      fs.mkdirSync(dbPath, { recursive: true });
+    }
+
+    process.env.LIORANDB_PATH = dbPath;
+  }
+
+  return dbPath;
+}
+
+export function getBaseDBFolder(): string {
+  return getDefaultRootPath();
+}
+
+export function installSystemEnv(dbPath = getDefaultRootPath()) {
+  const platform = os.platform();
+  const scriptsDir = path.join(os.tmpdir(), "lioran_env_setup");
+
+  if (!fs.existsSync(scriptsDir)) {
+    fs.mkdirSync(scriptsDir, { recursive: true });
+  }
+
+  if (platform === "win32") {
+    const script = path.join(scriptsDir, "set-lioran-env.ps1");
+    fs.writeFileSync(
+      script,
+      `[System.Environment]::SetEnvironmentVariable("LIORANDB_PATH","${dbPath}","Machine")`
+    );
+    return { platform: "windows", script };
+  }
+
+  if (platform === "linux" || platform === "darwin") {
+    const script = path.join(scriptsDir, "set-lioran-env.sh");
+    fs.writeFileSync(
+      script,
+      `export LIORANDB_PATH="${dbPath}"`
+    );
+    fs.chmodSync(script, 0o755);
+    return { platform, script };
+  }
+
+  return null;
+}

package/src/utils/secureKey.ts

@@ -0,0 +1,15 @@
+import crypto from "crypto";
+import os from "os";
+
+export function getMasterKey(): Buffer {
+  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();
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/src/core/collection.js

@@ -1,160 +0,0 @@
-import { ClassicLevel } from "classic-level";
-import { matchDocument, applyUpdate } from "./query.js";
-import { v4 as uuid } from "uuid";
-import { encryptData, decryptData } from "../utils/encryption.js";
-
-export class Collection {
-  constructor(dir) {
-    this.dir = dir;
-    this.db = new ClassicLevel(dir, { valueEncoding: "json" });
-
-    // Queue system
-    this.queue = Promise.resolve(); // start with a resolved promise
-  }
-
-  // Queue wrapper
-  _enqueue(task) {
-    // Add task to the queue
-    this.queue = this.queue.then(() => task()).catch(console.error);
-    return this.queue;
-  }
-
-  async close() {
-    if (this.db) {
-      try {
-        await this.db.close();
-      } catch (err) {
-        console.warn("Warning: close() failed", err);
-      }
-    }
-  }
-
-  async insertOne(doc) {
-    return this._enqueue(async () => {
-      const _id = doc._id ?? uuid();
-      const final = { _id, ...doc };
-      const encrypted = encryptData(final);
-      await this.db.put(String(_id), encrypted);
-      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 };
-        const encrypted = encryptData(final);
-        ops.push({ type: "put", key: String(_id), value: encrypted });
-        out.push(final);
-      }
-
-      await this.db.batch(ops);
-      return out;
-    });
-  }
-
-  async find(query = {}) {
-    return this._enqueue(async () => {
-      const out = [];
-      for await (const [, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        if (matchDocument(value, query)) out.push(value);
-      }
-      return out;
-    });
-  }
-
-  async findOne(query = {}) {
-    return this._enqueue(async () => {
-      for await (const [, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        if (matchDocument(value, query)) return value;
-      }
-      return null;
-    });
-  }
-
-  async updateOne(filter = {}, update = {}, options = { upsert: false }) {
-    return this._enqueue(async () => {
-      for await (const [key, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        if (matchDocument(value, filter)) {
-          const updated = applyUpdate(value, update);
-          updated._id = value._id;
-          const encrypted = encryptData(updated);
-          await this.db.put(key, encrypted);
-          return updated;
-        }
-      }
-
-      if (options.upsert) {
-        const newDoc = applyUpdate(filter, update);
-        newDoc._id = newDoc._id ?? uuid();
-        const encrypted = encryptData(newDoc);
-        await this.db.put(String(newDoc._id), encrypted);
-        return newDoc;
-      }
-
-      return null;
-    });
-  }
-
-  async updateMany(filter = {}, update = {}) {
-    return this._enqueue(async () => {
-      const updated = [];
-      for await (const [key, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        if (matchDocument(value, filter)) {
-          const newDoc = applyUpdate(value, update);
-          newDoc._id = value._id;
-          const encrypted = encryptData(newDoc);
-          await this.db.put(key, encrypted);
-          updated.push(newDoc);
-        }
-      }
-      return updated;
-    });
-  }
-
-  async deleteOne(filter = {}) {
-    return this._enqueue(async () => {
-      for await (const [key, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        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, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        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 [, encValue] of this.db.iterator()) {
-        const value = decryptData(encValue);
-        if (matchDocument(value, filter)) c++;
-      }
-      return c;
-    });
-  }
-}