WIP

Author: CMCDragonkai

src/DB.ts

@@ -1,4 +1,7 @@
-import type { AbstractBatch, AbstractIteratorOptions } from 'abstract-leveldown';
+import type {
+  AbstractBatch,
+  AbstractIteratorOptions,
+} from 'abstract-leveldown';
 import type { LevelDB } from 'level';
 import type { ResourceAcquire } from '@matrixai/resources';
 import type {
@@ -209,14 +212,8 @@ class DB {
    * Get from root level
    * @internal
    */
-  public async _get<T>(
-    keyPath: KeyPath,
-    raw?: false,
-  ): Promise<T | undefined>;
-  public async _get(
-    keyPath: KeyPath,
-    raw: true,
-  ): Promise<Buffer | undefined>;
+  public async _get<T>(keyPath: KeyPath, raw?: false): Promise<T | undefined>;
+  public async _get(keyPath: KeyPath, raw: true): Promise<Buffer | undefined>;
   public async _get<T>(
     keyPath: KeyPath,
     raw: boolean = false,
@@ -268,16 +265,8 @@ class DB {
    * Put from root level
    * @internal
    */
-  public async _put(
-    keyPath: KeyPath,
-    value: any,
-    raw?: false,
-  ): Promise<void>;
-  public async _put(
-    keyPath: KeyPath,
-    value: Buffer,
-    raw: true,
-  ): Promise<void>;
+  public async _put(keyPath: KeyPath, value: any, raw?: false): Promise<void>;
+  public async _put(keyPath: KeyPath, value: Buffer, raw: true): Promise<void>;
   public async _put(
     keyPath: KeyPath,
     value: any,
@@ -443,13 +432,15 @@ class DB {
     if (options.gt != null) {
       options.gt = Buffer.concat([
         levelKeyStart,
-        (typeof options.gt === 'string') ? Buffer.from(options.gt) : options.gt
+        typeof options.gt === 'string' ? Buffer.from(options.gt) : options.gt,
       ]);
     }
     if (options.gte != null) {
       options.gte = Buffer.concat([
         levelKeyStart,
-        (typeof options.gte === 'string') ? Buffer.from(options.gte) : options.gte
+        typeof options.gte === 'string'
+          ? Buffer.from(options.gte)
+          : options.gte,
       ]);
     }
     if (options.gt == null && options.gte == null) {
@@ -458,13 +449,15 @@ class DB {
     if (options?.lt != null) {
       options.lt = Buffer.concat([
         levelKeyStart,
-        (typeof options.lt === 'string') ? Buffer.from(options.lt) : options.lt
+        typeof options.lt === 'string' ? Buffer.from(options.lt) : options.lt,
       ]);
     }
     if (options?.lte != null) {
       options.lte = Buffer.concat([
         levelKeyStart,
-        (typeof options.lte === 'string') ? Buffer.from(options.lte) : options.lte
+        typeof options.lte === 'string'
+          ? Buffer.from(options.lte)
+          : options.lte,
       ]);
     }
     if (options.lt == null && options.lte == null) {
@@ -477,11 +470,7 @@ class DB {
     const next = iterator.next.bind(iterator);
     // @ts-ignore AbstractIterator type is outdated
     iterator.seek = (k: Buffer | string): void => {
-      seek(
-        utils.keyPathToKey(
-          [...levelPath, k] as unknown as KeyPath
-        )
-      );
+      seek(utils.keyPathToKey([...levelPath, k] as unknown as KeyPath));
     };
     // @ts-ignore AbstractIterator type is outdated
     iterator.next = async () => {
@@ -492,9 +481,7 @@ class DB {
         if (kv[0] != null) {
           // Truncate level path so the returned key is relative to the level path
           const keyPath = utils.parseKey(kv[0]).slice(levelPath.length);
-          kv[0] = utils.keyPathToKey(
-            keyPath as unknown as KeyPath
-          );
+          kv[0] = utils.keyPathToKey(keyPath as unknown as KeyPath);
         }
         // Handle values: false
         if (kv[1] != null) {
@@ -511,9 +498,7 @@ class DB {
    * This is not atomic, it will iterate over a snapshot of the DB
    */
   @ready(new errors.ErrorDBNotRunning())
-  public async clear(
-    levelPath: LevelPath = [],
-  ): Promise<void> {
+  public async clear(levelPath: LevelPath = []): Promise<void> {
     levelPath = ['data', ...levelPath];
     if (utils.checkSepLevelPath(levelPath)) {
       throw new errors.ErrorDBLevelSep();
@@ -525,10 +510,7 @@ class DB {
    * Clear from root level
    * @internal
    */
-  public async _clear(
-    db: LevelDB,
-    levelPath: LevelPath = [],
-  ): Promise<void> {
+  public async _clear(db: LevelDB, levelPath: LevelPath = []): Promise<void> {
     for await (const [k] of this._iterator(db, { values: false }, levelPath)) {
       await db.del(utils.keyPathToKey([...levelPath, k] as unknown as KeyPath));
     }
@@ -547,10 +529,19 @@ class DB {
    * Dump from root level
    * It is intended for diagnostics
    */
-  public async dump(levelPath?: LevelPath, raw?: false): Promise<Array<[string, any]>>;
-  public async dump(levelPath: LevelPath | undefined, raw: true): Promise<Array<[Buffer, Buffer]>>;
+  public async dump(
+    levelPath?: LevelPath,
+    raw?: false,
+  ): Promise<Array<[string, any]>>;
+  public async dump(
+    levelPath: LevelPath | undefined,
+    raw: true,
+  ): Promise<Array<[Buffer, Buffer]>>;
   @ready(new errors.ErrorDBNotRunning())
-  public async dump(levelPath: LevelPath = [], raw: boolean = false): Promise<Array<[string | Buffer, any]>> {
+  public async dump(
+    levelPath: LevelPath = [],
+    raw: boolean = false,
+  ): Promise<Array<[string | Buffer, any]>> {
     if (utils.checkSepLevelPath(levelPath)) {
       throw new errors.ErrorDBLevelSep();
     }

src/DBTransaction.ts

@@ -117,7 +117,7 @@ class DBTransaction {
     }
     let value = await this.db._get<T>(
       [...this.transactionPath, ...keyPath] as unknown as KeyPath,
-      raw as any
+      raw as any,
     );
     if (value === undefined) {
       value = await this.db.get<T>(keyPath, raw as any);
@@ -152,7 +152,7 @@ class DBTransaction {
     await this.db._put(
       [...this.transactionPath, ...keyPath] as unknown as KeyPath,
       value,
-      raw as any
+      raw as any,
     );
     this._ops.push({
       type: 'put',
@@ -170,10 +170,13 @@ class DBTransaction {
     if (utils.checkSepKeyPath(keyPath as KeyPath)) {
       throw new errors.ErrorDBLevelSep();
     }
-    await this.db._del([...this.transactionPath, ...keyPath] as unknown as KeyPath);
+    await this.db._del([
+      ...this.transactionPath,
+      ...keyPath,
+    ] as unknown as KeyPath);
     this._ops.push({
       type: 'del',
-      keyPath
+      keyPath,
     });
   }
 
@@ -196,17 +199,17 @@ class DBTransaction {
         ...options,
         keys: true,
         keyAsBuffer: true,
-        valueAsBuffer: true
+        valueAsBuffer: true,
       },
-      ['data', ...levelPath]
+      ['data', ...levelPath],
     );
     const tranIterator = this.db._iterator(
       this.db.db,
       {
         ...options,
         keys: true,
         keyAsBuffer: true,
-        valueAsBuffer: true
+        valueAsBuffer: true,
       },
       [...this.transactionPath, ...levelPath],
     );
@@ -307,9 +310,7 @@ class DBTransaction {
   }
 
   @ready(new errors.ErrorDBTransactionDestroyed())
-  public async clear(
-    levelPath: LevelPath = [],
-  ): Promise<void> {
+  public async clear(levelPath: LevelPath = []): Promise<void> {
     for await (const [k] of await this.iterator({ values: false }, levelPath)) {
       await this.del([...levelPath, k] as unknown as KeyPath);
     }
@@ -328,14 +329,23 @@ class DBTransaction {
    * Dump from transaction level
    * It is intended for diagnostics
    */
-  public async dump(levelPath?: LevelPath, raw?: false): Promise<Array<[string, any]>>;
-  public async dump(levelPath: LevelPath | undefined, raw: true): Promise<Array<[Buffer, Buffer]>>;
+  public async dump(
+    levelPath?: LevelPath,
+    raw?: false,
+  ): Promise<Array<[string, any]>>;
+  public async dump(
+    levelPath: LevelPath | undefined,
+    raw: true,
+  ): Promise<Array<[Buffer, Buffer]>>;
   @ready(new errors.ErrorDBTransactionDestroyed())
-  public async dump(levelPath: LevelPath = [], raw: boolean = false): Promise<Array<[string | Buffer, any]>> {
-    return await this.db.dump([
-      ...this.transactionPath,
-      ...levelPath
-    ], raw as any);
+  public async dump(
+    levelPath: LevelPath = [],
+    raw: boolean = false,
+  ): Promise<Array<[string | Buffer, any]>> {
+    return await this.db.dump(
+      [...this.transactionPath, ...levelPath],
+      raw as any,
+    );
   }
 
   @ready(new errors.ErrorDBTransactionDestroyed())

src/utils.ts

@@ -20,7 +20,7 @@ function keyPathToKey(keyPath: KeyPath): Buffer {
   const levelPath = keyPath.slice(0, -1);
   return Buffer.concat([
     levelPathToKey(levelPath),
-    (typeof keyPart === 'string') ? Buffer.from(keyPart, 'utf-8') : keyPart
+    typeof keyPart === 'string' ? Buffer.from(keyPart, 'utf-8') : keyPart,
   ]);
 }
 
@@ -31,11 +31,13 @@ function keyPathToKey(keyPath: KeyPath): Buffer {
  */
 function levelPathToKey(levelPath: LevelPath): Buffer {
   return Buffer.concat(
-    levelPath.map((p) => Buffer.concat([
-      sep,
-      (typeof p === 'string') ? Buffer.from(p, 'utf-8') : p,
-      sep
-    ]))
+    levelPath.map((p) =>
+      Buffer.concat([
+        sep,
+        typeof p === 'string' ? Buffer.from(p, 'utf-8') : p,
+        sep,
+      ]),
+    ),
   );
 }
 
@@ -53,7 +55,7 @@ function levelPathToKey(levelPath: LevelPath): Buffer {
  */
 function parseKey(key: Buffer): KeyPath {
   const [bufs] = parsePath(key);
-  if (!isNonEmptyArray(bufs))  {
+  if (!isNonEmptyArray(bufs)) {
     throw new TypeError('Buffer is not a key');
   }
   return bufs;
@@ -73,13 +75,16 @@ function parsePath(input: Buffer): [Array<Buffer>, Buffer] {
     let output: Array<Buffer> = [];
     let input_: Buffer = input;
     let output_: Array<Buffer>;
+    // eslint-disable-next-line prefer-const
     [output_, input_] = parseKeyActual(input_);
     output = output.concat(output_);
     return [output, input_];
   }
-};
+}
 
-function parseLevels(input: Buffer): [output: Array<Buffer>, remaining: Buffer] {
+function parseLevels(
+  input: Buffer,
+): [output: Array<Buffer>, remaining: Buffer] {
   let output: Array<Buffer> = [];
   try {
     let input_: Buffer = input;
@@ -93,7 +98,7 @@ function parseLevels(input: Buffer): [output: Array<Buffer>, remaining: Buffer]
   } catch (e) {
     return [[], input];
   }
-};
+}
 
 function parseLevel(input: Buffer): [Array<Buffer>, Buffer] {
   const sepStart = input.indexOf(sep);
@@ -108,14 +113,14 @@ function parseLevel(input: Buffer): [Array<Buffer>, Buffer] {
   const remaining = input.subarray(sepEnd + 1);
 
   return [[level], remaining];
-};
+}
 
 function parseKeyActual(input: Buffer): [Array<Buffer>, Buffer] {
   if (input.byteLength < 1) {
     throw new errors.ErrorDBParseKey('Key cannot be empty');
   }
   return [[input], input.subarray(input.byteLength)];
-};
+}
 
 /**
  * Checks if the KeyPath contains the separator
@@ -137,7 +142,7 @@ function checkSepLevelPath(levelPath: LevelPath): boolean {
  * Checks if the separator exists in a string or buffer
  * This only needs to applied to the LevelPath, not the final key
  */
-function sepExists (data: string | Buffer): boolean {
+function sepExists(data: string | Buffer): boolean {
   if (typeof data === 'string') {
     return data.includes(sep.toString('utf-8'));
   } else {