Changed to using @matrixai/resources for withF and withG

Author: CMCDragonkai

package-lock.json

@@ -22,6 +22,7 @@
   "dependencies": {
     "@matrixai/async-init": "^1.6.0",
     "@matrixai/logger": "^2.1.0",
+    "@matrixai/resources": "^1.0.0",
     "@matrixai/workers": "^1.2.5",
     "abstract-leveldown": "^7.2.0",
     "level": "7.0.1",

package.json

@@ -3,6 +3,7 @@ import type {
   AbstractIteratorOptions,
 } from 'abstract-leveldown';
 import type { LevelDB } from 'level';
+import type { ResourceAcquire } from '@matrixai/resources';
 import type {
   POJO,
   FileSystem,
@@ -12,7 +13,6 @@ import type {
   DBLevel,
   DBIterator,
   DBOps,
-  ResourceAcquire,
 } from './types';
 import level from 'level';
 import subleveldown from 'subleveldown';

src/DB.ts

@@ -71,16 +71,6 @@ type DBOp =
 
 type DBOps = Array<DBOp>;
 
-type ResourceAcquire<Resource = void> = () => Promise<
-  readonly [ResourceRelease, Resource?]
->;
-
-type ResourceRelease = (e?: Error) => Promise<void>;
-
-type Resources<T extends readonly ResourceAcquire<any>[]> = {
-  [K in keyof T]: T[K] extends ResourceAcquire<infer R> ? R : never;
-};
-
 export type {
   POJO,
   FileSystem,
@@ -91,7 +81,4 @@ export type {
   DBIterator,
   DBOp,
   DBOps,
-  ResourceAcquire,
-  ResourceRelease,
-  Resources,
 };

src/types.ts

@@ -1,10 +1,4 @@
-import type {
-  DBDomain,
-  ResourceAcquire,
-  ResourceRelease,
-  Resources,
-} from './types';
-
+import type { DBDomain } from './types';
 import sublevelprefixer from 'sublevel-prefixer';
 import * as dbErrors from './errors';
 
@@ -56,83 +50,11 @@ function fromArrayBuffer(
   return Buffer.from(b, offset, length);
 }
 
-/**
- * Make sure to explicitly declare or cast `acquires` as a tuple using `[ResourceAcquire...]` or `as const`
- */
-async function withF<
-  ResourceAcquires extends
-    | readonly [ResourceAcquire<unknown>]
-    | readonly ResourceAcquire<unknown>[],
-  T,
->(
-  acquires: ResourceAcquires,
-  f: (resources: Resources<ResourceAcquires>) => Promise<T>,
-): Promise<T> {
-  const releases: Array<ResourceRelease> = [];
-  const resources: Array<unknown> = [];
-  let e_: Error | undefined;
-  try {
-    for (const acquire of acquires) {
-      const [release, resource] = await acquire();
-      releases.push(release);
-      resources.push(resource);
-    }
-    return await f(resources as unknown as Resources<ResourceAcquires>);
-  } catch (e) {
-    e_ = e;
-    throw e;
-  } finally {
-    releases.reverse();
-    for (const release of releases) {
-      await release(e_);
-    }
-  }
-}
-
-/**
- * Make sure to explicitly declare or cast `acquires` as a tuple using `[ResourceAcquire...]` or `as const`
- */
-async function* withG<
-  ResourceAcquires extends
-    | readonly [ResourceAcquire<unknown>]
-    | readonly ResourceAcquire<unknown>[],
-  T = unknown,
-  TReturn = any,
-  TNext = unknown,
->(
-  acquires: ResourceAcquires,
-  g: (
-    resources: Resources<ResourceAcquires>,
-  ) => AsyncGenerator<T, TReturn, TNext>,
-): AsyncGenerator<T, TReturn, TNext> {
-  const releases: Array<ResourceRelease> = [];
-  const resources: Array<unknown> = [];
-  let e_: Error | undefined;
-  try {
-    for (const acquire of acquires) {
-      const [release, resource] = await acquire();
-      releases.push(release);
-      resources.push(resource);
-    }
-    return yield* g(resources as unknown as Resources<ResourceAcquires>);
-  } catch (e) {
-    e_ = e;
-    throw e;
-  } finally {
-    releases.reverse();
-    for (const release of releases) {
-      await release(e_);
-    }
-  }
-}
-
 export {
   prefix,
   domainPath,
   serialize,
   deserialize,
   toArrayBuffer,
   fromArrayBuffer,
-  withF,
-  withG,
 };

src/utils.ts

@@ -2,6 +2,7 @@ import os from 'os';
 import path from 'path';
 import fs from 'fs';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
+import { withF } from '@matrixai/resources';
 import DB from '@/DB';
 import DBTransaction from '@/DBTransaction';
 import * as utils from '@/utils';
@@ -53,7 +54,7 @@ describe(DBTransaction.name, () => {
     expect(await db.dump(db.transactionsDb)).toStrictEqual({});
   });
   test('get, put and del', async () => {
-    const p = utils.withF([db.transaction()], async ([tran]) => {
+    const p = withF([db.transaction()], async ([tran]) => {
       expect(await tran.get([], 'foo')).toBeUndefined();
       // Add foo -> bar to the transaction
       await tran.put([], 'foo', 'bar');
@@ -83,19 +84,19 @@ describe(DBTransaction.name, () => {
     expect(await db.dump(db.transactionsDb)).toStrictEqual({});
   });
   test('no dirty reads', async () => {
-    await utils.withF([db.transaction()], async ([tran1]) => {
+    await withF([db.transaction()], async ([tran1]) => {
       expect(await tran1.get([], 'hello')).toBeUndefined();
-      await utils.withF([db.transaction()], async ([tran2]) => {
+      await withF([db.transaction()], async ([tran2]) => {
         await tran2.put([], 'hello', 'world');
         // `tran2` has not yet committed
         expect(await tran1.get([], 'hello')).toBeUndefined();
       });
     });
     await db.clear();
-    await utils.withF([db.transaction()], async ([tran1]) => {
+    await withF([db.transaction()], async ([tran1]) => {
       expect(await tran1.get([], 'hello')).toBeUndefined();
       await tran1.put([], 'hello', 'foo');
-      await utils.withF([db.transaction()], async ([tran2]) => {
+      await withF([db.transaction()], async ([tran2]) => {
         // `tran1` has not yet committed
         expect(await tran2.get([], 'hello')).toBeUndefined();
         await tran2.put([], 'hello', 'bar');
@@ -105,19 +106,19 @@ describe(DBTransaction.name, () => {
     });
   });
   test('non-repeatable reads', async () => {
-    await utils.withF([db.transaction()], async ([tran1]) => {
+    await withF([db.transaction()], async ([tran1]) => {
       expect(await tran1.get([], 'hello')).toBeUndefined();
-      await utils.withF([db.transaction()], async ([tran2]) => {
+      await withF([db.transaction()], async ([tran2]) => {
         await tran2.put([], 'hello', 'world');
       });
       // `tran2` is now committed
       expect(await tran1.get([], 'hello')).toBe('world');
     });
     await db.clear();
-    await utils.withF([db.transaction()], async ([tran1]) => {
+    await withF([db.transaction()], async ([tran1]) => {
       expect(await tran1.get([], 'hello')).toBeUndefined();
       await tran1.put([], 'hello', 'foo');
-      await utils.withF([db.transaction()], async ([tran2]) => {
+      await withF([db.transaction()], async ([tran2]) => {
         // `tran1` has not yet committed
         expect(await tran2.get([], 'hello')).toBeUndefined();
         await tran2.put([], 'hello', 'bar');
@@ -132,7 +133,7 @@ describe(DBTransaction.name, () => {
     await db.put([], '2', '2');
     await db.put([], '3', '3');
     let rows: Array<[string, string]>;
-    await utils.withF([db.transaction()], async ([tran1]) => {
+    await withF([db.transaction()], async ([tran1]) => {
       rows = [];
       for await (const [k, v] of await tran1.iterator()) {
         rows.push([k.toString(), JSON.parse(v.toString())]);
@@ -142,7 +143,7 @@ describe(DBTransaction.name, () => {
         ['2', '2'],
         ['3', '3'],
       ]);
-      await utils.withF([db.transaction()], async ([tran2]) => {
+      await withF([db.transaction()], async ([tran2]) => {
         await tran2.del([], '1');
         await tran2.put([], '4', '4');
         rows = [];
@@ -167,9 +168,9 @@ describe(DBTransaction.name, () => {
     });
   });
   test('lost updates', async () => {
-    await utils.withF([db.transaction()], async ([tran1]) => {
+    await withF([db.transaction()], async ([tran1]) => {
       await tran1.put([], 'hello', 'foo');
-      await utils.withF([db.transaction()], async ([tran2]) => {
+      await withF([db.transaction()], async ([tran2]) => {
         await tran2.put([], 'hello', 'bar');
       });
       expect(await tran1.get([], 'hello')).toBe('foo');
@@ -200,7 +201,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
     await db.put([], 'k', 'k');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -247,7 +248,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
     await db.put([], 'k', 'k');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -294,7 +295,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'd', 'd');
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -337,7 +338,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'd', 'd');
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -380,7 +381,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'd', 'd');
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -419,7 +420,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'd', 'd');
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -464,7 +465,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
     await db.put([], 'k', 'k');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -510,7 +511,7 @@ describe(DBTransaction.name, () => {
     await db.put([], 'e', 'e');
     await db.put([], 'h', 'h');
     await db.put([], 'k', 'k');
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       await tran.put([], 'a', '1');
       await tran.put([], 'c', '3');
       await tran.put([], 'e', '5');
@@ -558,7 +559,7 @@ describe(DBTransaction.name, () => {
       results.push(2);
     });
     const mockFailure = jest.fn();
-    await utils.withF([db.transaction()], async ([tran]) => {
+    await withF([db.transaction()], async ([tran]) => {
       tran.queueSuccess(mockSuccess1);
       tran.queueSuccess(mockSuccess2);
       tran.queueFailure(mockFailure);
@@ -578,7 +579,7 @@ describe(DBTransaction.name, () => {
       results.push(2);
     });
     await expect(
-      utils.withF([db.transaction()], async ([tran]) => {
+      withF([db.transaction()], async ([tran]) => {
         tran.queueSuccess(mockSuccess);
         tran.queueFailure(mockFailure1);
         tran.queueFailure(mockFailure2);
@@ -595,7 +596,7 @@ describe(DBTransaction.name, () => {
     await db.put([], '2', 'b');
     const mockFailure = jest.fn();
     await expect(
-      utils.withF([db.transaction()], async ([tran]) => {
+      withF([db.transaction()], async ([tran]) => {
         await tran.put([], '1', '1');
         await tran.put([], '2', '2');
         tran.queueFailure(mockFailure);