serializable-bptree 8.4.1 → 8.4.2

package/dist/cjs/index.cjs

@@ -1569,8 +1569,6 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
 // src/base/BPTreeTransaction.ts
 var BPTreeTransaction = class _BPTreeTransaction {
   _cachedRegexp = /* @__PURE__ */ new Map();
-  nodes = /* @__PURE__ */ new Map();
-  deletedNodeBuffer = /* @__PURE__ */ new Map();
   rootTx;
   mvccRoot;
   mvcc;
@@ -2051,6 +2049,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
   _clearCache() {
     this._cachedRegexp.clear();
   }
+  _resetForReload() {
+    this._cachedRegexp.clear();
+    this.isInitialized = false;
+    this.isDestroyed = false;
+    this.mvccRoot.diskCache.clear();
+  }
   /**
    * Clears all cached nodes.
    * This method is useful for freeing up memory when the tree is no longer needed.
@@ -2381,6 +2385,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       throw e;
     }
   }
+  reload() {
+    if (this.rootTx !== this) {
+      throw new Error("Cannot call reload on a nested transaction");
+    }
+    this._reloadInternal();
+  }
+  _reloadInternal() {
+    this._resetForReload();
+    this._initInternal();
+  }
   exists(key, value) {
     const node = this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
@@ -3587,6 +3601,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       throw e;
     }
   }
+  async reload() {
+    if (this.rootTx !== this) {
+      throw new Error("Cannot call reload on a nested transaction");
+    }
+    return await this._reloadInternal();
+  }
+  async _reloadInternal() {
+    this._resetForReload();
+    await this._initInternal();
+  }
   async exists(key, value) {
     const node = await this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);

package/dist/esm/index.mjs

@@ -1533,8 +1533,6 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
 // src/base/BPTreeTransaction.ts
 var BPTreeTransaction = class _BPTreeTransaction {
   _cachedRegexp = /* @__PURE__ */ new Map();
-  nodes = /* @__PURE__ */ new Map();
-  deletedNodeBuffer = /* @__PURE__ */ new Map();
   rootTx;
   mvccRoot;
   mvcc;
@@ -2015,6 +2013,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
   _clearCache() {
     this._cachedRegexp.clear();
   }
+  _resetForReload() {
+    this._cachedRegexp.clear();
+    this.isInitialized = false;
+    this.isDestroyed = false;
+    this.mvccRoot.diskCache.clear();
+  }
   /**
    * Clears all cached nodes.
    * This method is useful for freeing up memory when the tree is no longer needed.
@@ -2345,6 +2349,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       throw e;
     }
   }
+  reload() {
+    if (this.rootTx !== this) {
+      throw new Error("Cannot call reload on a nested transaction");
+    }
+    this._reloadInternal();
+  }
+  _reloadInternal() {
+    this._resetForReload();
+    this._initInternal();
+  }
   exists(key, value) {
     const node = this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
@@ -3551,6 +3565,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       throw e;
     }
   }
+  async reload() {
+    if (this.rootTx !== this) {
+      throw new Error("Cannot call reload on a nested transaction");
+    }
+    return await this._reloadInternal();
+  }
+  async _reloadInternal() {
+    this._resetForReload();
+    await this._initInternal();
+  }
   async exists(key, value) {
     const node = await this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);

package/dist/types/base/BPTreeTransaction.d.ts

@@ -4,8 +4,6 @@ import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
 export declare abstract class BPTreeTransaction<K, V> {
     private readonly _cachedRegexp;
-    protected readonly nodes: Map<string, BPTreeUnknownNode<K, V>>;
-    protected readonly deletedNodeBuffer: Map<string, BPTreeUnknownNode<K, V>>;
     protected readonly rootTx: BPTreeTransaction<K, V>;
     protected readonly mvccRoot: BPTreeMVCC<K, V>;
     protected readonly mvcc: BPTreeMVCC<K, V>;
@@ -122,6 +120,12 @@ export declare abstract class BPTreeTransaction<K, V> {
      * If it is not called, the tree will not function.
      */
     abstract init(): Deferred<void>;
+    /**
+     * Clears all in-memory caches and re-initializes the tree from storage.
+     * This is equivalent to calling `clear()` followed by `init()`, but reuses the same instance.
+     * Useful when the underlying storage has been modified externally and the tree needs to reflect current state.
+     */
+    abstract reload(): Deferred<void>;
     /**
      * Retrieves the value associated with the given key.
      * @param key The key to search for.
@@ -233,6 +237,7 @@ export declare abstract class BPTreeTransaction<K, V> {
         deleted: TransactionEntry<string, BPTreeNode<K, V>>[];
     };
     protected _clearCache(): void;
+    protected _resetForReload(): void;
     /**
      * Clears all cached nodes.
      * This method is useful for freeing up memory when the tree is no longer needed.

package/dist/types/transaction/BPTreeAsyncTransaction.d.ts

@@ -34,6 +34,8 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): AsyncGenerator<[K, V]>;
     init(): Promise<void>;
     protected _initInternal(): Promise<void>;
+    reload(): Promise<void>;
+    protected _reloadInternal(): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
     get(key: K): Promise<V | undefined>;
     keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K>;

package/dist/types/transaction/BPTreeSyncTransaction.d.ts

@@ -31,6 +31,8 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): Generator<[K, V]>;
     init(): void;
     protected _initInternal(): void;
+    reload(): void;
+    protected _reloadInternal(): void;
     exists(key: K, value: V): boolean;
     get(key: K): V | undefined;
     keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<K>;

package/package.json

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