dataply 0.0.26-alpha.6 → 0.0.26-alpha.7

package/dist/cjs/index.js

@@ -5026,32 +5026,73 @@ var BPTreePureSync = class {
       createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        strategy.write(id, node);
+        return node;
+      },
+      updateNode() {
+      },
+      deleteNode() {
+      },
+      readHead() {
+        return strategy.readHead();
+      },
+      writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return strategy.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       updateNode(node) {
-        strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       deleteNode(node) {
-        strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       readHead() {
+        if (headBuffer) return headBuffer;
         return strategy.readHead();
       },
       writeHead(head) {
-        strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    function flush() {
+      for (const id of deleteBuffer) {
+        strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        strategy.write(id, node);
+      }
+      if (headBuffer) {
+        strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
   }
   init() {
-    this._ops = this._createOps();
+    const { ops, flush } = this._createBufferedOps();
     this._ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
-      this._ops,
+      ops,
       this._ctx,
       this.strategy.order,
       this.strategy.head,
@@ -5059,6 +5100,8 @@ var BPTreePureSync = class {
         this.strategy.head = head;
       }
     );
+    flush();
+    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
@@ -5132,16 +5175,24 @@ var BPTreePureSync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
-    insertOp(this._ops, this._ctx, key, value, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    insertOp(ops, this._ctx, key, value, this.comparator);
+    flush();
   }
   delete(key, value) {
-    deleteOp(this._ops, this._ctx, key, this.comparator, value);
+    const { ops, flush } = this._createBufferedOps();
+    deleteOp(ops, this._ctx, key, this.comparator, value);
+    flush();
   }
   batchInsert(entries) {
-    batchInsertOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    flush();
   }
   bulkLoad(entries) {
-    bulkLoadOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
@@ -5152,15 +5203,17 @@ var BPTreePureSync = class {
     return head.data;
   }
   setHeadData(data) {
-    const head = this._ops.readHead();
+    const { ops, flush } = this._createBufferedOps();
+    const head = ops.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
-    this._ops.writeHead({
+    ops.writeHead({
       root: head.root,
       order: head.order,
       data
     });
+    flush();
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;
@@ -5169,6 +5222,7 @@ var BPTreePureAsync = class {
   strategy;
   comparator;
   option;
+  lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
   _ctx;
   _ops;
@@ -5194,39 +5248,93 @@ var BPTreePureAsync = class {
       async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = await strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        await strategy.write(id, node);
+        return node;
+      },
+      async updateNode() {
+      },
+      async deleteNode() {
+      },
+      async readHead() {
+        return await strategy.readHead();
+      },
+      async writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      async getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return await strategy.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       async updateNode(node) {
-        await strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       async deleteNode(node) {
-        await strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       async readHead() {
+        if (headBuffer) return headBuffer;
         return await strategy.readHead();
       },
       async writeHead(head) {
-        await strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    async function flush() {
+      for (const id of deleteBuffer) {
+        await strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        await strategy.write(id, node);
+      }
+      if (headBuffer) {
+        await strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
+  }
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
   }
   async init() {
-    this._ops = this._createOps();
-    this._ctx = {
-      rootId: "",
-      order: this.strategy.order,
-      headData: () => this.strategy.head.data
-    };
-    await initOpAsync(
-      this._ops,
-      this._ctx,
-      this.strategy.order,
-      this.strategy.head,
-      (head) => {
-        this.strategy.head = head;
-      }
-    );
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      this._ctx = {
+        rootId: "",
+        order: this.strategy.order,
+        headData: () => this.strategy.head.data
+      };
+      await initOpAsync(
+        ops,
+        this._ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
+      await flush();
+      this._ops = this._createOps();
+    });
   }
   getRootId() {
     return this._ctx.rootId;
@@ -5250,28 +5358,40 @@ var BPTreePureAsync = class {
     return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
-    yield* keysStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      yield* keysStreamOpAsync(
+        this._ops,
+        this._ctx.rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async *whereStream(condition, options) {
-    yield* whereStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      yield* whereStreamOpAsync(
+        this._ops,
+        this._ctx.rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
@@ -5289,16 +5409,32 @@ var BPTreePureAsync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   async insert(key, value) {
-    await insertOpAsync(this._ops, this._ctx, key, value, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      await flush();
+    });
   }
   async delete(key, value) {
-    await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      await flush();
+    });
   }
   async batchInsert(entries) {
-    await batchInsertOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      await flush();
+    });
   }
   async bulkLoad(entries) {
-    await bulkLoadOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      await flush();
+    });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
@@ -5307,9 +5443,13 @@ var BPTreePureAsync = class {
     return head.data;
   }
   async setHeadData(data) {
-    const head = await this._ops.readHead();
-    if (head === null) throw new Error("Head not found");
-    await this._ops.writeHead({ root: head.root, order: head.order, data });
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const head = await ops.readHead();
+      if (head === null) throw new Error("Head not found");
+      await ops.writeHead({ root: head.root, order: head.order, data });
+      await flush();
+    });
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;
@@ -9767,11 +9907,7 @@ var PageFileSystem = class {
    * @returns 페이지 버퍼
    */
   async get(pageIndex, tx) {
-    const page = await tx.readPage(pageIndex);
-    if (page === null) {
-      return new Uint8Array(this.pageSize);
-    }
-    return page;
+    return tx.__readPage(pageIndex);
   }
   /**
    * Reads the page header.
@@ -9862,7 +9998,7 @@ var PageFileSystem = class {
     const manager = this.pageFactory.getManager(page);
     manager.updateChecksum(page);
     await tx.__acquireWriteLock(pageIndex);
-    await tx.writePage(pageIndex, page);
+    await tx.__writePage(pageIndex, page);
   }
   /**
    * Appends and inserts a new page.
@@ -10882,7 +11018,7 @@ var Transaction = class {
    * @param pageId Page ID
    * @returns Page data
    */
-  async readPage(pageId) {
+  async __readPage(pageId) {
     const tx = this.ensureMvccTx();
     const data = await tx.read(pageId);
     if (data === null) {
@@ -10897,7 +11033,7 @@ var Transaction = class {
    * @param pageId Page ID
    * @param data Page data
    */
-  async writePage(pageId, data) {
+  async __writePage(pageId, data) {
     const tx = this.ensureMvccTx();
     const exists = await tx.exists(pageId);
     if (exists) {
@@ -11079,7 +11215,6 @@ var DataplyAPI = class {
   constructor(file, options) {
     this.file = file;
     this.hook = useHookall(this);
-    this.latcher = new Ryoiki3();
     this.options = this.verboseOptions(options);
     this.loggerManager = new LoggerManager(this.options.logLevel);
     this.logger = this.loggerManager.create("DataplyAPI");
@@ -11132,38 +11267,6 @@ var DataplyAPI = class {
   txIdCounter;
   /** Promise-chain mutex for serializing write operations */
   writeQueue = Promise.resolve();
-  /** Lock manager. Used for managing transactions */
-  latcher;
-  /**
-   * Acquire a read lock on the given page ID and execute the given function.
-   * @param pageId Page ID to acquire a read lock on
-   * @param fn Function to execute while holding the read lock
-   * @returns The result of the given function
-   */
-  async latchReadLock(pageId, fn) {
-    let lockId;
-    return this.latcher.readLock(this.latcher.range(pageId, 1), async (_lockId) => {
-      lockId = _lockId;
-      return fn();
-    }).finally(() => {
-      this.latcher.readUnlock(lockId);
-    });
-  }
-  /**
-   * Acquire a write lock on the given page ID and execute the given function.
-   * @param pageId Page ID to acquire a write lock on
-   * @param fn Function to execute while holding the write lock
-   * @returns The result of the given function
-   */
-  async latchWriteLock(pageId, fn) {
-    let lockId;
-    return this.latcher.writeLock(this.latcher.range(pageId, 1), async (_lockId) => {
-      lockId = _lockId;
-      return fn();
-    }).finally(() => {
-      this.latcher.writeUnlock(lockId);
-    });
-  }
   /**
    * Verifies if the page file is a valid Dataply file.
    * The metadata page must be located at the beginning of the Dataply file.

package/dist/types/core/DataplyAPI.d.ts

@@ -1,6 +1,5 @@
 import { type DataplyOptions, type DataplyMetadata } from '../types';
 import { type IHookall } from 'hookall';
-import { Ryoiki } from 'ryoiki';
 import { PageFileSystem } from './PageFileSystem';
 import { RowTableEngine } from './RowTableEngine';
 import { TextCodec } from '../utils/TextCodec';
@@ -48,23 +47,7 @@ export declare class DataplyAPI {
     private txIdCounter;
     /** Promise-chain mutex for serializing write operations */
     private writeQueue;
-    /** Lock manager. Used for managing transactions */
-    protected readonly latcher: Ryoiki;
     constructor(file: string, options: DataplyOptions);
-    /**
-     * Acquire a read lock on the given page ID and execute the given function.
-     * @param pageId Page ID to acquire a read lock on
-     * @param fn Function to execute while holding the read lock
-     * @returns The result of the given function
-     */
-    latchReadLock<T>(pageId: number, fn: () => Promise<T>): Promise<T>;
-    /**
-     * Acquire a write lock on the given page ID and execute the given function.
-     * @param pageId Page ID to acquire a write lock on
-     * @param fn Function to execute while holding the write lock
-     * @returns The result of the given function
-     */
-    latchWriteLock<T>(pageId: number, fn: () => Promise<T>): Promise<T>;
     /**
      * Verifies if the page file is a valid Dataply file.
      * The metadata page must be located at the beginning of the Dataply file.

package/dist/types/core/transaction/Transaction.d.ts

@@ -59,13 +59,13 @@ export declare class Transaction {
      * @param pageId Page ID
      * @returns Page data
      */
-    readPage(pageId: number): Promise<Uint8Array>;
+    __readPage(pageId: number): Promise<Uint8Array>;
     /**
      * Writes a page through the MVCC transaction.
      * @param pageId Page ID
      * @param data Page data
      */
-    writePage(pageId: number, data: Uint8Array): Promise<void>;
+    __writePage(pageId: number, data: Uint8Array): Promise<void>;
     /**
      * Acquires a write lock.
      * @param pageId Page ID

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.6",
+  "version": "0.0.26-alpha.7",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -49,6 +49,6 @@
     "hookall": "^2.2.0",
     "mvcc-api": "^1.3.7",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^9.0.0"
+    "serializable-bptree": "^9.0.1"
   }
-}
+}