WIP

Author: CMCDragonkai

src/DBTransaction.ts

@@ -1,5 +1,8 @@
 import type { ResourceRelease } from '@matrixai/resources';
-import type { LockBox, MultiLockRequest as AsyncLocksMultiLockRequest } from '@matrixai/async-locks';
+import type {
+  LockBox,
+  MultiLockRequest as AsyncLocksMultiLockRequest,
+} from '@matrixai/async-locks';
 import type DB from './DB';
 import type {
   ToString,
@@ -31,11 +34,14 @@ class DBTransaction {
   protected _db: DB;
   protected logger: Logger;
   protected lockBox: LockBox<RWLockWriter>;
-  protected _locks: Map<string, {
-    lock: RWLockWriter,
-    type: 'read' | 'write',
-    release: ResourceRelease,
-  }> = new Map();
+  protected _locks: Map<
+    string,
+    {
+      lock: RWLockWriter;
+      type: 'read' | 'write';
+      release: ResourceRelease;
+    }
+  > = new Map();
   protected _options: RocksDBTransactionOptions;
   protected _transaction: RocksDBTransaction;
   protected _snapshot: RocksDBTransactionSnapshot;
@@ -118,11 +124,14 @@ class DBTransaction {
     return this._rollbacked;
   }
 
-  get locks(): ReadonlyMap<string, {
-    lock: RWLockWriter,
-    type: 'read' | 'write',
-    release: ResourceRelease,
-  }> {
+  get locks(): ReadonlyMap<
+    string,
+    {
+      lock: RWLockWriter;
+      type: 'read' | 'write';
+      release: ResourceRelease;
+    }
+  > {
     return this._locks;
   }
 
@@ -146,15 +155,17 @@ class DBTransaction {
    * There is no support for lock upgrading or downgrading
    * There is no deadlock detection
    */
-  public async lock(...requests: Array<MultiLockRequest | string>): Promise<void> {
+  public async lock(
+    ...requests: Array<MultiLockRequest | string>
+  ): Promise<void> {
     const requests_: Array<AsyncLocksMultiLockRequest<RWLockWriter>> = [];
     for (const request of requests) {
       if (Array.isArray(request)) {
         const [key, ...lockingParams] = request;
         const key_ = key.toString();
         const lock = this._locks.get(key_);
         // Default the lock type to `write`
-        const lockType = lockingParams[0] = lockingParams[0] ?? 'write';
+        const lockType = (lockingParams[0] = lockingParams[0] ?? 'write');
         if (lock == null) {
           requests_.push([key_, RWLockWriter, ...lockingParams]);
         } else if (lock.type !== lockType) {

src/errors.ts

@@ -83,7 +83,8 @@ class ErrorDBTransactionConflict<T> extends ErrorDBTransaction<T> {
 }
 
 class ErrorDBTransactionLockType<T> extends ErrorDBTransaction<T> {
-  static description = 'DBTransaction does not support upgrading or downgrading the lock type';
+  static description =
+    'DBTransaction does not support upgrading or downgrading the lock type';
 }
 
 export {

src/types.ts

@@ -161,7 +161,7 @@ type DBOps = Array<DBOp>;
 
 type MultiLockRequest = [
   key: ToString,
-  ...lockingParams: Parameters<RWLockWriter['lock']>
+  ...lockingParams: Parameters<RWLockWriter['lock']>,
 ];
 
 export type {
@@ -182,5 +182,5 @@ export type {
   DBBatch,
   DBOp,
   DBOps,
-  MultiLockRequest
+  MultiLockRequest,
 };

tests/DBTransaction.test.ts

@@ -1019,11 +1019,17 @@ describe(DBTransaction.name, () => {
       await tran1.lock(['foo', 'read']);
       await tran1.lock(['bar', 'write']);
       // There is no automatic lock upgrade or downgrade
-      await expect(tran1.lock(['foo', 'write'])).rejects.toThrow(errors.ErrorDBTransactionLockType);
-      await expect(tran1.lock(['bar', 'read'])).rejects.toThrow(errors.ErrorDBTransactionLockType);
+      await expect(tran1.lock(['foo', 'write'])).rejects.toThrow(
+        errors.ErrorDBTransactionLockType,
+      );
+      await expect(tran1.lock(['bar', 'read'])).rejects.toThrow(
+        errors.ErrorDBTransactionLockType,
+      );
       await db.withTransactionF(async (tran2) => {
         await tran2.lock(['foo', 'read']);
-        await expect(tran2.lock(['bar', 'write', 0])).rejects.toThrow(locksErrors.ErrorAsyncLocksTimeout);
+        await expect(tran2.lock(['bar', 'write', 0])).rejects.toThrow(
+          locksErrors.ErrorAsyncLocksTimeout,
+        );
         expect(tran1.locks.size).toBe(2);
         expect(tran1.locks.has('foo')).toBe(true);
         expect(tran1.locks.get('foo')!.type).toBe('read');
@@ -1048,7 +1054,7 @@ describe(DBTransaction.name, () => {
     });
   });
   test('locks are unlocked in reverse order', async () => {
-    let order: Array<string> = [];
+    const order: Array<string> = [];
     let p1, p2;
     await db.withTransactionF(async (tran) => {
       // '1' and '2' are in sort order
@@ -1083,7 +1089,9 @@ describe(DBTransaction.name, () => {
         // This is a noop, because `tran1` owns `key1` and `key2`
         await tran2.unlock('key1', 'key2');
         // This fails because `key1` is still locked by `tran1`
-        await expect(tran2.lock(['key1', 'write', 0])).rejects.toThrow(locksErrors.ErrorAsyncLocksTimeout);
+        await expect(tran2.lock(['key1', 'write', 0])).rejects.toThrow(
+          locksErrors.ErrorAsyncLocksTimeout,
+        );
         await tran1.unlock('key1');
         expect(tran1.locks.size).toBe(1);
         // This succeeds because `key1` is now unlocked
@@ -1093,9 +1101,9 @@ describe(DBTransaction.name, () => {
         await tran1.unlock('key1');
         expect(tran2.locks.has('key1')).toBe(true);
         expect(tran1.locks.has('key1')).toBe(false);
-        await expect(tran1.lock([
-          'key1', 'write', 0
-        ])).rejects.toThrow(locksErrors.ErrorAsyncLocksTimeout);
+        await expect(tran1.lock(['key1', 'write', 0])).rejects.toThrow(
+          locksErrors.ErrorAsyncLocksTimeout,
+        );
       });
       await tran1.lock('key1');
       expect(tran1.locks.has('key1')).toBe(true);
@@ -1113,9 +1121,12 @@ describe(DBTransaction.name, () => {
         const p1 = tran1.lock(['bar', 'write', 50]);
         const p2 = tran2.lock(['foo', 'write', 50]);
         const results = await Promise.allSettled([p1, p2]);
-        expect(results.every(r =>
-          r.status === 'rejected' &&
-          r.reason instanceof locksErrors.ErrorAsyncLocksTimeout)
+        expect(
+          results.every(
+            (r) =>
+              r.status === 'rejected' &&
+              r.reason instanceof locksErrors.ErrorAsyncLocksTimeout,
+          ),
         ).toBe(true);
       });
     });