serializable-bptree 7.0.3 → 8.0.0

package/dist/types/BPTreeAsync.d.ts

@@ -1,17 +1,14 @@
 import type { BPTreeConstructorOption } from './types';
 import { SerializeStrategyAsync } from './SerializeStrategyAsync';
 import { ValueComparator } from './base/ValueComparator';
-import { BPTreeAsyncBase } from './base/BPTreeAsyncBase';
 import { BPTreeAsyncTransaction } from './transaction/BPTreeAsyncTransaction';
-export declare class BPTreeAsync<K, V> extends BPTreeAsyncBase<K, V> {
+export declare class BPTreeAsync<K, V> extends BPTreeAsyncTransaction<K, V> {
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     /**
      * Creates a new asynchronous transaction.
-     * @returns A promise that resolves to a new BPTreeAsyncTransaction.
+     * @returns A new BPTreeAsyncTransaction.
      */
     createTransaction(): Promise<BPTreeAsyncTransaction<K, V>>;
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value: V): Promise<void>;
-    protected readLock<T>(fn: () => Promise<T>): Promise<T>;
-    protected writeLock<T>(fn: () => Promise<T>): Promise<T>;
 }

package/dist/types/BPTreeSync.d.ts

@@ -1,9 +1,8 @@
 import type { BPTreeConstructorOption } from './types';
 import { SerializeStrategySync } from './SerializeStrategySync';
 import { ValueComparator } from './base/ValueComparator';
-import { BPTreeSyncBase } from './base/BPTreeSyncBase';
 import { BPTreeSyncTransaction } from './transaction/BPTreeSyncTransaction';
-export declare class BPTreeSync<K, V> extends BPTreeSyncBase<K, V> {
+export declare class BPTreeSync<K, V> extends BPTreeSyncTransaction<K, V> {
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     /**
      * Creates a new synchronous transaction.

package/dist/types/SerializeStrategyAsync.d.ts

@@ -12,8 +12,6 @@ export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStra
     getHeadData(key: string, defaultValue: Json): Promise<Json>;
     setHeadData(key: string, data: Json): Promise<void>;
     autoIncrement(key: string, defaultValue: number): Promise<number>;
-    getLastCommittedTransactionId(): Promise<number>;
-    compareAndSwapHead(newRoot: string, newTxId: number): Promise<void>;
 }
 export declare class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyAsync<K, V> {
     protected readonly node: Record<string, BPTreeNode<K, V>>;

package/dist/types/SerializeStrategySync.d.ts

@@ -10,8 +10,6 @@ export declare abstract class SerializeStrategySync<K, V> extends SerializeStrat
     getHeadData(key: string, defaultValue: Json): Json;
     setHeadData(key: string, data: Json): void;
     autoIncrement(key: string, defaultValue: number): number;
-    getLastCommittedTransactionId(): number;
-    compareAndSwapHead(newRoot: string, newTxId: number): void;
 }
 export declare class InMemoryStoreStrategySync<K, V> extends SerializeStrategySync<K, V> {
     protected readonly node: Record<string, BPTreeNode<K, V>>;

package/dist/types/base/{BPTree.d.ts → BPTreeTransaction.d.ts}

@@ -1,25 +1,20 @@
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData } from '../types';
-import { CacheEntanglementSync, CacheEntanglementAsync } from 'cache-entanglement';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC } from '../types';
+import { LRUMap } from 'cache-entanglement';
+import { TransactionResult } from 'mvcc-api';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
-export declare abstract class BPTree<K, V> {
+export declare abstract class BPTreeTransaction<K, V> {
     private readonly _cachedRegexp;
-    protected abstract readonly nodes: CacheEntanglementSync<any, any> | CacheEntanglementAsync<any, any>;
+    protected readonly nodes: LRUMap<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>;
     protected readonly strategy: SerializeStrategy<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
     protected order: number;
     protected rootId: string;
-    protected _strategyDirty: boolean;
-    protected readonly _nodeCreateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
-    protected readonly _nodeUpdateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
-    protected readonly _nodeDeleteBuffer: Map<string, BPTreeUnknownNode<K, V>>;
-    readonly sharedDeleteCache: Map<string, {
-        node: BPTreeUnknownNode<K, V>;
-        obsoleteAt: number;
-    }>;
-    protected readonly activeTransactions: Set<number>;
-    private lastTransactionId;
     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>>;
@@ -77,12 +72,12 @@ export declare abstract class BPTree<K, V> {
      * @returns Returns true if the value satisfies the condition.
      */
     verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
-    protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    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 _createNodeId(isLeaf: boolean): Deferred<string>;
-    protected abstract _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
+    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 _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 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>>;
@@ -91,9 +86,6 @@ export declare abstract class BPTree<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>>;
-    protected abstract commitHeadBuffer(): Deferred<void>;
-    protected abstract commitNodeCreateBuffer(): Deferred<void>;
-    protected abstract commitNodeUpdateBuffer(): Deferred<void>;
     /**
      * After creating a tree instance, it must be called.
      * This method is used to initialize the stored tree and recover data.
@@ -150,30 +142,27 @@ export declare abstract class BPTree<K, V> {
      * @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.
+     */
+    abstract getHeadData(): Deferred<SerializableData>;
+    /**
+     * Commits the transaction and returns the result.
+     * @param label The label of the transaction.
+     */
+    abstract commit(label?: string): Deferred<TransactionResult<string, BPTreeNode<K, V>>>;
+    /**
+     * Rolls back the transaction and returns the result.
+     */
+    abstract rollback(): TransactionResult<string, BPTreeNode<K, V>>;
     protected ensureValues(v: V | V[]): V[];
     protected lowestValue(v: V[]): V;
     protected highestValue(v: V[]): V;
     protected lowestPrimaryValue(v: V[]): V;
     protected highestPrimaryValue(v: V[]): V;
-    protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): Deferred<void>;
-    protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
-    protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
-    protected bufferForNodeDelete(node: BPTreeUnknownNode<K, V>): Deferred<void>;
-    /**
-     * Returns the user-defined data stored in the head of the tree.
-     * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
-     * @returns User-defined data stored in the head of the tree.
-     */
-    getHeadData(): SerializableData;
     /**
      * Clears all cached nodes.
      * This method is useful for freeing up memory when the tree is no longer needed.
      */
     clear(): void;
-    registerTransaction(txId: number): void;
-    unregisterTransaction(txId: number): void;
-    pruneObsoleteNodes(): void;
-    getObsoleteNode(id: string): BPTreeUnknownNode<K, V> | undefined;
-    addObsoleteNode(node: BPTreeUnknownNode<K, V>, obsoleteAt: number): void;
-    getNextTransactionId(): number;
 }

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

@@ -2,7 +2,6 @@ import type { BPTreeNode, Json, SerializeStrategyHead } from '../types';
 export declare abstract class SerializeStrategy<K, V> {
     readonly order: number;
     head: SerializeStrategyHead;
-    protected lastCommittedTransactionId: number;
     constructor(order: number);
     /**
      * The rule for generating node IDs is set.
@@ -44,17 +43,6 @@ export declare abstract class SerializeStrategy<K, V> {
      * @param head This is the current state of the tree.
      */
     abstract writeHead(head: SerializeStrategyHead): void | Promise<void>;
-    /**
-     * Atomically updates the head with the new root and transaction ID.
-     * Required for Optimistic Concurrency Control (CoW).
-     * @param newRoot The new root ID to set.
-     * @param newTxId The new transaction ID.
-     */
-    abstract compareAndSwapHead(newRoot: string, newTxId: number): void | Promise<void>;
-    /**
-     * Returns the last committed transaction ID (in-memory only).
-     */
-    abstract getLastCommittedTransactionId(): number | Promise<number>;
     /**
      * Retrieves the data stored in the tree.
      * If no value is stored in the tree, it stores a `defaultValue` and then returns that value.

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type { BPTreeNode, BPTreeInternalNode, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, BPTreeCondition, SerializeStrategyHead, SerializableData } from './types';
+export type { BPTreeNode, BPTreeInternalNode, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, BPTreeCondition, BPTreeTransactionResult, SerializeStrategyHead, SerializableData } from './types';
 export { ValueComparator, NumericComparator, StringComparator } from './base/ValueComparator';
 export { BPTreeSync } from './BPTreeSync';
 export { BPTreeSyncTransaction } from './transaction/BPTreeSyncTransaction';

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

@@ -1,52 +1,48 @@
-import type { BPTreeUnknownNode, BPTreeTransactionResult } from '../types';
-import { BPTreeAsyncBase } from '../base/BPTreeAsyncBase';
-/**
- * Represents an asynchronous transaction for a B+ Tree.
- * Provides Snapshot Isolation using MVCC and Copy-on-Write techniques.
- */
-export declare class BPTreeAsyncTransaction<K, V> extends BPTreeAsyncBase<K, V> {
-    private readonly realBaseTree;
-    private readonly realBaseStrategy;
-    private txNodes;
-    protected readonly dirtyIds: Set<string>;
-    protected readonly createdInTx: Set<string>;
-    protected readonly deletedIds: Set<string>;
-    readonly obsoleteNodes: Map<string, BPTreeUnknownNode<K, V>>;
-    private readonly originalNodes;
-    private initialRootId;
-    private transactionRootId;
-    private transactionId;
-    private initialLastCommittedTransactionId;
-    constructor(baseTree: BPTreeAsyncBase<K, V>);
-    /**
-     * Initializes the transaction by capturing the current state of the tree.
-     */
-    initTransaction(): Promise<void>;
+import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead } from '../types';
+import { TransactionResult } from 'mvcc-api';
+import { BPTreeTransaction } from '../base/BPTreeTransaction';
+import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
+import { ValueComparator } from '../base/ValueComparator';
+export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V> {
+    protected readonly rootTx: BPTreeAsyncTransaction<K, V>;
+    protected readonly mvccRoot: AsyncBPTreeMVCC<K, V>;
+    protected readonly mvcc: AsyncBPTreeMVCC<K, V>;
+    protected readonly strategy: SerializeStrategyAsync<K, V>;
+    protected readonly comparator: ValueComparator<V>;
+    protected readonly option: BPTreeConstructorOption;
+    constructor(rootTx: BPTreeAsyncTransaction<K, V> | null, mvccRoot: AsyncBPTreeMVCC<K, V>, mvcc: AsyncBPTreeMVCC<K, V>, strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
-    protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Promise<void>;
-    protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Promise<void>;
-    protected bufferForNodeDelete(node: BPTreeUnknownNode<K, V>): Promise<void>;
-    private markPathDirty;
-    protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
-    /**
-     * Attempts to commit the transaction.
-     * Uses Optimistic Locking (Compare-And-Swap) on the root node ID to detect conflicts.
-     *
-     * @param cleanup Whether to clean up obsolete nodes after commit. Defaults to true.
-     * @returns A promise that resolves to the transaction result.
-     */
-    commit(cleanup?: boolean): Promise<BPTreeTransactionResult>;
     /**
-     * Rolls back the transaction by clearing all buffered changes.
-     * If cleanup is `true`, it also clears the transaction nodes.
-     * @param cleanup Whether to clear the transaction nodes.
-     * @returns The IDs of nodes that were created in this transaction.
+     * Create a new node with a unique ID.
      */
-    rollback(cleanup?: boolean): Promise<string[]>;
-    protected readLock<T>(fn: () => Promise<T>): Promise<T>;
-    protected writeLock<T>(fn: () => Promise<T>): Promise<T>;
-    protected commitHeadBuffer(): Promise<void>;
-    protected commitNodeCreateBuffer(): Promise<void>;
-    protected commitNodeUpdateBuffer(): Promise<void>;
-    protected commitNodeDeleteBuffer(): Promise<void>;
+    protected _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
+    protected _updateNode(node: BPTreeUnknownNode<K, V>): Promise<void>;
+    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 _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>>;
+    protected insertableRightestNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V>>;
+    protected insertableRightestEndNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V> | null>;
+    protected insertableEndNode(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
+    protected leftestNode(): Promise<BPTreeLeafNode<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>;
+    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): AsyncGenerator<K>;
+    whereStream(condition: BPTreeCondition<V>, limit?: number): AsyncGenerator<[K, V]>;
+    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Promise<Set<K>>;
+    where(condition: BPTreeCondition<V>): Promise<BPTreePair<K, V>>;
+    insert(key: K, value: V): Promise<void>;
+    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<void>;
+    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>>;
 }

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

@@ -0,0 +1,15 @@
+import type { SerializeStrategyAsync } from '../SerializeStrategyAsync';
+import type { BPTreeNode } from '../types';
+import { AsyncMVCCStrategy } from 'mvcc-api';
+/**
+ * MVCC Strategy for synchronous B+Tree operations.
+ * Uses node ID as key and node data as value.
+ */
+export declare class BPTreeMVCCStrategyAsync<K, V, B extends BPTreeNode<K, V>> extends AsyncMVCCStrategy<string, B> {
+    private readonly strategy;
+    constructor(strategy: SerializeStrategyAsync<K, V>);
+    read(key: string): Promise<B>;
+    write(key: string, value: B): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+}

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

@@ -0,0 +1,15 @@
+import type { SerializeStrategySync } from '../SerializeStrategySync';
+import type { BPTreeNode } from '../types';
+import { SyncMVCCStrategy } from 'mvcc-api';
+/**
+ * MVCC Strategy for synchronous B+Tree operations.
+ * Uses node ID as key and node data as value.
+ */
+export declare class BPTreeMVCCStrategySync<K, V, B extends BPTreeNode<K, V>> extends SyncMVCCStrategy<string, B> {
+    private readonly strategy;
+    constructor(strategy: SerializeStrategySync<K, V>);
+    read(key: string): B;
+    write(key: string, value: B): void;
+    delete(key: string): void;
+    exists(key: string): boolean;
+}

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

@@ -1,52 +1,48 @@
-import type { BPTreeUnknownNode, BPTreeTransactionResult } from '../types';
-import { BPTreeSyncBase } from '../base/BPTreeSyncBase';
-/**
- * Represents a synchronous transaction for a B+ Tree.
- * Provides Snapshot Isolation using MVCC and Copy-on-Write techniques.
- */
-export declare class BPTreeSyncTransaction<K, V> extends BPTreeSyncBase<K, V> {
-    private readonly realBaseTree;
-    private readonly realBaseStrategy;
-    private txNodes;
-    protected readonly dirtyIds: Set<string>;
-    protected readonly createdInTx: Set<string>;
-    protected readonly deletedIds: Set<string>;
-    readonly obsoleteNodes: Map<string, BPTreeUnknownNode<K, V>>;
-    private readonly originalNodes;
-    private initialRootId;
-    private transactionRootId;
-    private transactionId;
-    private initialLastCommittedTransactionId;
-    constructor(baseTree: BPTreeSyncBase<K, V>);
-    /**
-     * Initializes the transaction by capturing the current state of the tree.
-     */
-    initTransaction(): void;
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC } from '../types';
+import { TransactionResult } from 'mvcc-api';
+import { BPTreeTransaction } from '../base/BPTreeTransaction';
+import { SerializeStrategySync } from '../SerializeStrategySync';
+import { ValueComparator } from '../base/ValueComparator';
+export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V> {
+    protected readonly rootTx: BPTreeSyncTransaction<K, V>;
+    protected readonly mvccRoot: SyncBPTreeMVCC<K, V>;
+    protected readonly mvcc: SyncBPTreeMVCC<K, V>;
+    protected readonly strategy: SerializeStrategySync<K, V>;
+    protected readonly comparator: ValueComparator<V>;
+    protected readonly option: BPTreeConstructorOption;
+    constructor(rootTx: BPTreeSyncTransaction<K, V>, mvccRoot: SyncBPTreeMVCC<K, V>, mvcc: SyncBPTreeMVCC<K, V>, strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     protected getNode(id: string): BPTreeUnknownNode<K, V>;
-    protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): void;
-    protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): void;
-    protected bufferForNodeDelete(node: BPTreeUnknownNode<K, V>): void;
-    private markPathDirty;
-    protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
-    /**
-     * Attempts to commit the transaction.
-     * Uses Optimistic Locking (Compare-And-Swap) on the root node ID to detect conflicts.
-     *
-     * @param cleanup Whether to clean up obsolete nodes after commit. Defaults to true.
-     * @returns The transaction result.
-     */
-    commit(cleanup?: boolean): BPTreeTransactionResult;
     /**
-     * Rolls back the transaction by clearing all buffered changes.
-     * If cleanup is `true`, it also clears the transaction nodes.
-     * @param cleanup Whether to clear the transaction nodes.
-     * @returns The IDs of nodes that were created in this transaction.
+     * Create a new node with a unique ID.
      */
-    rollback(cleanup?: boolean): string[];
-    protected readLock<T>(fn: () => T): T;
-    protected writeLock<T>(fn: () => T): T;
-    protected commitHeadBuffer(): void;
-    protected commitNodeCreateBuffer(): void;
-    protected commitNodeUpdateBuffer(): void;
-    protected commitNodeDeleteBuffer(): void;
+    protected _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
+    protected _updateNode(node: BPTreeUnknownNode<K, V>): void;
+    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 _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>;
+    protected insertableRightestNodeByPrimary(value: V): BPTreeLeafNode<K, V>;
+    protected insertableRightestEndNodeByPrimary(value: V): BPTreeLeafNode<K, V> | null;
+    protected insertableEndNode(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
+    protected leftestNode(): BPTreeLeafNode<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;
+    exists(key: K, value: V): boolean;
+    forceUpdate(id?: string): number;
+    get(key: K): V | undefined;
+    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number): Generator<K>;
+    whereStream(condition: BPTreeCondition<V>, limit?: number): Generator<[K, V]>;
+    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
+    where(condition: BPTreeCondition<V>): BPTreePair<K, V>;
+    insert(key: K, value: V): void;
+    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): void;
+    delete(key: K, value: V): void;
+    getHeadData(): SerializableData;
+    setHeadData(data: SerializableData): void;
+    commit(label?: string): TransactionResult<string, BPTreeNode<K, V>>;
+    rollback(): TransactionResult<string, BPTreeNode<K, V>>;
 }

package/dist/types/types/index.d.ts

@@ -1,3 +1,6 @@
+import type { SyncMVCCTransaction, AsyncMVCCTransaction, MVCCTransaction, MVCCStrategy } from 'mvcc-api';
+import { BPTreeMVCCStrategyAsync } from '../transaction/BPTreeMVCCStrategyAsync';
+import { BPTreeMVCCStrategySync } from '../transaction/BPTreeMVCCStrategySync';
 export type Sync<T> = T;
 export type Async<T> = Promise<T>;
 export type Deferred<T> = Sync<T> | Async<T>;
@@ -78,6 +81,8 @@ export interface BPTreeTransactionResult {
     createdIds: string[];
     /** IDs of nodes that became obsolete and can be deleted after a successful commit. */
     obsoleteIds: string[];
+    /** Error message if the transaction failed. */
+    error?: string;
 }
 export type SerializableData = Record<string, Json>;
 export interface SerializeStrategyHead {
@@ -85,6 +90,9 @@ export interface SerializeStrategyHead {
     order: number;
     data: SerializableData;
 }
+export type BPTreeMVCC<K, V> = MVCCTransaction<MVCCStrategy<string, BPTreeNode<K, V>>, string, BPTreeNode<K, V>>;
+export type SyncBPTreeMVCC<K, V> = SyncMVCCTransaction<BPTreeMVCCStrategySync<K, V, BPTreeNode<K, V>>, string, BPTreeNode<K, V>>;
+export type AsyncBPTreeMVCC<K, V> = AsyncMVCCTransaction<BPTreeMVCCStrategyAsync<K, V, BPTreeNode<K, V>>, string, BPTreeNode<K, V>>;
 export type Primitive = string | number | null | boolean;
 export type Json = Primitive | Primitive[] | Json[] | {
     [key: string]: Json;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "7.0.3",
+  "version": "8.0.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",
@@ -16,7 +16,7 @@
     "dist/**/*"
   ],
   "scripts": {
-    "test": "jest",
+    "test": "jest --runInBand",
     "build": "node build/index.js && tsc"
   },
   "author": "izure <admin@izure.org>",
@@ -44,6 +44,7 @@
   },
   "dependencies": {
     "cache-entanglement": "^1.7.1",
+    "mvcc-api": "^1.2.8",
     "ryoiki": "^1.2.0"
   }
 }

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

@@ -1,41 +0,0 @@
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, BPTreeLeafNode, BPTreeNodeKey, SerializableData, BPTreePair } from '../types';
-import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
-import { BPTree } from './BPTree';
-import { ValueComparator } from './ValueComparator';
-export declare abstract class BPTreeAsyncBase<K, V> extends BPTree<K, V> {
-    protected readonly strategy: SerializeStrategyAsync<K, V>;
-    protected readonly nodes: ReturnType<typeof this._createCachedNode>;
-    constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
-    private _createCachedNode;
-    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]>;
-    protected _createNodeId(isLeaf: boolean): Promise<string>;
-    protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
-    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;
-    protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Promise<void>;
-    init(): Promise<void>;
-    protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
-    protected insertableNode(value: V): Promise<BPTreeLeafNode<K, V>>;
-    protected insertableNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V>>;
-    protected insertableRightestNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V>>;
-    protected insertableRightestEndNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V> | null>;
-    protected insertableEndNode(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
-    protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
-    protected rightestNode(): Promise<BPTreeLeafNode<K, V>>;
-    exists(key: K, value: V): Promise<boolean>;
-    forceUpdate(id?: string): Promise<number>;
-    protected commitHeadBuffer(): Promise<void>;
-    protected commitNodeCreateBuffer(): Promise<void>;
-    protected commitNodeUpdateBuffer(): Promise<void>;
-    protected commitNodeDeleteBuffer(): Promise<void>;
-    get(key: K): Promise<V | undefined>;
-    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number): AsyncGenerator<K>;
-    whereStream(condition: BPTreeCondition<V>, limit?: number): AsyncGenerator<[K, V]>;
-    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Promise<Set<K>>;
-    where(condition: BPTreeCondition<V>): Promise<BPTreePair<K, V>>;
-    insert(key: K, value: V): Promise<void>;
-    delete(key: K, value: V): Promise<void>;
-    getHeadData(): SerializableData;
-    setHeadData(data: SerializableData): Promise<void>;
-    protected abstract readLock<T>(fn: () => Promise<T>): Promise<T>;
-    protected abstract writeLock<T>(fn: () => Promise<T>): Promise<T>;
-}

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

@@ -1,39 +0,0 @@
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData } from '../types';
-import { SerializeStrategySync } from '../SerializeStrategySync';
-import { BPTree } from './BPTree';
-import { ValueComparator } from './ValueComparator';
-export declare abstract class BPTreeSyncBase<K, V> extends BPTree<K, V> {
-    protected readonly strategy: SerializeStrategySync<K, V>;
-    protected readonly nodes: ReturnType<typeof this._createCachedNode>;
-    constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
-    private _createCachedNode;
-    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]>;
-    protected _createNodeId(isLeaf: boolean): string;
-    protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
-    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
-    protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): void;
-    init(): void;
-    protected getNode(id: string): BPTreeUnknownNode<K, V>;
-    protected insertableNode(value: V): BPTreeLeafNode<K, V>;
-    protected insertableNodeByPrimary(value: V): BPTreeLeafNode<K, V>;
-    protected insertableRightestNodeByPrimary(value: V): BPTreeLeafNode<K, V>;
-    protected insertableRightestEndNodeByPrimary(value: V): BPTreeLeafNode<K, V> | null;
-    protected insertableEndNode(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
-    protected leftestNode(): BPTreeLeafNode<K, V>;
-    protected rightestNode(): BPTreeLeafNode<K, V>;
-    exists(key: K, value: V): boolean;
-    forceUpdate(id?: string): number;
-    protected commitHeadBuffer(): void;
-    protected commitNodeCreateBuffer(): void;
-    protected commitNodeUpdateBuffer(): void;
-    protected commitNodeDeleteBuffer(): void;
-    get(key: K): V | undefined;
-    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number): Generator<K>;
-    whereStream(condition: BPTreeCondition<V>, limit?: number): Generator<[K, V]>;
-    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
-    where(condition: BPTreeCondition<V>): BPTreePair<K, V>;
-    insert(key: K, value: V): void;
-    delete(key: K, value: V): void;
-    getHeadData(): SerializableData;
-    setHeadData(data: SerializableData): void;
-}

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

@@ -1,18 +0,0 @@
-import type { SerializeStrategyHead, BPTreeNode, Json } from '../types';
-import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
-export declare class BPTreeAsyncSnapshotStrategy<K, V> extends SerializeStrategyAsync<K, V> {
-    private readonly baseStrategy;
-    private readonly snapshotHead;
-    constructor(baseStrategy: SerializeStrategyAsync<K, V>, root: string);
-    id(isLeaf: boolean): Promise<string>;
-    read(id: string): Promise<BPTreeNode<K, V>>;
-    write(id: string, node: BPTreeNode<K, V>): Promise<void>;
-    delete(id: string): Promise<void>;
-    readHead(): Promise<SerializeStrategyHead | null>;
-    writeHead(head: SerializeStrategyHead): Promise<void>;
-    compareAndSwapHead(newRoot: string, newTxId: number): Promise<void>;
-    getLastCommittedTransactionId(): Promise<number>;
-    getHeadData(key: string, defaultValue: Json): Promise<Json>;
-    setHeadData(key: string, data: Json): Promise<void>;
-    autoIncrement(key: string, defaultValue: number): Promise<number>;
-}

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

@@ -1,18 +0,0 @@
-import type { SerializeStrategyHead, BPTreeNode, Json } from '../types';
-import { SerializeStrategySync } from '../SerializeStrategySync';
-export declare class BPTreeSyncSnapshotStrategy<K, V> extends SerializeStrategySync<K, V> {
-    private readonly baseStrategy;
-    private readonly snapshotHead;
-    constructor(baseStrategy: SerializeStrategySync<K, V>, root: string);
-    id(isLeaf: boolean): string;
-    read(id: string): BPTreeNode<K, V>;
-    write(id: string, node: BPTreeNode<K, V>): void;
-    delete(id: string): void;
-    readHead(): SerializeStrategyHead | null;
-    writeHead(head: SerializeStrategyHead): void;
-    compareAndSwapHead(newRoot: string, newTxId: number): void;
-    getLastCommittedTransactionId(): number;
-    getHeadData(key: string, defaultValue: Json): Json;
-    setHeadData(key: string, data: Json): void;
-    autoIncrement(key: string, defaultValue: number): number;
-}