@liorandb/core 1.0.11 → 1.0.13

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,19 +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>;
-  private walCounter = 0;
 
   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>) {
@@ -37,349 +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 maybeCheckpoint() {
-    if (++this.walCounter >= 100) {
-      this.walCounter = 0;
-      await this.clearWAL();
-    }
-  }
-
-  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.maybeCheckpoint();
-    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;
   }
 
-  /* ---------- FAST PATH (_id INDEX) ---------- */
-
-  private async _findOne(query: any): Promise<T | null> {
+  private async _findOne(query: any) {
     if (query?._id) {
       try {
         const enc = await this.db.get(String(query._id));
-        if (!enc) return null;
-        return decryptData(enc);
-      } catch {
-        return null;
-      }
+        return enc ? decryptData(enc) : null;
+      } catch { return null; }
     }
 
     for await (const [, enc] of this.db.iterator()) {
-      if (!enc) continue;
-      const value = decryptData(enc);
-      if (matchDocument(value, query)) return value;
+      const v = decryptData(enc);
+      if (matchDocument(v, query)) return v;
     }
 
     return null;
   }
 
-  private async _updateOne(
-    filter: any,
-    update: any,
-    options: UpdateOptions
-  ): Promise<T | null> {
-    if (filter?._id) {
-      try {
-        const enc = await this.db.get(String(filter._id));
-        if (!enc) throw new Error("Not found");
-        const value = decryptData(enc);
-
-        const updated = applyUpdate(value, update);
-        updated._id = value._id;
-
-        const validated = this.validate(updated);
-        await this.db.put(String(updated._id), encryptData(validated));
-
-        return validated;
-      } catch {
-        if (!options?.upsert) return null;
-      }
-    }
-
+  private async _updateOne(filter: any, update: any, options: UpdateOptions) {
     for await (const [key, enc] of this.db.iterator()) {
-      if (!enc) continue;
       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 _deleteOne(filter: any): Promise<boolean> {
-    if (filter?._id) {
-      try {
-        await this.db.del(String(filter._id));
-        return true;
-      } catch {
-        return false;
-      }
-    }
+  private async _updateMany(filter: any, update: any) {
+    const out = [];
 
     for await (const [key, enc] of this.db.iterator()) {
-      if (!enc) continue;
       const value = decryptData(enc);
-
       if (matchDocument(value, filter)) {
-        await this.db.del(key);
-        return true;
+        const updated = this.validate(applyUpdate(value, update)) as any;
+        updated._id = value._id;
+        await this.db.put(key, encryptData(updated));
+        out.push(updated);
       }
     }
 
-    return false;
+    return out;
   }
 
-  /* ---------- NORMAL OPS ---------- */
-
-  private async _updateMany(filter: any, update: any): Promise<T[]> {
-    const updated: T[] = [];
-
-    for await (const [key, enc] of this.db.iterator()) {
-      if (!enc) continue;
-      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);
-      }
+  private async _find(query: any) {
+    const out = [];
+    for await (const [, enc] of this.db.iterator()) {
+      const v = decryptData(enc);
+      if (matchDocument(v, query)) out.push(v);
     }
-
-    return updated;
+    return out;
   }
 
-  private async _find(query: any): Promise<T[]> {
-    const out: T[] = [];
-
-    for await (const [, enc] of this.db.iterator()) {
-      if (!enc) continue;
-      const value = decryptData(enc);
-      if (matchDocument(value, query)) out.push(value);
+  private async _deleteOne(filter: any) {
+    for await (const [key, enc] of this.db.iterator()) {
+      if (matchDocument(decryptData(enc), filter)) {
+        await this.db.del(key);
+        return true;
+      }
     }
-
-    return out;
+    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()) {
-      if (!enc) continue;
-      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()) {
-      if (!enc) continue;
-      const value = decryptData(enc);
-      if (matchDocument(value, filter)) c++;
+      if (matchDocument(decryptData(enc), filter)) c++;
     }
-
     return c;
   }
 }

package/src/core/database.ts

@@ -4,133 +4,150 @@ import { Collection } from "./collection.js";
 import type { LioranManager } from "../LioranManager.js";
 import type { ZodSchema } from "zod";
 
+type TXOp = { tx: number; col: string; op: string; args: any[] };
+type TXCommit = { tx: number; commit: true };
+type TXApplied = { tx: number; applied: true };
+type WALEntry = TXOp | TXCommit | TXApplied;
+
+class DBTransactionContext {
+  private ops: TXOp[] = [];
+
+  constructor(
+    private db: LioranDB,
+    public readonly txId: number
+  ) {}
+
+  collection(name: string) {
+    return new Proxy({}, {
+      get: (_, prop: string) => {
+        return (...args: any[]) => {
+          this.ops.push({
+            tx: this.txId,
+            col: name,
+            op: prop,
+            args
+          });
+        };
+      }
+    });
+  }
+
+  async commit() {
+    await this.db.writeWAL(this.ops);
+    await this.db.writeWAL([{ tx: this.txId, commit: true }]);
+    await this.db.applyTransaction(this.ops);
+    await this.db.writeWAL([{ tx: this.txId, applied: true }]);
+    await this.db.clearWAL();
+  }
+}
+
 export class LioranDB {
   basePath: string;
   dbName: string;
   manager: LioranManager;
   collections: Map<string, Collection>;
+  private walPath: string;
+
+  private static TX_SEQ = 0;
 
   constructor(basePath: string, dbName: string, manager: LioranManager) {
     this.basePath = basePath;
     this.dbName = dbName;
     this.manager = manager;
     this.collections = new Map();
+    this.walPath = path.join(basePath, "__tx_wal.log");
 
-    if (!fs.existsSync(basePath)) {
-      fs.mkdirSync(basePath, { recursive: true });
-    }
-  }
-
-  /* -------------------------------- COLLECTION -------------------------------- */
+    fs.mkdirSync(basePath, { recursive: true });
 
-  collection<T = any>(name: string, schema?: ZodSchema<T>): Collection<T> {
-    if (this.collections.has(name)) {
-      const col = this.collections.get(name)!;
-      if (schema) col.setSchema(schema);
-      return col as Collection<T>;
-    }
-
-    const colPath = path.join(this.basePath, name);
+    this.recoverFromWAL().catch(console.error);
+  }
 
-    if (!fs.existsSync(colPath)) {
-      fs.mkdirSync(colPath, { recursive: true });
+  async writeWAL(entries: WALEntry[]) {
+    const fd = await fs.promises.open(this.walPath, "a");
+    for (const e of entries) {
+      await fd.write(JSON.stringify(e) + "\n");
     }
-
-    const col = new Collection<T>(colPath, schema);
-    this.collections.set(name, col);
-
-    return col;
+    await fd.sync();
+    await fd.close();
   }
 
-  async createCollection<T = any>(
-    name: string,
-    schema?: ZodSchema<T>
-  ): Promise<Collection<T>> {
-    const colPath = path.join(this.basePath, name);
-
-    if (fs.existsSync(colPath)) {
-      throw new Error("Collection already exists");
-    }
+  async clearWAL() {
+    try { await fs.promises.unlink(this.walPath); } catch {}
+  }
 
-    await fs.promises.mkdir(colPath, { recursive: true });
+  private async recoverFromWAL() {
+    if (!fs.existsSync(this.walPath)) return;
 
-    const col = new Collection<T>(colPath, schema);
-    this.collections.set(name, col);
+    const raw = await fs.promises.readFile(this.walPath, "utf8");
 
-    return col;
-  }
+    const committed = new Set<number>();
+    const applied = new Set<number>();
+    const ops = new Map<number, TXOp[]>();
 
-  async deleteCollection(name: string): Promise<boolean> {
-    const colPath = path.join(this.basePath, name);
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
 
-    if (!fs.existsSync(colPath)) {
-      throw new Error("Collection does not exist");
+      try {
+        const entry: WALEntry = JSON.parse(line);
+
+        if ("commit" in entry) committed.add(entry.tx);
+        else if ("applied" in entry) applied.add(entry.tx);
+        else {
+          if (!ops.has(entry.tx)) ops.set(entry.tx, []);
+          ops.get(entry.tx)!.push(entry);
+        }
+      } catch {
+        // Ignore corrupted WAL tail
+        break;
+      }
     }
 
-    if (this.collections.has(name)) {
-      await this.collections.get(name)!.close();
-      this.collections.delete(name);
+    for (const tx of committed) {
+      if (applied.has(tx)) continue;
+
+      const txOps = ops.get(tx);
+      if (txOps) await this.applyTransaction(txOps);
     }
 
-    await fs.promises.rm(colPath, { recursive: true, force: true });
-    return true;
+    await this.clearWAL();
   }
 
-  async renameCollection(oldName: string, newName: string): Promise<boolean> {
-    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 already exists");
+  async applyTransaction(ops: TXOp[]) {
+    for (const { col, op, args } of ops) {
+      const collection = this.collection(col);
+      await (collection as any)._exec(op, args);
     }
+  }
 
-    if (this.collections.has(oldName)) {
-      await this.collections.get(oldName)!.close();
-      this.collections.delete(oldName);
+  collection<T = any>(name: string, schema?: ZodSchema<T>): Collection<T> {
+    if (this.collections.has(name)) {
+      const col = this.collections.get(name)!;
+      if (schema) col.setSchema(schema);
+      return col as Collection<T>;
     }
 
-    await fs.promises.rename(oldPath, newPath);
-
-    const col = new Collection(newPath);
-    this.collections.set(newName, col);
+    const colPath = path.join(this.basePath, name);
+    fs.mkdirSync(colPath, { recursive: true });
 
-    return true;
+    const col = new Collection<T>(colPath, schema);
+    this.collections.set(name, col);
+    return col;
   }
 
-  async dropCollection(name: string): Promise<boolean> {
-    return this.deleteCollection(name);
-  }
+  async transaction<T>(fn: (tx: DBTransactionContext) => Promise<T>): Promise<T> {
+    const txId = ++LioranDB.TX_SEQ;
+    const tx = new DBTransactionContext(this, txId);
 
-  async listCollections(): Promise<string[]> {
-    const dirs = await fs.promises.readdir(this.basePath, {
-      withFileTypes: true
-    });
+    const result = await fn(tx);
+    await tx.commit();
 
-    return dirs.filter(d => d.isDirectory()).map(d => d.name);
+    return result;
   }
 
-  /* -------------------------------- LIFECYCLE -------------------------------- */
-
   async close(): Promise<void> {
     for (const col of this.collections.values()) {
-      try {
-        await col.close();
-      } catch {}
+      try { await col.close(); } catch {}
     }
     this.collections.clear();
   }
-
-  /* -------------------------------- DEBUG -------------------------------- */
-
-  getStats() {
-    return {
-      dbName: this.dbName,
-      basePath: this.basePath,
-      collections: [...this.collections.keys()]
-    };
-  }
-}
+}