@liorandb/core 1.0.8 → 1.0.10

package/src/LioranManager.ts

@@ -3,20 +3,25 @@ import fs from "fs";
 import { LioranDB } from "./core/database.js";
 import { setEncryptionKey } from "./utils/encryption.js";
 import { getDefaultRootPath } from "./utils/rootpath.js";
+import { dbQueue } from "./ipc/queue.js";
 
 export interface LioranManagerOptions {
   rootPath?: string;
   encryptionKey?: string | Buffer;
+  ipc?: boolean;
 }
 
 export class LioranManager {
   rootPath: string;
   openDBs: Map<string, LioranDB>;
+  private closed = false;
+  private ipc: boolean;
 
   constructor(options: LioranManagerOptions = {}) {
-    const { rootPath, encryptionKey } = options;
+    const { rootPath, encryptionKey, ipc } = options;
 
     this.rootPath = rootPath || getDefaultRootPath();
+    this.ipc = ipc ?? process.env.LIORANDB_IPC === "1";
 
     if (!fs.existsSync(this.rootPath)) {
       fs.mkdirSync(this.rootPath, { recursive: true });
@@ -27,13 +32,26 @@ export class LioranManager {
     }
 
     this.openDBs = new Map();
+
+    if (!this.ipc) {
+      this._registerShutdownHooks();
+    }
   }
 
+  /* -------------------------------- CORE -------------------------------- */
+
   async db(name: string): Promise<LioranDB> {
+    if (this.ipc) {
+      await dbQueue.exec("db", { db: name });
+      return new IPCDatabase(name) as any;
+    }
+
     return this.openDatabase(name);
   }
 
   async createDatabase(name: string): Promise<LioranDB> {
+    this._assertOpen();
+
     const dbPath = path.join(this.rootPath, name);
 
     if (fs.existsSync(dbPath)) {
@@ -41,44 +59,99 @@ export class LioranManager {
     }
 
     await fs.promises.mkdir(dbPath, { recursive: true });
-    return this.openDatabase(name);
+    return this.db(name);
   }
 
   async openDatabase(name: string): Promise<LioranDB> {
+    this._assertOpen();
+
+    if (this.openDBs.has(name)) {
+      return this.openDBs.get(name)!;
+    }
+
     const dbPath = path.join(this.rootPath, name);
 
     if (!fs.existsSync(dbPath)) {
       await fs.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;
   }
 
+  /* -------------------------------- LIFECYCLE -------------------------------- */
+
   async closeDatabase(name: string): Promise<void> {
+    if (this.ipc) return;
+
     if (!this.openDBs.has(name)) return;
 
     const db = this.openDBs.get(name)!;
+    await db.close();
+    this.openDBs.delete(name);
+  }
 
-    for (const [, col] of db.collections.entries()) {
-      await col.close();
+  /**
+   * Gracefully shuts down everything.
+   * - Closes all databases
+   * - Terminates IPC worker if running
+   */
+  async closeAll(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+
+    if (this.ipc) {
+      await dbQueue.shutdown();
+      return;
     }
 
-    this.openDBs.delete(name);
+    for (const db of this.openDBs.values()) {
+      try {
+        await db.close();
+      } catch {}
+    }
+
+    this.openDBs.clear();
+  }
+
+  /**
+   * Alias for closeAll() (clean public API)
+   */
+  async close(): Promise<void> {
+    return this.closeAll();
+  }
+
+  private _registerShutdownHooks() {
+    const shutdown = async () => {
+      await this.closeAll();
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("exit", shutdown);
   }
 
+  private _assertOpen() {
+    if (this.closed) {
+      throw new Error("LioranManager is closed");
+    }
+  }
+
+  /* -------------------------------- MANAGEMENT -------------------------------- */
+
   async renameDatabase(oldName: string, newName: string): Promise<boolean> {
+    if (this.ipc) {
+      return (await dbQueue.exec("renameDatabase", { oldName, newName })) as boolean;
+    }
+
     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`);
     }
@@ -93,6 +166,10 @@ export class LioranManager {
   }
 
   async dropDatabase(name: string): Promise<boolean> {
+    if (this.ipc) {
+      return (await dbQueue.exec("dropDatabase", { name })) as boolean;
+    }
+
     const dbPath = path.join(this.rootPath, name);
 
     if (!fs.existsSync(dbPath)) return false;
@@ -103,10 +180,64 @@ export class LioranManager {
   }
 
   async listDatabases(): Promise<string[]> {
+    if (this.ipc) {
+      return (await dbQueue.exec("listDatabases", {})) as string[];
+    }
+
     const items = await fs.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,
+      closed: this.closed
+    };
+  }
+}
+
+/* -------------------------------- IPC PROXY DB -------------------------------- */
+
+class IPCDatabase {
+  constructor(private name: string) {}
+
+  collection(name: string) {
+    return new IPCCollection(this.name, name);
+  }
+}
+
+class IPCCollection {
+  constructor(
+    private db: string,
+    private col: string
+  ) {}
+
+  private call(method: string, params: any[]) {
+    return dbQueue.exec("op", {
+      db: this.db,
+      col: this.col,
+      method,
+      params
+    });
+  }
+
+  insertOne = (doc: any) => this.call("insertOne", [doc]);
+  insertMany = (docs: any[]) => this.call("insertMany", [docs]);
+  find = (query?: any) => this.call("find", [query]);
+  findOne = (query?: any) => this.call("findOne", [query]);
+  updateOne = (filter: any, update: any, options?: any) =>
+    this.call("updateOne", [filter, update, options]);
+  updateMany = (filter: any, update: any) =>
+    this.call("updateMany", [filter, update]);
+  deleteOne = (filter: any) => this.call("deleteOne", [filter]);
+  deleteMany = (filter: any) => this.call("deleteMany", [filter]);
+  countDocuments = (filter?: any) =>
+    this.call("countDocuments", [filter]);
 }

package/src/core/collection.ts

@@ -1,7 +1,11 @@
+import fs from "fs";
+import path from "path";
 import { ClassicLevel } from "classic-level";
 import { matchDocument, applyUpdate } from "./query.js";
 import { v4 as uuid } from "uuid";
 import { encryptData, decryptData } from "../utils/encryption.js";
+import type { ZodSchema } from "zod";
+import { validateSchema } from "../utils/schema.js";
 
 export interface UpdateOptions {
   upsert?: boolean;
@@ -11,153 +15,315 @@ export class Collection<T = any> {
   dir: string;
   db: ClassicLevel<string, string>;
   private queue: Promise<any>;
+  private walPath: string;
+  private schema?: ZodSchema<T>;
 
-  constructor(dir: string) {
+  constructor(dir: string, schema?: ZodSchema<T>) {
     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: ZodSchema<T>) {
+    this.schema = schema;
+  }
+
+  private validate(doc: any): T {
+    return this.schema ? validateSchema(this.schema, doc) : doc;
+  }
+
+  /* ---------------- WAL ---------------- */
+
+  private async writeWAL(entry: any) {
+    await fs.promises.appendFile(
+      this.walPath,
+      JSON.stringify(entry) + "\n"
+    );
+  }
+
+  private async clearWAL() {
+    if (fs.existsSync(this.walPath)) {
+      await fs.promises.unlink(this.walPath);
+    }
   }
 
+  private 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 ---------------- */
+
   private _enqueue<R>(task: () => Promise<R>): Promise<R> {
     this.queue = this.queue.then(task).catch(console.error);
     return this.queue;
   }
 
+  /* ---------------- Core Executor ---------------- */
+
+  private async _exec(op: string, args: any[], log = true) {
+    if (log) await this.writeWAL({ op, args });
+
+    let result: any;
+
+    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(): 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);
-      }
+  insertOne(doc: T & { _id?: string }): Promise<T> {
+    return this._enqueue(() => this._exec("insertOne", [doc]));
+  }
 
-      await this.db.batch(ops);
-      return out;
-    });
+  insertMany(docs: (T & { _id?: string })[] = []): Promise<T[]> {
+    return this._enqueue(() => this._exec("insertMany", [docs]));
   }
 
-  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;
-    });
+  find(query: any = {}): Promise<T[]> {
+    return this._enqueue(() => this._exec("find", [query]));
   }
 
-  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;
-    });
+  findOne(query: any = {}): Promise<T | null> {
+    return this._enqueue(() => this._exec("findOne", [query]));
   }
 
-  async updateOne(
+  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;
-        }
-      }
+    return this._enqueue(() =>
+      this._exec("updateOne", [filter, update, options])
+    );
+  }
 
-      if (options.upsert) {
-        const doc = applyUpdate(filter, update);
-        doc._id ??= uuid();
-        await this.db.put(String(doc._id), encryptData(doc));
-        return doc;
-      }
+  updateMany(filter: any = {}, update: any = {}): Promise<T[]> {
+    return this._enqueue(() =>
+      this._exec("updateMany", [filter, update])
+    );
+  }
+
+  deleteOne(filter: any = {}): Promise<boolean> {
+    return this._enqueue(() => this._exec("deleteOne", [filter]));
+  }
+
+  deleteMany(filter: any = {}): Promise<number> {
+    return this._enqueue(() => this._exec("deleteMany", [filter]));
+  }
 
-      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);
-        }
+  countDocuments(filter: any = {}): Promise<number> {
+    return this._enqueue(() =>
+      this._exec("countDocuments", [filter])
+    );
+  }
+
+  /* ---------------- Internal Ops ---------------- */
+
+  private async _insertOne(doc: T & { _id?: string }): Promise<T> {
+    const _id = doc._id ?? uuid();
+    const final = this.validate({ _id, ...doc });
+
+    await this.db.put(String(_id), encryptData(final));
+    return final;
+  }
+
+  private async _insertMany(
+    docs: (T & { _id?: string })[]
+  ): Promise<T[]> {
+    const ops: Array<{ type: "put"; key: string; value: string }> = [];
+    const out: T[] = [];
+
+    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;
+  }
+
+  private async _updateOne(
+    filter: any,
+    update: any,
+    options: UpdateOptions
+  ): Promise<T | null> {
+    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;
       }
-      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;
-        }
+    }
+
+    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;
+  }
+
+  private async _updateMany(filter: any, update: any): Promise<T[]> {
+    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;
+
+        const validated = this.validate(doc);
+        await this.db.put(key, encryptData(validated));
+
+        updated.push(validated);
       }
-      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 updated;
+  }
+
+  private async _find(query: any): Promise<T[]> {
+    const out: T[] = [];
+
+    for await (const [, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, query)) out.push(value);
+    }
+
+    return out;
+  }
+
+  private async _findOne(query: any): Promise<T | null> {
+    for await (const [, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, query)) return value;
+    }
+
+    return null;
+  }
+
+  private async _deleteOne(filter: any): Promise<boolean> {
+    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 count;
-    });
+    }
+
+    return false;
   }
 
-  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++;
+  private async _deleteMany(filter: any): Promise<number> {
+    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 c;
-    });
+    }
+
+    return count;
+  }
+
+  private async _countDocuments(filter: any): Promise<number> {
+    let c = 0;
+
+    for await (const [, enc] of this.db.iterator()) {
+      const value = decryptData(enc);
+      if (matchDocument(value, filter)) c++;
+    }
+
+    return c;
   }
 }