@milaboratories/pl-drivers 1.6.12 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-drivers",
-  "version": "1.6.12",
+  "version": "1.7.0",
   "engines": {
     "node": ">=20"
   },
@@ -31,12 +31,12 @@
     "undici": "~7.10.0",
     "zod": "~3.23.8",
     "upath": "^2.0.1",
-    "@milaboratories/ts-helpers": "^1.4.2",
     "@milaboratories/helpers": "^1.6.19",
     "@milaboratories/computable": "^2.6.2",
+    "@milaboratories/ts-helpers": "^1.4.2",
     "@milaboratories/pl-tree": "^1.7.4",
-    "@milaboratories/pl-model-common": "^1.17.0",
-    "@milaboratories/pl-client": "^2.11.5"
+    "@milaboratories/pl-client": "^2.11.5",
+    "@milaboratories/pl-model-common": "^1.19.0"
   },
   "devDependencies": {
     "eslint": "^9.25.1",
@@ -47,8 +47,8 @@
     "vitest": "^2.1.9",
     "@vitest/coverage-v8": "^2.1.9",
     "@types/tar-fs": "^2.0.4",
-    "@milaboratories/eslint-config": "^1.0.4",
-    "@milaboratories/build-configs": "1.0.5"
+    "@milaboratories/build-configs": "1.0.5",
+    "@milaboratories/eslint-config": "^1.0.4"
   },
   "scripts": {
     "type-check": "tsc --noEmit --composite false",

package/src/drivers/download_blob_url/driver.ts

@@ -11,14 +11,14 @@ import * as path from 'node:path';
 import { FilesCache } from '../helpers/files_cache';
 import type { ResourceId } from '@milaboratories/pl-client';
 import { resourceIdToString, stringifyWithResourceId } from '@milaboratories/pl-client';
-import type { ArchiveFormat, BlobToURLDriver, FolderURL } from '@milaboratories/pl-model-common';
+import { type ArchiveFormat, type BlobToURLDriver, type FolderURL, isFolderURL } from '@milaboratories/pl-model-common';
 import type { DownloadableBlobSnapshot } from './snapshot';
 import { makeDownloadableBlobSnapshot } from './snapshot';
 import type { PlTreeEntry } from '@milaboratories/pl-tree';
 import { isPlTreeEntry } from '@milaboratories/pl-tree';
 import { DownloadAndUnarchiveTask, rmRFDir } from './task';
 import type { ClientDownload } from '../../clients/download';
-import { getPathForFolderURL, isFolderURL } from './url';
+import { getPathForFolderURL } from '../urls/url';
 import type { Id } from './driver_id';
 import { newId } from './driver_id';
 import { nonRecoverableError } from '../download_blob/download_blob_task';

package/src/drivers/download_blob_url/task.ts

@@ -12,7 +12,7 @@ import { CallersCounter, createPathAtomically, ensureDirExists, fileExists, notE
 import type { DownloadableBlobSnapshot } from './snapshot';
 import { UnknownStorageError, WrongLocalFileUrl, type ClientDownload } from '../../clients/download';
 import type { ArchiveFormat, FolderURL } from '@milaboratories/pl-model-common';
-import { newFolderURL } from './url';
+import { newFolderURL } from '../urls/url';
 import decompress from 'decompress';
 import { assertNever } from '@protobuf-ts/runtime';
 import { resourceIdToString, stringifyWithResourceId } from '@milaboratories/pl-client';

package/src/drivers/download_blob_url/url.ts

@@ -1,43 +0,0 @@
-import type { FolderURL } from '@milaboratories/pl-model-common';
-import { ArchiveFormat } from '@milaboratories/pl-model-common';
-import type { Signer } from '@milaboratories/ts-helpers';
-import path from 'path';
-
-export function newFolderURL(signer: Signer, saveDir: string, fPath: string): FolderURL {
-  const p = path.relative(saveDir, fPath);
-  const sign = signer.sign(p);
-
-  return `plblob+folder://${sign}.${p}.blob`;
-}
-
-export function isFolderURL(url: string): url is FolderURL {
-  const parsed = new URL(url);
-  return parsed.protocol == 'plblob+folder:';
-}
-
-export function getPathForFolderURL(signer: Signer, url: FolderURL, rootDir: string): string {
-  const parsed = new URL(url);
-  const [sign, subfolder, _] = parsed.host.split('.');
-
-  signer.verify(subfolder, sign, `signature verification failed for url: ${url}, subfolder: ${subfolder}`);
-
-  let fPath = parseValidPath(path.join(rootDir, `${subfolder}`), parsed.pathname.slice(1));
-
-  if (parsed.pathname == '' || parsed.pathname == '/')
-    fPath = path.join(fPath, 'index.html');
-
-  return path.resolve(fPath);
-}
-
-/** Checks that the userInputPath is in baseDir and returns an absolute path. */
-function parseValidPath(baseDir: string, userInputPath: string): string {
-  const absolutePath = path.resolve(baseDir, userInputPath);
-
-  const normalizedBase = path.resolve(baseDir);
-
-  if (!absolutePath.startsWith(normalizedBase)) {
-    throw new Error('Path validation failed.');
-  }
-
-  return absolutePath;
-}

package/src/drivers/{download_url.test.ts → download_url/driver.test.ts}

@@ -1,38 +1,41 @@
 import { TestHelpers } from '@milaboratories/pl-client';
-import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
+import { ConsoleLoggerAdapter, HmacSha256Signer } from '@milaboratories/ts-helpers';
 import * as os from 'node:os';
 import { text } from 'node:stream/consumers';
 import { Readable } from 'node:stream';
 import * as fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
-import { DownloadUrlDriver } from './download_url';
+import { DownloadUrlDriver } from './driver';
 import { test, expect } from 'vitest';
 
 test('should download a tar archive and extracts its content and then deleted', async () => {
   await TestHelpers.withTempRoot(async (client) => {
     const logger = new ConsoleLoggerAdapter();
     const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'test1-'));
-    const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir);
+    const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir, genSigner());
 
     const url = new URL(
       'https://block.registry.platforma.bio/releases/v1/milaboratory/enter-numbers/0.4.1/frontend.tgz',
     );
 
-    const c = driver.getPath(url);
+    const c = driver.getUrl(url);
 
-    const path1 = await c.getValue();
-    expect(path1).toBeUndefined();
+    const url1 = await c.getValue();
+    expect(url1).toBeUndefined();
 
     await c.awaitChange();
 
-    const path2 = await c.getValue();
-    expect(path2).not.toBeUndefined();
-    expect(path2?.error).toBeUndefined();
-    expect(path2?.path).not.toBeUndefined();
+    const url2 = await c.getValue();
+    expect(url2).not.toBeUndefined();
+    expect(url2?.error).toBeUndefined();
+    expect(url2?.url).not.toBeUndefined();
 
-    console.log('frontend saved to dir: ', path2);
-    const indexJs = fs.createReadStream(path.join(path2!.path!, 'index.js'));
+    console.log('frontend saved to dir by url: ', url2);
+    const u = new URL(url2!.url!);
+    u.pathname = 'index.js';
+    const ui = driver.getPathForBlockUI(u.toString());
+    const indexJs = fs.createReadStream(ui);
     const indexJsCode = await text(Readable.toWeb(indexJs));
     expect(indexJsCode).toContain('use strict');
 
@@ -45,22 +48,22 @@ test('should show a error when 404 status code', async () => {
     await TestHelpers.withTempRoot(async (client) => {
       const logger = new ConsoleLoggerAdapter();
       const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'test1-'));
-      const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir);
+      const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir, genSigner());
 
       const url = new URL(
         'https://block.registry.platforma.bio/releases/v1/milaboratory/NOT_FOUND',
       );
 
-      const c = driver.getPath(url);
+      const c = driver.getUrl(url);
 
-      const path1 = await c.getValue();
-      expect(path1).toBeUndefined();
+      const url1 = await c.getValue();
+      expect(url1).toBeUndefined();
 
       await c.awaitChange();
 
-      const path2 = await c.getValue();
-      expect(path2).not.toBeUndefined();
-      expect(path2?.error).not.toBeUndefined();
+      const url2 = await c.getValue();
+      expect(url2).not.toBeUndefined();
+      expect(url2?.error).not.toBeUndefined();
     });
   } catch (e) {
     console.log('HERE: ', e);
@@ -71,21 +74,25 @@ test('should abort a downloading process when we reset a state of a computable',
   await TestHelpers.withTempRoot(async (client) => {
     const logger = new ConsoleLoggerAdapter();
     const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'test2-'));
-    const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir);
+    const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir, genSigner());
 
     const url = new URL(
       'https://block.registry.platforma.bio/releases/v1/milaboratory/enter-numbers/0.4.1/frontend.tgz',
     );
 
-    const c = driver.getPath(url);
+    const c = driver.getUrl(url);
 
-    const path1 = await c.getValue();
-    expect(path1).toBeUndefined();
+    const url1 = await c.getValue();
+    expect(url1).toBeUndefined();
 
     c.resetState();
     await c.awaitChange();
 
-    const path2 = await c.getValue();
-    expect(path2).toBeUndefined();
+    const url2 = await c.getValue();
+    expect(url2).toBeUndefined();
   });
 });
+
+function genSigner() {
+  return new HmacSha256Signer(HmacSha256Signer.generateSecret())
+}

package/src/drivers/{download_url.ts → download_url/driver.ts}

@@ -1,49 +1,57 @@
 import type { ComputableCtx, Watcher } from '@milaboratories/computable';
-import { ChangeSource, Computable } from '@milaboratories/computable';
+import { Computable } from '@milaboratories/computable';
 import type {
-  MiLogger } from '@milaboratories/ts-helpers';
+  MiLogger,
+  Signer,
+} from '@milaboratories/ts-helpers';
 import {
-  CallersCounter,
   TaskProcessor,
-  createPathAtomically,
-  ensureDirExists,
-  fileExists,
-  notEmpty,
 } from '@milaboratories/ts-helpers';
 import { createHash, randomUUID } from 'node:crypto';
-import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
-import { Transform, Writable } from 'node:stream';
-import * as zlib from 'node:zlib';
-import * as tar from 'tar-fs';
 import type { Dispatcher } from 'undici';
-import { NetworkError400, RemoteFileDownloader } from '../helpers/download';
-import { FilesCache } from './helpers/files_cache';
+import { RemoteFileDownloader } from '../../helpers/download';
+import { FilesCache } from '../helpers/files_cache';
 import { stringifyWithResourceId } from '@milaboratories/pl-client';
+import type { BlockUIURL, FrontendDriver } from '@milaboratories/pl-model-common';
+import { isBlockUIURL } from '@milaboratories/pl-model-common';
+import { getPathForBlockUIURL } from '../urls/url';
+import { DownloadByUrlTask, rmRFDir } from './task';
 
 export interface DownloadUrlSyncReader {
   /** Returns a Computable that (when the time will come)
    * downloads an archive from an URL,
    * extracts it to the local dir and returns a path to that dir. */
-  getPath(url: URL): Computable<PathResult | undefined>;
+  getUrl(url: URL): Computable<UrlResult | undefined>;
 }
 
-export interface PathResult {
-  /** Path to the downloadable blob, might be undefined when the error happened. */
-  path?: string;
+export interface UrlResult {
+  /** Path to the downloadable blob along with the signature and a custom protocol,
+   * might be undefined when the error happened. */
+  url?: BlockUIURL;
   /** Error that happened when the archive were downloaded. */
   error?: string;
 }
 
 export type DownloadUrlDriverOps = {
+  /** A soft limit of the amount of blob storage, in bytes.
+   * Once exceeded, the download driver will start deleting blobs one by one
+   * when they become unneeded.
+   * */
   cacheSoftSizeBytes: number;
+
+  /** Whether to gunzip the downloaded archive (it will be untared automatically). */
   withGunzip: boolean;
+
+  /** Max number of concurrent downloads while calculating computable states
+   * derived from this driver.
+   * */
   nConcurrentDownloads: number;
 };
 
 /** Downloads .tar or .tar.gz archives by given URLs
  * and extracts them into saveDir. */
-export class DownloadUrlDriver implements DownloadUrlSyncReader {
+export class DownloadUrlDriver implements DownloadUrlSyncReader, FrontendDriver {
   private readonly downloadHelper: RemoteFileDownloader;
 
   private urlToDownload: Map<string, DownloadByUrlTask> = new Map();
@@ -57,6 +65,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
     private readonly logger: MiLogger,
     httpClient: Dispatcher,
     private readonly saveDir: string,
+    private readonly signer: Signer,
     private readonly opts: DownloadUrlDriverOps = {
       cacheSoftSizeBytes: 1 * 1024 * 1024 * 1024, // 1 GB
       withGunzip: true,
@@ -69,25 +78,26 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
   }
 
   /** Use to get a path result inside a computable context */
-  getPath(url: URL, ctx: ComputableCtx): PathResult | undefined;
+  getUrl(url: URL, ctx: ComputableCtx): UrlResult | undefined;
 
   /** Returns a Computable that do the work */
-  getPath(url: URL): Computable<PathResult | undefined>;
+  getUrl(url: URL): Computable<UrlResult | undefined>;
 
-  getPath(
+  /** Returns a computable that returns a custom protocol URL to the downloaded and unarchived path. */
+  getUrl(
     url: URL,
     ctx?: ComputableCtx,
-  ): Computable<PathResult | undefined> | PathResult | undefined {
+  ): Computable<UrlResult | undefined> | UrlResult | undefined {
     // wrap result as computable, if we were not given an existing computable context
-    if (ctx === undefined) return Computable.make((c) => this.getPath(url, c));
+    if (ctx === undefined) return Computable.make((c) => this.getUrl(url, c));
 
     const callerId = randomUUID();
 
     // read as ~ golang's defer
     ctx.addOnDestroy(() => this.releasePath(url, callerId));
 
-    const result = this.getPathNoCtx(url, ctx.watcher, callerId);
-    if (result?.path === undefined)
+    const result = this.getUrlNoCtx(url, ctx.watcher, callerId);
+    if (result?.url === undefined)
       ctx.markUnstable(
         `a path to the downloaded and untared archive might be undefined. The current result: ${result}`,
       );
@@ -95,13 +105,13 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
     return result;
   }
 
-  getPathNoCtx(url: URL, w: Watcher, callerId: string) {
+  getUrlNoCtx(url: URL, w: Watcher, callerId: string) {
     const key = url.toString();
     const task = this.urlToDownload.get(key);
 
-    if (task != undefined) {
+    if (task !== undefined) {
       task.attach(w, callerId);
-      return task.getPath();
+      return task.getUrl();
     }
 
     const newTask = this.setNewTask(w, url, callerId);
@@ -110,14 +120,22 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
       recoverableErrorPredicate: (e) => true,
     });
 
-    return newTask.getPath();
+    return newTask.getUrl();
+  }
+
+  getPathForBlockUI(url: string): string {
+    if (!isBlockUIURL(url)) {
+      throw new Error(`getPathForBlockUI: ${url} is invalid`);
+    }
+
+    return getPathForBlockUIURL(this.signer, url, this.saveDir);
   }
 
   /** Downloads and extracts a tar archive if it wasn't downloaded yet. */
   async downloadUrl(task: DownloadByUrlTask, callerId: string) {
     await task.download(this.downloadHelper, this.opts.withGunzip);
     // Might be undefined if a error happened
-    if (task.getPath()?.path != undefined) this.cache.addCache(task, callerId);
+    if (task.getUrl()?.url !== undefined) this.cache.addCache(task, callerId);
   }
 
   /** Removes a directory and aborts a downloading task when all callers
@@ -171,7 +189,13 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
   }
 
   private setNewTask(w: Watcher, url: URL, callerId: string) {
-    const result = new DownloadByUrlTask(this.logger, this.getFilePath(url), url);
+    const result = new DownloadByUrlTask(
+      this.logger,
+      this.getFilePath(url),
+      url,
+      this.signer,
+      this.saveDir,
+    );
     result.attach(w, callerId);
     this.urlToDownload.set(url.toString(), result);
 
@@ -189,128 +213,3 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
     return path.join(this.saveDir, sha256);
   }
 }
-
-/** Downloads and extracts an archive to a directory. */
-class DownloadByUrlTask {
-  readonly counter = new CallersCounter();
-  readonly change = new ChangeSource();
-  private readonly signalCtl = new AbortController();
-  error: string | undefined;
-  done = false;
-  size = 0;
-
-  constructor(
-    private readonly logger: MiLogger,
-    readonly path: string,
-    readonly url: URL,
-  ) {}
-
-  public info() {
-    return {
-      url: this.url.toString(),
-      path: this.path,
-      done: this.done,
-      size: this.size,
-      error: this.error,
-    };
-  }
-
-  attach(w: Watcher, callerId: string) {
-    this.counter.inc(callerId);
-    if (!this.done) this.change.attachWatcher(w);
-  }
-
-  async download(clientDownload: RemoteFileDownloader, withGunzip: boolean) {
-    try {
-      const size = await this.downloadAndUntar(clientDownload, withGunzip, this.signalCtl.signal);
-      this.setDone(size);
-      this.change.markChanged(`download of ${this.url} finished`);
-    } catch (e: any) {
-      if (e instanceof URLAborted || e instanceof NetworkError400) {
-        this.setError(e);
-        this.change.markChanged(`download of ${this.url} failed`);
-        // Just in case we were half-way extracting an archive.
-        await rmRFDir(this.path);
-        return;
-      }
-
-      throw e;
-    }
-  }
-
-  private async downloadAndUntar(
-    clientDownload: RemoteFileDownloader,
-    withGunzip: boolean,
-    signal: AbortSignal,
-  ): Promise<number> {
-    await ensureDirExists(path.dirname(this.path));
-
-    if (await fileExists(this.path)) {
-      return await dirSize(this.path);
-    }
-
-    const resp = await clientDownload.download(this.url.toString(), {}, signal);
-
-    let content = resp.content;
-    if (withGunzip) {
-      const gunzip = Transform.toWeb(zlib.createGunzip());
-      content = content.pipeThrough(gunzip, { signal });
-    }
-
-    await createPathAtomically(this.logger, this.path, async (fPath: string) => {
-      await fsp.mkdir(fPath); // throws if a directory already exists.
-      const untar = Writable.toWeb(tar.extract(fPath));
-      await content.pipeTo(untar, { signal });
-    });
-
-    return resp.size;
-  }
-
-  getPath(): PathResult | undefined {
-    if (this.done) return { path: notEmpty(this.path) };
-
-    if (this.error) return { error: this.error };
-
-    return undefined;
-  }
-
-  private setDone(size: number) {
-    this.done = true;
-    this.size = size;
-  }
-
-  private setError(e: any) {
-    this.error = String(e);
-  }
-
-  abort(reason: string) {
-    this.signalCtl.abort(new URLAborted(reason));
-  }
-}
-
-/** Throws when a downloading aborts. */
-class URLAborted extends Error {
-  name = 'URLAborted';
-}
-
-/** Gets a directory size by calculating sizes recursively. */
-async function dirSize(dir: string): Promise<number> {
-  const files = await fsp.readdir(dir, { withFileTypes: true });
-  const sizes = await Promise.all(
-    files.map(async (file: any) => {
-      const fPath = path.join(dir, file.name);
-
-      if (file.isDirectory()) return await dirSize(fPath);
-
-      const stat = await fsp.stat(fPath);
-      return stat.size;
-    }),
-  );
-
-  return sizes.reduce((sum: any, size: any) => sum + size, 0);
-}
-
-/** Do rm -rf on dir. */
-async function rmRFDir(path: string) {
-  await fsp.rm(path, { recursive: true, force: true });
-}

package/src/drivers/download_url/task.ts

@@ -0,0 +1,151 @@
+import type { Watcher } from '@milaboratories/computable';
+import { ChangeSource } from '@milaboratories/computable';
+import type {
+  MiLogger,
+  Signer,
+} from '@milaboratories/ts-helpers';
+import {
+  CallersCounter,
+  createPathAtomically,
+  ensureDirExists,
+  fileExists,
+  notEmpty,
+} from '@milaboratories/ts-helpers';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { Transform, Writable } from 'node:stream';
+import * as zlib from 'node:zlib';
+import * as tar from 'tar-fs';
+import type { RemoteFileDownloader } from '../../helpers/download';
+import { NetworkError400 } from '../../helpers/download';
+import type { UrlResult } from './driver';
+import { newBlockUIURL } from '../urls/url';
+
+/** Downloads and extracts an archive to a directory. */
+export class DownloadByUrlTask {
+  readonly counter = new CallersCounter();
+  readonly change = new ChangeSource();
+  private readonly signalCtl = new AbortController();
+  error: string | undefined;
+  done = false;
+  size = 0;
+
+  constructor(
+    private readonly logger: MiLogger,
+    readonly path: string,
+    readonly url: URL,
+    readonly signer: Signer,
+    readonly saveDir: string,
+  ) { }
+
+  public info() {
+    return {
+      url: this.url.toString(),
+      path: this.path,
+      done: this.done,
+      size: this.size,
+      error: this.error,
+    };
+  }
+
+  attach(w: Watcher, callerId: string) {
+    this.counter.inc(callerId);
+    if (!this.done) this.change.attachWatcher(w);
+  }
+
+  async download(clientDownload: RemoteFileDownloader, withGunzip: boolean) {
+    try {
+      const size = await this.downloadAndUntar(clientDownload, withGunzip, this.signalCtl.signal);
+      this.setDone(size);
+      this.change.markChanged(`download of ${this.url} finished`);
+    } catch (e: unknown) {
+      if (e instanceof URLAborted || e instanceof NetworkError400) {
+        this.setError(e);
+        this.change.markChanged(`download of ${this.url} failed`);
+        // Just in case we were half-way extracting an archive.
+        await rmRFDir(this.path);
+        return;
+      }
+
+      throw e;
+    }
+  }
+
+  private async downloadAndUntar(
+    clientDownload: RemoteFileDownloader,
+    withGunzip: boolean,
+    signal: AbortSignal,
+  ): Promise<number> {
+    await ensureDirExists(path.dirname(this.path));
+
+    if (await fileExists(this.path)) {
+      return await dirSize(this.path);
+    }
+
+    const resp = await clientDownload.download(this.url.toString(), {}, signal);
+
+    let content = resp.content;
+    if (withGunzip) {
+      const gunzip = Transform.toWeb(zlib.createGunzip());
+      content = content.pipeThrough(gunzip, { signal });
+    }
+
+    await createPathAtomically(this.logger, this.path, async (fPath: string) => {
+      await fsp.mkdir(fPath); // throws if a directory already exists.
+      const untar = Writable.toWeb(tar.extract(fPath));
+      await content.pipeTo(untar, { signal });
+    });
+
+    return resp.size;
+  }
+
+  getUrl(): UrlResult | undefined {
+    if (this.done) return {
+      url: newBlockUIURL(this.signer, this.saveDir, notEmpty(this.path))
+     };
+
+    if (this.error) return { error: this.error };
+
+    return undefined;
+  }
+
+  private setDone(size: number) {
+    this.done = true;
+    this.size = size;
+  }
+
+  private setError(e: any) {
+    this.error = String(e);
+  }
+
+  abort(reason: string) {
+    this.signalCtl.abort(new URLAborted(reason));
+  }
+}
+
+/** Throws when a downloading aborts. */
+export class URLAborted extends Error {
+  name = 'URLAborted';
+}
+
+/** Gets a directory size by calculating sizes recursively. */
+async function dirSize(dir: string): Promise<number> {
+  const files = await fsp.readdir(dir, { withFileTypes: true });
+  const sizes = await Promise.all(
+    files.map(async (file: any) => {
+      const fPath = path.join(dir, file.name);
+
+      if (file.isDirectory()) return await dirSize(fPath);
+
+      const stat = await fsp.stat(fPath);
+      return stat.size;
+    }),
+  );
+
+  return sizes.reduce((sum: any, size: any) => sum + size, 0);
+}
+
+/** Do rm -rf on dir. */
+export async function rmRFDir(path: string) {
+  await fsp.rm(path, { recursive: true, force: true });
+}