Implemented DBTransaction.clear

Author: CMCDragonkai

src/DB.ts

@@ -468,6 +468,8 @@ class DB {
   }> {
     const dataDb = await this._level('data', db);
     const transactionsDb = await this._level('transactions', db);
+    // Clear any dirty state in the transactions
+    await transactionsDb.clear();
     return {
       dataDb,
       transactionsDb,

src/DBTransaction.ts

@@ -117,15 +117,6 @@ class DBTransaction {
     return records;
   }
 
-  @ready(new dbErrors.ErrorDBTransactionDestroyed())
-  public async count(domain: DBDomain = []): Promise<number> {
-    let count = 0;
-    for await (const _ of await this.iterator(undefined, domain)) {
-      count++;
-    }
-    return count;
-  }
-
   public async iterator(
     options: AbstractIteratorOptions & { values: false },
     domain?: DBDomain,
@@ -268,6 +259,22 @@ class DBTransaction {
     return iterator;
   }
 
+  @ready(new dbErrors.ErrorDBTransactionDestroyed())
+  public async clear(domain: DBDomain = []): Promise<void> {
+    for await (const [k] of await this.iterator({ values: false }, domain)) {
+      await this.del(domain, k);
+    }
+  }
+
+  @ready(new dbErrors.ErrorDBTransactionDestroyed())
+  public async count(domain: DBDomain = []): Promise<number> {
+    let count = 0;
+    for await (const _ of await this.iterator({ values: false }, domain)) {
+      count++;
+    }
+    return count;
+  }
+
   public async get<T>(
     domain: DBDomain,
     key: string | Buffer,

tests/DBTransaction.test.ts

@@ -83,6 +83,40 @@ describe(DBTransaction.name, () => {
     // Transaction state is cleared
     expect(await db.dump(db.transactionsDb)).toStrictEqual({});
   });
+  test('transactional clear', async () => {
+    await db.put([], '1', '1');
+    await db.put([], '2', '2');
+    await db.put([], '3', '3');
+    await withF([db.transaction()], async ([tran]) => {
+      await tran.clear();
+    });
+    expect(await db.dump()).toStrictEqual({});
+    await db.clear();
+    await db.put([], '1', '1');
+    await db.put(['level1'], '2', '2');
+    await db.put(['level1', 'level2'], '3', '3');
+    await withF([db.transaction()], async ([tran]) => {
+      await tran.clear(['level1']);
+    });
+    expect(await db.dump()).toStrictEqual({
+      '1': '1',
+    });
+  });
+  test('transactional count', async () => {
+    await db.put([], '1', '1');
+    await db.put([], '2', '2');
+    await db.put([], '3', '3');
+    await withF([db.transaction()], async ([tran]) => {
+      expect(await tran.count()).toBe(3);
+    });
+    await db.clear();
+    await db.put([], '1', '1');
+    await db.put(['level1'], '2', '2');
+    await db.put(['level1', 'level2'], '3', '3');
+    await withF([db.transaction()], async ([tran]) => {
+      expect(await tran.count(['level1'])).toBe(2);
+    });
+  });
   test('no dirty reads', async () => {
     await withF([db.transaction()], async ([tran1]) => {
       expect(await tran1.get([], 'hello')).toBeUndefined();