feat: Add delete method to SerializeStrategy class.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "3.3.1",
+  "version": "3.4.0-alpha.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.mjs",

src/BPTreeAsync.ts

@@ -159,6 +159,7 @@ export class BPTreeAsync<K, V> extends BPTree<K, V> {
 
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys as number[]
+      this.bufferForNodeDelete(this.root)
       this.root = await this.getNode(keys[0])
       this.root.parent = 0
       this.strategy.head.root = this.root.id
@@ -255,6 +256,7 @@ export class BPTreeAsync<K, V> extends BPTree<K, V> {
 
         await this._deleteEntry(await this.getNode(node.parent), node.id, guess!)
         this.bufferForNodeUpdate(pointer)
+        this.bufferForNodeDelete(node)
       }
       else {
         if (isPredecessor) {
@@ -491,6 +493,13 @@ export class BPTreeAsync<K, V> extends BPTree<K, V> {
     this._nodeUpdateBuffer.clear()
   }
 
+  protected async commitNodeDeleteBuffer(): Promise<void> {
+    for (const node of this._nodeDeleteBuffer.values()) {
+      await this.strategy.delete(node.id)
+    }
+    this._nodeDeleteBuffer.clear()
+  }
+
   public async keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Promise<Set<K>> {
     for (const k in condition) {
       const key = k as keyof BPTreeCondition<V>
@@ -608,6 +617,7 @@ export class BPTreeAsync<K, V> extends BPTree<K, V> {
     await this.commitHeadBuffer()
     await this.commitNodeCreateBuffer()
     await this.commitNodeUpdateBuffer()
+    await this.commitNodeDeleteBuffer()
   }
 
   public async exists(key: K, value: V): Promise<boolean> {

src/BPTreeSync.ts

@@ -159,6 +159,7 @@ export class BPTreeSync<K, V> extends BPTree<K, V> {
 
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys as number[]
+      this.bufferForNodeDelete(this.root)
       this.root = this.getNode(keys[0])
       this.root.parent = 0
       this.strategy.head.root = this.root.id
@@ -255,6 +256,7 @@ export class BPTreeSync<K, V> extends BPTree<K, V> {
 
         this._deleteEntry(this.getNode(node.parent), node.id, guess!)
         this.bufferForNodeUpdate(pointer)
+        this.bufferForNodeDelete(node)
       }
       else {
         if (isPredecessor) {
@@ -491,6 +493,13 @@ export class BPTreeSync<K, V> extends BPTree<K, V> {
     this._nodeUpdateBuffer.clear()
   }
 
+  protected commitNodeDeleteBuffer(): void {
+    for (const node of this._nodeDeleteBuffer.values()) {
+      this.strategy.delete(node.id)
+    }
+    this._nodeDeleteBuffer.clear()
+  }
+
   public keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K> {
     for (const k in condition) {
       const key = k as keyof BPTreeCondition<V>
@@ -608,6 +617,7 @@ export class BPTreeSync<K, V> extends BPTree<K, V> {
     this.commitHeadBuffer()
     this.commitNodeCreateBuffer()
     this.commitNodeUpdateBuffer()
+    this.commitNodeDeleteBuffer()
   }
 
   public exists(key: K, value: V): boolean {

src/SerializeStrategyAsync.ts

@@ -6,6 +6,7 @@ export abstract class SerializeStrategyAsync<K, V> extends SerializeStrategy<K,
   abstract id(isLeaf: boolean): Promise<number>
   abstract read(id: number): Promise<BPTreeNode<K, V>>
   abstract write(id: number, node: BPTreeNode<K, V>): Promise<void>
+  abstract delete(id: number): Promise<void>
   abstract readHead(): Promise<SerializeStrategyHead|null>
   abstract writeHead(head: SerializeStrategyHead): Promise<void>
 
@@ -52,6 +53,10 @@ export class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyAsync<K,
     this.node[id] = node
   }
 
+  async delete(id: number): Promise<void> {
+    delete this.node[id]
+  }
+
   async readHead(): Promise<SerializeStrategyHead|null> {
     if (this.head.root === 0) {
       return null

src/SerializeStrategySync.ts

@@ -6,6 +6,7 @@ export abstract class SerializeStrategySync<K, V> extends SerializeStrategy<K, V
   abstract id(isLeaf: boolean): number
   abstract read(id: number): BPTreeNode<K, V>
   abstract write(id: number, node: BPTreeNode<K, V>): void
+  abstract delete(id: number): void
   abstract readHead(): SerializeStrategyHead|null
   abstract writeHead(head: SerializeStrategyHead): void
 
@@ -52,6 +53,10 @@ export class InMemoryStoreStrategySync<K, V> extends SerializeStrategySync<K, V>
     this.node[id] = node
   }
 
+  delete(id: number): void {
+    delete this.node[id]
+  }
+
   readHead(): SerializeStrategyHead|null {
     if (this.head.root === 0) {
       return null

src/base/BPTree.ts

@@ -61,6 +61,7 @@ export abstract class BPTree<K, V> {
 
   protected readonly _nodeCreateBuffer: Map<number, BPTreeUnknownNode<K, V>>
   protected readonly _nodeUpdateBuffer: Map<number, BPTreeUnknownNode<K, V>>
+  protected readonly _nodeDeleteBuffer: Map<number, BPTreeUnknownNode<K, V>>
 
   protected readonly verifierMap: Record<
     keyof BPTreeCondition<V>,
@@ -120,6 +121,7 @@ export abstract class BPTree<K, V> {
     this._cachedRegexp = new CacheBranchSync()
     this._nodeCreateBuffer = new Map()
     this._nodeUpdateBuffer = new Map()
+    this._nodeDeleteBuffer = new Map()
     this.nodes = new Map()
     this.strategy = strategy
     this.comparator = comparator
@@ -249,14 +251,18 @@ export abstract class BPTree<K, V> {
     }
   }
 
-  protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void> {
+  protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): void {
     this._nodeCreateBuffer.set(node.id, node)
   }
 
-  protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void> {
+  protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): void {
     this._nodeUpdateBuffer.set(node.id, node)
   }
 
+  protected bufferForNodeDelete(node: BPTreeUnknownNode<K, V>): void {
+    this._nodeDeleteBuffer.set(node.id, node)
+  }
+
   /**
    * 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 `{}`.

src/base/SerializeStrategy.ts

@@ -46,6 +46,13 @@ export abstract class SerializeStrategy<K, V> {
    */
   abstract write(id: number, node: BPTreeNode<K, V>): void|Promise<void>
 
+  /**
+   * This method is called when previously created nodes become no longer needed due to deletion or other processes.  
+   * It can be used to free up space by deleting existing stored nodes.
+   * @param id This is the ID of the node to be deleted.
+   */
+  abstract delete(id: number): void|Promise<void>
+
   /**
    * It is called when the `init` method of the tree instance is called.
    * This method should return the information needed to initialize the tree. This information refers to the values stored in the `writeHead` method.

test/unit.test.ts

@@ -14,12 +14,14 @@ import {
 import {
   readFileSync,
   writeFileSync,
+  unlinkSync,
   existsSync,
   mkdirSync,
 } from 'fs'
 import {
   readFile,
   writeFile,
+  unlink
 } from 'fs/promises'
 import { join } from 'path'
 
@@ -518,6 +520,10 @@ class FileIOStrategySync extends SerializeStrategySync<string, number> {
     writeFileSync(this._filePath(id), stringify, 'utf8')
   }
 
+  delete(id: number): void {
+    unlinkSync(this._filePath(id))
+  }
+
   readHead(): SerializeStrategyHead|null {
     const filePath = this._filePath('head')
     if (!existsSync(filePath)) {
@@ -566,6 +572,10 @@ class FileIOStrategyAsync extends SerializeStrategyAsync<string, number> {
     await writeFile(this._filePath(id), stringify, 'utf8')
   }
 
+  async delete(id: number): Promise<void> {
+    await unlink(this._filePath(id))
+  }
+
   async readHead(): Promise<SerializeStrategyHead|null> {
     const filePath = this._filePath('head')
     if (!existsSync(filePath)) {