serializable-bptree 7.0.1 → 7.0.3

package/dist/types/SerializeStrategyAsync.d.ts

@@ -7,10 +7,13 @@ export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStra
     abstract delete(id: string): Promise<void>;
     abstract readHead(): Promise<SerializeStrategyHead | null>;
     abstract writeHead(head: SerializeStrategyHead): Promise<void>;
+    private lock;
+    acquireLock<T>(action: () => Promise<T>): Promise<T>;
     getHeadData(key: string, defaultValue: Json): Promise<Json>;
     setHeadData(key: string, data: Json): Promise<void>;
     autoIncrement(key: string, defaultValue: number): Promise<number>;
-    compareAndSwapHead(oldRoot: string | null, newRoot: string): Promise<boolean>;
+    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,7 +10,8 @@ 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;
-    compareAndSwapHead(oldRoot: string | null, newRoot: string): boolean;
+    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

@@ -10,20 +10,16 @@ export declare abstract class BPTree<K, V> {
     protected readonly option: BPTreeConstructorOption;
     protected order: number;
     protected rootId: string;
-    /**
-     * Returns the ID of the root node.
-     * @returns The root node ID.
-     */
-    getRootId(): string;
-    /**
-     * Returns the order of the B+Tree.
-     * @returns The order of the tree.
-     */
-    getOrder(): number;
     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>>;
@@ -63,6 +59,16 @@ export declare abstract class BPTree<K, V> {
         tree: T;
         condition: BPTreeCondition<unknown>;
     } | null;
+    /**
+     * Returns the ID of the root node.
+     * @returns The root node ID.
+     */
+    getRootId(): string;
+    /**
+     * Returns the order of the B+Tree.
+     * @returns The order of the tree.
+     */
+    getOrder(): number;
     /**
      * Verified if the value satisfies the condition.
      *
@@ -164,4 +170,10 @@ export declare abstract class BPTree<K, V> {
      * 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,6 +2,7 @@ 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,13 +45,16 @@ export declare abstract class SerializeStrategy<K, V> {
      */
     abstract writeHead(head: SerializeStrategyHead): void | Promise<void>;
     /**
-     * Atomically updates the head if the current root matches the expected value.
+     * Atomically updates the head with the new root and transaction ID.
      * Required for Optimistic Concurrency Control (CoW).
-     * @param oldRoot The expected current root ID.
      * @param newRoot The new root ID to set.
-     * @returns True if successful, False if the root has changed.
+     * @param newTxId The new transaction ID.
      */
-    abstract compareAndSwapHead(oldRoot: string | null, newRoot: string): boolean | Promise<boolean>;
+    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/transaction/BPTreeAsyncSnapshotStrategy.d.ts

@@ -10,7 +10,8 @@ export declare class BPTreeAsyncSnapshotStrategy<K, V> extends SerializeStrategy
     delete(id: string): Promise<void>;
     readHead(): Promise<SerializeStrategyHead | null>;
     writeHead(head: SerializeStrategyHead): Promise<void>;
-    compareAndSwapHead(oldRoot: string | null, newRoot: string): Promise<boolean>;
+    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/BPTreeAsyncTransaction.d.ts

@@ -11,8 +11,12 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeAsyncBase<K, V>
     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.
@@ -28,14 +32,17 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeAsyncBase<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(): Promise<BPTreeTransactionResult>;
+    commit(cleanup?: boolean): Promise<BPTreeTransactionResult>;
     /**
      * Rolls back the transaction by clearing all buffered changes.
-     * Internal use only.
+     * 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.
      */
-    protected rollback(): Promise<void>;
+    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>;

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

@@ -10,7 +10,8 @@ export declare class BPTreeSyncSnapshotStrategy<K, V> extends SerializeStrategyS
     delete(id: string): void;
     readHead(): SerializeStrategyHead | null;
     writeHead(head: SerializeStrategyHead): void;
-    compareAndSwapHead(oldRoot: string | null, newRoot: string): boolean;
+    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;

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

@@ -11,8 +11,12 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeSyncBase<K, V> {
     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.
@@ -28,14 +32,19 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeSyncBase<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(): BPTreeTransactionResult;
+    commit(cleanup?: boolean): BPTreeTransactionResult;
     /**
      * Rolls back the transaction by clearing all buffered changes.
-     * Internal use only.
+     * 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.
      */
-    protected rollback(): void;
+    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;

package/package.json

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