serializable-bptree 9.0.0 → 9.0.1

package/dist/cjs/index.cjs

@@ -5014,32 +5014,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,
@@ -5047,6 +5088,8 @@ var BPTreePureSync = class {
         this.strategy.head = head;
       }
     );
+    flush();
+    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
@@ -5120,16 +5163,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() {
@@ -5140,15 +5191,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;
@@ -5159,6 +5212,7 @@ var BPTreePureAsync = class {
   strategy;
   comparator;
   option;
+  lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
   _ctx;
   _ops;
@@ -5184,39 +5238,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;
@@ -5240,28 +5348,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();
@@ -5279,16 +5399,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() {
@@ -5297,9 +5433,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;

package/dist/esm/index.mjs

@@ -4976,32 +4976,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,
@@ -5009,6 +5050,8 @@ var BPTreePureSync = class {
         this.strategy.head = head;
       }
     );
+    flush();
+    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
@@ -5082,16 +5125,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() {
@@ -5102,15 +5153,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;
@@ -5121,6 +5174,7 @@ var BPTreePureAsync = class {
   strategy;
   comparator;
   option;
+  lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
   _ctx;
   _ops;
@@ -5146,39 +5200,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;
@@ -5202,28 +5310,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();
@@ -5241,16 +5361,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() {
@@ -5259,9 +5395,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;

package/dist/types/BPTreePureAsync.d.ts

@@ -2,10 +2,12 @@ import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearch
 import { SerializeStrategyAsync } from './SerializeStrategyAsync';
 import { ValueComparator } from './base/ValueComparator';
 import { BPTreeTransaction } from './base/BPTreeTransaction';
+import { Ryoiki } from 'ryoiki';
 export declare class BPTreePureAsync<K, V> {
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
+    protected readonly lock: Ryoiki;
     private readonly _cachedRegexp;
     private _ctx;
     private _ops;
@@ -14,6 +16,8 @@ export declare class BPTreePureAsync<K, V> {
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     private _ensureValues;
     private _createOps;
+    private _createBufferedOps;
+    protected writeLock<T>(fn: () => Promise<T>): Promise<T>;
     init(): Promise<void>;
     getRootId(): string;
     getOrder(): number;

package/dist/types/BPTreePureSync.d.ts

@@ -14,6 +14,7 @@ export declare class BPTreePureSync<K, V> {
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     private _ensureValues;
     private _createOps;
+    private _createBufferedOps;
     init(): void;
     /**
      * Returns the ID of the root node.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "9.0.0",
+  "version": "9.0.1",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",