serializable-bptree 8.1.2 → 8.1.4

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

@@ -1,11 +1,10 @@
 import type { TransactionEntry, TransactionResult } from 'mvcc-api';
 import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC } from '../types';
-import { LRUMap } from 'cache-entanglement';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
 export declare abstract class BPTreeTransaction<K, V> {
     private readonly _cachedRegexp;
-    protected readonly nodes: LRUMap<string, BPTreeUnknownNode<K, V>>;
+    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>;
@@ -15,6 +14,8 @@ export declare abstract class BPTreeTransaction<K, V> {
     protected readonly option: BPTreeConstructorOption;
     protected order: number;
     protected rootId: string;
+    protected isInitialized: boolean;
+    protected isDestroyed: boolean;
     protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>;
     protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
     protected readonly verifierEndNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V> | null>>;
@@ -72,6 +73,7 @@ export declare abstract class BPTreeTransaction<K, V> {
      * @returns Returns true if the value satisfies the condition.
      */
     verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
+    protected _cloneNode<T extends BPTreeUnknownNode<K, V>>(node: T): T;
     /**
      * Selects the best driver key from a condition object.
      * The driver key determines the starting point and traversal direction for queries.
@@ -81,11 +83,10 @@ export declare abstract class BPTreeTransaction<K, V> {
      */
     protected getDriverKey(condition: BPTreeCondition<V>): keyof BPTreeCondition<V> | null;
     protected constructor(rootTx: BPTreeTransaction<K, V> | null, mvccRoot: BPTreeMVCC<K, V>, mvcc: BPTreeMVCC<K, V>, strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
-    private _createCachedRegexp;
     protected abstract _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
-    protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
+    protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
-    protected abstract _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
+    protected abstract _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract getNode(id: string): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract insertableNode(value: V): Deferred<BPTreeLeafNode<K, V>>;
     protected abstract insertableNodeByPrimary(value: V): Deferred<BPTreeLeafNode<K, V>>;
@@ -94,6 +95,11 @@ export declare abstract class BPTreeTransaction<K, V> {
     protected abstract insertableEndNode(value: V, direction: 1 | -1): Deferred<BPTreeLeafNode<K, V> | null>;
     protected abstract leftestNode(): Deferred<BPTreeLeafNode<K, V>>;
     protected abstract rightestNode(): Deferred<BPTreeLeafNode<K, V>>;
+    /**
+     * After creating a tree instance, it must be called.
+     * This method is used to initialize the stored tree and recover data.
+     * If it is not called, the tree will not function.
+     */
     /**
      * After creating a tree instance, it must be called.
      * This method is used to initialize the stored tree and recover data.
@@ -142,14 +148,6 @@ export declare abstract class BPTreeTransaction<K, V> {
     * @param data User-defined data to be stored in the head of the tree.
     */
     abstract setHeadData(data: SerializableData): Deferred<void>;
-    /**
-     * This method deletes nodes cached in-memory and caches new nodes from the stored nodes.
-     * Typically, there's no need to use this method, but it can be used to synchronize data in scenarios where the remote storage and the client are in a 1:n relationship.
-     * If you do not specify an ID, all nodes will be updated.
-     * @param id The ID of the node to update.
-     * @returns The return value is the total number of nodes updated.
-     */
-    abstract forceUpdate(id?: string): Deferred<number>;
     /**
      * Returns the user-defined data stored in the head of the tree.
      */
@@ -162,7 +160,7 @@ export declare abstract class BPTreeTransaction<K, V> {
     /**
      * Rolls back the transaction and returns the result.
      */
-    abstract rollback(): TransactionResult<string, BPTreeNode<K, V>>;
+    abstract rollback(): Deferred<TransactionResult<string, BPTreeNode<K, V>>>;
     protected ensureValues(v: V | V[]): V[];
     protected lowestValue(v: V[]): V;
     protected highestValue(v: V[]): V;
@@ -177,11 +175,13 @@ export declare abstract class BPTreeTransaction<K, V> {
         updated: TransactionEntry<string, BPTreeNode<K, V>>[];
         deleted: TransactionEntry<string, BPTreeNode<K, V>>[];
     };
+    protected _clearCache(): void;
     /**
      * Clears all cached nodes.
      * This method is useful for freeing up memory when the tree is no longer needed.
      */
     clear(): void;
+    protected _clearInternal(): void;
     protected _binarySearchValues(values: V[], target: V, usePrimary?: boolean, upperBound?: boolean): {
         index: number;
         found: boolean;

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

@@ -1,5 +1,6 @@
 import type { TransactionResult } from 'mvcc-api';
 import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreeOrder, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead } from '../types';
+import { Ryoiki } from 'ryoiki';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
 import { ValueComparator } from '../base/ValueComparator';
@@ -10,7 +11,9 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
+    protected readonly lock: Ryoiki;
     constructor(rootTx: BPTreeAsyncTransaction<K, V> | null, mvccRoot: AsyncBPTreeMVCC<K, V>, mvcc: AsyncBPTreeMVCC<K, V>, strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    protected writeLock<T>(id: number, fn: () => Promise<T>): Promise<T>;
     protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
     /**
      * Create a new node with a unique ID.
@@ -20,7 +23,7 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected _deleteNode(node: BPTreeUnknownNode<K, V>): Promise<void>;
     protected _readHead(): Promise<SerializeStrategyHead | null>;
     protected _writeHead(head: SerializeStrategyHead): Promise<void>;
-    protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): Promise<void>;
+    protected _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<BPTreeUnknownNode<K, V>>;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Promise<void>;
     protected insertableNode(value: V): Promise<BPTreeLeafNode<K, V>>;
     protected insertableNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V>>;
@@ -31,18 +34,18 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected rightestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected getPairsGenerator(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1, earlyTerminate: boolean): AsyncGenerator<[K, V]>;
     init(): Promise<void>;
+    protected _initInternal(): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
-    forceUpdate(id?: string): Promise<number>;
     get(key: K): Promise<V | undefined>;
     keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number, order?: BPTreeOrder): AsyncGenerator<K>;
     whereStream(condition: BPTreeCondition<V>, limit?: number, order?: BPTreeOrder): AsyncGenerator<[K, V]>;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>, order?: BPTreeOrder): Promise<Set<K>>;
     where(condition: BPTreeCondition<V>, order?: BPTreeOrder): Promise<BPTreePair<K, V>>;
     insert(key: K, value: V): Promise<void>;
-    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<void>;
+    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<BPTreeUnknownNode<K, V>>;
     delete(key: K, value: V): Promise<void>;
     getHeadData(): Promise<SerializableData>;
     setHeadData(data: SerializableData): Promise<void>;
     commit(label?: string): Promise<TransactionResult<string, BPTreeNode<K, V>>>;
-    rollback(): TransactionResult<string, BPTreeNode<K, V>>;
+    rollback(): Promise<TransactionResult<string, BPTreeNode<K, V>>>;
 }

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

@@ -20,7 +20,7 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected _deleteNode(node: BPTreeUnknownNode<K, V>): void;
     protected _readHead(): SerializeStrategyHead | null;
     protected _writeHead(head: SerializeStrategyHead): void;
-    protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
+    protected _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): BPTreeUnknownNode<K, V>;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): void;
     protected insertableNode(value: V): BPTreeLeafNode<K, V>;
     protected insertableNodeByPrimary(value: V): BPTreeLeafNode<K, V>;
@@ -31,15 +31,15 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected rightestNode(): BPTreeLeafNode<K, V>;
     protected getPairsGenerator(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1, earlyTerminate: boolean): Generator<[K, V]>;
     init(): void;
+    protected _initInternal(): void;
     exists(key: K, value: V): boolean;
-    forceUpdate(id?: string): number;
     get(key: K): V | undefined;
     keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number, order?: BPTreeOrder): Generator<K>;
     whereStream(condition: BPTreeCondition<V>, limit?: number, order?: BPTreeOrder): Generator<[K, V]>;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>, order?: BPTreeOrder): Set<K>;
     where(condition: BPTreeCondition<V>, order?: BPTreeOrder): BPTreePair<K, V>;
     insert(key: K, value: V): void;
-    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): void;
+    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): BPTreeUnknownNode<K, V>;
     delete(key: K, value: V): void;
     getHeadData(): SerializableData;
     setHeadData(data: SerializableData): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "8.1.2",
+  "version": "8.1.4",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",
@@ -17,7 +17,8 @@
   ],
   "scripts": {
     "test": "jest --runInBand",
-    "build": "node build/index.js && tsc"
+    "build": "node build/index.js && tsc",
+    "benchmark": "npx tsx benchmark/index.ts"
   },
   "author": "izure <admin@izure.org>",
   "keywords": [
@@ -43,8 +44,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "cache-entanglement": "^1.7.1",
-    "mvcc-api": "^1.2.11",
+    "mvcc-api": "^1.3.2",
     "ryoiki": "^1.2.0"
   }
 }