@liorandb/core 1.0.8 → 1.0.10

package/src/core/database.ts

@@ -2,6 +2,7 @@ import path from "path";
 import fs from "fs";
 import { Collection } from "./collection.js";
 import type { LioranManager } from "../LioranManager.js";
+import type { ZodSchema } from "zod";
 
 export class LioranDB {
   basePath: string;
@@ -20,9 +21,13 @@ export class LioranDB {
     }
   }
 
-  collection<T = any>(name: string): Collection<T> {
+  /* -------------------------------- COLLECTION -------------------------------- */
+
+  collection<T = any>(name: string, schema?: ZodSchema<T>): Collection<T> {
     if (this.collections.has(name)) {
-      return this.collections.get(name)!;
+      const col = this.collections.get(name)!;
+      if (schema) col.setSchema(schema);
+      return col as Collection<T>;
     }
 
     const colPath = path.join(this.basePath, name);
@@ -31,12 +36,16 @@ export class LioranDB {
       fs.mkdirSync(colPath, { recursive: true });
     }
 
-    const col = new Collection<T>(colPath);
+    const col = new Collection<T>(colPath, schema);
     this.collections.set(name, col);
+
     return col;
   }
 
-  async createCollection(name: string): Promise<boolean> {
+  async createCollection<T = any>(
+    name: string,
+    schema?: ZodSchema<T>
+  ): Promise<Collection<T>> {
     const colPath = path.join(this.basePath, name);
 
     if (fs.existsSync(colPath)) {
@@ -44,8 +53,11 @@ export class LioranDB {
     }
 
     await fs.promises.mkdir(colPath, { recursive: true });
-    this.collections.set(name, new Collection(colPath));
-    return true;
+
+    const col = new Collection<T>(colPath, schema);
+    this.collections.set(name, col);
+
+    return col;
   }
 
   async deleteCollection(name: string): Promise<boolean> {
@@ -68,8 +80,13 @@ export class LioranDB {
     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 (!fs.existsSync(oldPath)) {
+      throw new Error("Collection does not exist");
+    }
+
+    if (fs.existsSync(newPath)) {
+      throw new Error("New collection name already exists");
+    }
 
     if (this.collections.has(oldName)) {
       await this.collections.get(oldName)!.close();
@@ -77,7 +94,10 @@ export class LioranDB {
     }
 
     await fs.promises.rename(oldPath, newPath);
-    this.collections.set(newName, new Collection(newPath));
+
+    const col = new Collection(newPath);
+    this.collections.set(newName, col);
+
     return true;
   }
 
@@ -92,4 +112,25 @@ export class LioranDB {
 
     return dirs.filter(d => d.isDirectory()).map(d => d.name);
   }
+
+  /* -------------------------------- LIFECYCLE -------------------------------- */
+
+  async close(): Promise<void> {
+    for (const col of this.collections.values()) {
+      try {
+        await col.close();
+      } catch {}
+    }
+    this.collections.clear();
+  }
+
+  /* -------------------------------- DEBUG -------------------------------- */
+
+  getStats() {
+    return {
+      dbName: this.dbName,
+      basePath: this.basePath,
+      collections: [...this.collections.keys()]
+    };
+  }
 }

package/src/ipc/index.ts

@@ -0,0 +1,56 @@
+import { dbQueue } from "./queue.js";
+
+type AnyFn = (...args: any[]) => Promise<any>;
+
+/* -------------------------------- COLLECTION PROXY -------------------------------- */
+
+class CollectionProxy {
+  constructor(
+    private dbName: string,
+    private collectionName: string
+  ) {}
+
+  private call(method: string, params: any[]): Promise<any> {
+    return dbQueue.exec("op", {
+      db: this.dbName,
+      col: this.collectionName,
+      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]);
+}
+
+/* -------------------------------- DATABASE PROXY -------------------------------- */
+
+class DBProxy {
+  constructor(private dbName: string) {}
+
+  collection(name: string) {
+    return new CollectionProxy(this.dbName, name);
+  }
+}
+
+/* -------------------------------- MANAGER PROXY -------------------------------- */
+
+class LioranManagerIPC {
+  async db(name: string) {
+    await dbQueue.exec("db", { db: name });
+    return new DBProxy(name);
+  }
+}
+
+export const manager = new LioranManagerIPC();
+export type { CollectionProxy, DBProxy };

package/src/ipc/queue.ts

@@ -0,0 +1,78 @@
+import { fork, ChildProcess } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function resolveWorkerPath() {
+  // dist/ipc/queue.js → dist/worker/dbWorker.js
+  return path.resolve(__dirname, "../dist/worker/dbWorker.js");
+}
+
+export class DBQueue {
+  private worker: ChildProcess;
+  private seq = 0;
+  private pending = new Map<number, (r: any) => void>();
+  private isShutdown = false;
+
+  constructor() {
+    const workerPath = resolveWorkerPath();
+
+    this.worker = fork(workerPath, [], {
+      stdio: ["inherit", "inherit", "inherit", "ipc"],
+    });
+
+    this.worker.on("message", (msg: any) => {
+      const cb = this.pending.get(msg.id);
+      if (cb) {
+        this.pending.delete(msg.id);
+        cb(msg);
+      }
+    });
+
+    this.worker.on("exit", () => {
+      this.isShutdown = true;
+    });
+
+    // Auto cleanup
+    process.on("exit", () => this.shutdown());
+    process.on("SIGINT", () => this.shutdown());
+    process.on("SIGTERM", () => this.shutdown());
+  }
+
+  exec(action: string, args: any) {
+    if (this.isShutdown) {
+      return Promise.reject(new Error("DBQueue is shutdown"));
+    }
+
+    return new Promise((resolve, reject) => {
+      const id = ++this.seq;
+
+      this.pending.set(id, (msg) => {
+        if (msg.ok) resolve(msg.result);
+        else reject(new Error(msg.error));
+      });
+
+      this.worker.send({ id, action, args });
+    });
+  }
+
+  async shutdown() {
+    if (this.isShutdown) return;
+
+    this.isShutdown = true;
+
+    try {
+      this.worker.send({ action: "shutdown" });
+    } catch {}
+
+    setTimeout(() => {
+      try {
+        this.worker.kill("SIGTERM");
+      } catch {}
+    }, 200);
+  }
+}
+
+export const dbQueue = new DBQueue();

package/src/types/index.ts

@@ -1,6 +1,7 @@
 export interface LioranManagerOptions {
   rootPath?: string
-  encryptionKey?: string | Buffer
+  encryptionKey?: string | Buffer,
+  ipc?: boolean
 }
 
 export interface UpdateOptions {

package/src/utils/schema.ts

@@ -0,0 +1,14 @@
+import { ZodSchema } from "zod";
+
+export function validateSchema<T>(schema: ZodSchema<T>, data: any): T {
+  const result = schema.safeParse(data);
+
+  if (!result.success) {
+    throw new Error(
+      "Schema validation failed:\n" +
+      JSON.stringify(result.error.format(), null, 2)
+    );
+  }
+
+  return result.data;
+}

package/src/worker/dbWorker.ts

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