@liorandb/core 1.0.10 → 1.0.12

package/dist/index.d.ts

@@ -8,59 +8,71 @@ declare class Collection<T = any> {
     dir: string;
     db: ClassicLevel<string, string>;
     private queue;
-    private walPath;
     private schema?;
     constructor(dir: string, schema?: ZodSchema<T>);
     setSchema(schema: ZodSchema<T>): void;
     private validate;
-    private writeWAL;
-    private clearWAL;
-    private recoverFromWAL;
     private _enqueue;
-    private _exec;
     close(): Promise<void>;
+    _exec(op: string, args: any[]): Promise<any>;
     insertOne(doc: T & {
         _id?: string;
-    }): Promise<T>;
+    }): Promise<any>;
     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>;
+    })[]): Promise<any>;
+    find(query?: any): Promise<any>;
+    findOne(query?: any): Promise<any>;
+    updateOne(filter: any, update: any, options?: UpdateOptions$1): Promise<any>;
+    updateMany(filter: any, update: any): Promise<any>;
+    deleteOne(filter: any): Promise<any>;
+    deleteMany(filter: any): Promise<any>;
+    countDocuments(filter?: any): Promise<any>;
     private _insertOne;
     private _insertMany;
+    private _findOne;
     private _updateOne;
     private _updateMany;
     private _find;
-    private _findOne;
     private _deleteOne;
     private _deleteMany;
     private _countDocuments;
 }
 
+type TXOp = {
+    tx: number;
+    col: string;
+    op: string;
+    args: any[];
+};
+type TXCommit = {
+    tx: number;
+    commit: true;
+};
+type WALEntry = TXOp | TXCommit;
+declare class DBTransactionContext {
+    private db;
+    readonly txId: number;
+    private ops;
+    constructor(db: LioranDB, txId: number);
+    collection(name: string): {};
+    commit(): Promise<void>;
+}
 declare class LioranDB {
     basePath: string;
     dbName: string;
     manager: LioranManager;
     collections: Map<string, Collection>;
+    private walPath;
+    private static TX_SEQ;
     constructor(basePath: string, dbName: string, manager: LioranManager);
+    writeWAL(entries: WALEntry[]): Promise<void>;
+    clearWAL(): Promise<void>;
+    private recoverFromWAL;
+    applyTransaction(ops: TXOp[]): Promise<void>;
     collection<T = any>(name: string, schema?: ZodSchema<T>): Collection<T>;
-    createCollection<T = any>(name: string, schema?: ZodSchema<T>): Promise<Collection<T>>;
-    deleteCollection(name: string): Promise<boolean>;
-    renameCollection(oldName: string, newName: string): Promise<boolean>;
-    dropCollection(name: string): Promise<boolean>;
-    listCollections(): Promise<string[]>;
+    transaction<T>(fn: (tx: DBTransactionContext) => Promise<T>): Promise<T>;
     close(): Promise<void>;
-    getStats(): {
-        dbName: string;
-        basePath: string;
-        collections: string[];
-    };
 }
 
 interface LioranManagerOptions$1 {

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   LioranDB,
   LioranManager,
   getBaseDBFolder
-} from "./chunk-J7OD7MXK.js";
+} from "./chunk-ST6KMJQJ.js";
 export {
   LioranDB,
   LioranManager,

package/dist/worker/dbWorker.js

@@ -1,37 +1,35 @@
 import {
   LioranManager
-} from "../chunk-J7OD7MXK.js";
+} from "../chunk-ST6KMJQJ.js";
 
 // src/worker/dbWorker.ts
-var manager = new LioranManager();
+var manager = new LioranManager({ ipc: false });
 process.on("message", async (msg) => {
   const { id, action, args } = msg;
   try {
     let result;
     switch (action) {
-      case "shutdown": {
+      case "shutdown":
         await manager.closeAll();
         result = true;
         break;
-      }
-      case "db": {
-        const db = await manager.db(args.db);
+      case "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[method](...params);
         break;
       }
+      case "tx": {
+        const db = await manager.db(args.db);
+        result = await db.transaction(args.fn);
+        break;
+      }
       default:
-        throw new Error("Unknown action");
+        throw new Error("Unknown IPC action");
     }
     process.send?.({ id, ok: true, result });
   } catch (err) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@liorandb/core",
-  "version": "1.0.10",
-  "description": "**LioranDB Core Module** – Lightweight, local-first, peer-to-peer database management for Node.js.",
+  "version": "1.0.12",
+  "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": {

package/src/core/collection.ts

@@ -1,5 +1,3 @@
-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";
@@ -14,18 +12,13 @@ export interface UpdateOptions {
 export class Collection<T = any> {
   dir: string;
   db: ClassicLevel<string, string>;
-  private queue: Promise<any>;
-  private walPath: string;
+  private queue: Promise<any> = Promise.resolve();
   private schema?: ZodSchema<T>;
 
   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.db = new ClassicLevel(dir, { valueEncoding: "utf8" });
     this.schema = schema;
-
-    this.recoverFromWAL().catch(console.error);
   }
 
   setSchema(schema: ZodSchema<T>) {
@@ -36,294 +29,187 @@ export class Collection<T = any> {
     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;
+  async close(): Promise<void> {
+    try { await this.db.close(); } catch {}
+  }
 
+  async _exec(op: string, args: 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}`);
+      case "insertOne": return this._insertOne(args[0]);
+      case "insertMany": return this._insertMany(args[0]);
+      case "find": return this._find(args[0]);
+      case "findOne": return this._findOne(args[0]);
+      case "updateOne": return this._updateOne(args[0], args[1], args[2]);
+      case "updateMany": return this._updateMany(args[0], args[1]);
+      case "deleteOne": return this._deleteOne(args[0]);
+      case "deleteMany": return this._deleteMany(args[0]);
+      case "countDocuments": return this._countDocuments(args[0]);
+      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 {}
-  }
-
-  insertOne(doc: T & { _id?: string }): Promise<T> {
+  insertOne(doc: T & { _id?: string }) {
     return this._enqueue(() => this._exec("insertOne", [doc]));
   }
 
-  insertMany(docs: (T & { _id?: string })[] = []): Promise<T[]> {
+  insertMany(docs: (T & { _id?: string })[] = []) {
     return this._enqueue(() => this._exec("insertMany", [docs]));
   }
 
-  find(query: any = {}): Promise<T[]> {
+  find(query: any = {}) {
     return this._enqueue(() => this._exec("find", [query]));
   }
 
-  findOne(query: any = {}): Promise<T | null> {
+  findOne(query: any = {}) {
     return this._enqueue(() => this._exec("findOne", [query]));
   }
 
-  updateOne(
-    filter: any = {},
-    update: any = {},
-    options: UpdateOptions = { upsert: false }
-  ): Promise<T | null> {
+  updateOne(filter: any, update: any, options: UpdateOptions = {}) {
     return this._enqueue(() =>
       this._exec("updateOne", [filter, update, options])
     );
   }
 
-  updateMany(filter: any = {}, update: any = {}): Promise<T[]> {
+  updateMany(filter: any, update: any) {
     return this._enqueue(() =>
       this._exec("updateMany", [filter, update])
     );
   }
 
-  deleteOne(filter: any = {}): Promise<boolean> {
-    return this._enqueue(() => this._exec("deleteOne", [filter]));
+  deleteOne(filter: any) {
+    return this._enqueue(() =>
+      this._exec("deleteOne", [filter])
+    );
   }
 
-  deleteMany(filter: any = {}): Promise<number> {
-    return this._enqueue(() => this._exec("deleteMany", [filter]));
+  deleteMany(filter: any) {
+    return this._enqueue(() =>
+      this._exec("deleteMany", [filter])
+    );
   }
 
-  countDocuments(filter: any = {}): Promise<number> {
+  countDocuments(filter: any = {}) {
     return this._enqueue(() =>
       this._exec("countDocuments", [filter])
     );
   }
 
-  /* ---------------- Internal Ops ---------------- */
+  /* ---------------- Storage ---------------- */
 
-  private async _insertOne(doc: T & { _id?: string }): Promise<T> {
+  private async _insertOne(doc: any) {
     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[] = [];
+  private async _insertMany(docs: any[]) {
+    const batch: Array<{ type: "put"; key: string; value: string }> = [];
+    const out = [];
 
     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)
-      });
-
+      batch.push({ type: "put", key: String(_id), value: encryptData(final) });
       out.push(final);
     }
 
-    await this.db.batch(ops);
+    await this.db.batch(batch);
     return out;
   }
 
-  private async _updateOne(
-    filter: any,
-    update: any,
-    options: UpdateOptions
-  ): Promise<T | null> {
+  private async _findOne(query: any) {
+    if (query?._id) {
+      try {
+        const enc = await this.db.get(String(query._id));
+        return enc ? decryptData(enc) : null;
+      } catch { return null; }
+    }
+
+    for await (const [, enc] of this.db.iterator()) {
+      const v = decryptData(enc);
+      if (matchDocument(v, query)) return v;
+    }
+
+    return null;
+  }
+
+  private async _updateOne(filter: any, update: any, options: UpdateOptions) {
     for await (const [key, enc] of this.db.iterator()) {
       const value = decryptData(enc);
-
       if (matchDocument(value, filter)) {
-        const updated = applyUpdate(value, update);
+        const updated = this.validate(applyUpdate(value, update)) as any;
         updated._id = value._id;
-
-        const validated = this.validate(updated);
-        await this.db.put(key, encryptData(validated));
-
-        return validated;
+        await this.db.put(key, encryptData(updated));
+        return updated;
       }
     }
 
     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;
+      const doc = this.validate({ _id: uuid(), ...applyUpdate({}, update) }) as any;
+      await this.db.put(String(doc._id), encryptData(doc));
+      return doc;
     }
 
     return null;
   }
 
-  private async _updateMany(filter: any, update: any): Promise<T[]> {
-    const updated: T[] = [];
+  private async _updateMany(filter: any, update: any) {
+    const out = [];
 
     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);
+        const updated = this.validate(applyUpdate(value, update)) as any;
+        updated._id = value._id;
+        await this.db.put(key, encryptData(updated));
+        out.push(updated);
       }
     }
 
-    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> {
+  private async _find(query: any) {
+    const out = [];
     for await (const [, enc] of this.db.iterator()) {
-      const value = decryptData(enc);
-      if (matchDocument(value, query)) return value;
+      const v = decryptData(enc);
+      if (matchDocument(v, query)) out.push(v);
     }
-
-    return null;
+    return out;
   }
 
-  private async _deleteOne(filter: any): Promise<boolean> {
+  private async _deleteOne(filter: any) {
     for await (const [key, enc] of this.db.iterator()) {
-      const value = decryptData(enc);
-
-      if (matchDocument(value, filter)) {
+      if (matchDocument(decryptData(enc), filter)) {
         await this.db.del(key);
         return true;
       }
     }
-
     return false;
   }
 
-  private async _deleteMany(filter: any): Promise<number> {
+  private async _deleteMany(filter: any) {
     let count = 0;
-
     for await (const [key, enc] of this.db.iterator()) {
-      const value = decryptData(enc);
-
-      if (matchDocument(value, filter)) {
+      if (matchDocument(decryptData(enc), filter)) {
         await this.db.del(key);
         count++;
       }
     }
-
     return count;
   }
 
-  private async _countDocuments(filter: any): Promise<number> {
+  private async _countDocuments(filter: any) {
     let c = 0;
-
     for await (const [, enc] of this.db.iterator()) {
-      const value = decryptData(enc);
-      if (matchDocument(value, filter)) c++;
+      if (matchDocument(decryptData(enc), filter)) c++;
     }
-
     return c;
   }
-}
+}