@milaboratories/pl-drivers 1.5.10 → 1.5.12

package/src/drivers/download_blob_url/task.ts

@@ -0,0 +1,230 @@
+import { Transform, Writable } from 'node:stream';
+import * as zlib from 'node:zlib';
+import * as tar from 'tar-fs';
+import path from 'path';
+import fs from 'fs';
+import * as fsp from 'fs/promises';
+import { NetworkError400 } from '../../helpers/download';
+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 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 decompress from 'decompress';
+import { assertNever } from '@protobuf-ts/runtime';
+import { stringifyWithResourceId } from '@milaboratories/pl-client';
+
+export type URLResult = {
+  url?: FolderURL;
+  error?: string;
+};
+
+/** Downloads and extracts an archive to a directory. */
+export class DownloadAndUnarchiveTask {
+  readonly counter = new CallersCounter();
+  readonly change = new ChangeSource();
+  private readonly signalCtl = new AbortController();
+  error: string | undefined;
+  done = false;
+  size = 0;
+  private url: FolderURL | undefined;
+  private state: DownloadCtx | undefined;
+
+  constructor(
+    private readonly logger: MiLogger,
+    private readonly signer: Signer,
+    readonly saveDir: string,
+    readonly path: string,
+    readonly rInfo: DownloadableBlobSnapshot,
+    readonly format: ArchiveFormat,
+    private readonly clientDownload: ClientDownload,
+  ) {}
+
+  /** A debug info of the task. */
+  public info() {
+    return {
+      rInfo: this.rInfo,
+      format: this.format,
+      path: this.path,
+      done: this.done,
+      size: this.size,
+      error: this.error,
+      taskHistory: this.state,
+    };
+  }
+
+  attach(w: Watcher, callerId: string) {
+    this.counter.inc(callerId);
+    if (!this.done) this.change.attachWatcher(w);
+  }
+
+  async download() {
+    try {
+      const size = await this.downloadAndDecompress(this.signalCtl.signal);
+      this.setDone(size);
+      this.change.markChanged();
+
+      this.logger.info(`blob to URL task is done: ${stringifyWithResourceId(this.info())}`);
+    } catch (e: any) {
+      this.logger.warn(`a error was produced: ${e} for blob to URL task: ${stringifyWithResourceId(this.info())}`);
+
+      if (nonRecoverableError(e)) {
+        this.setError(e);
+        this.change.markChanged();
+        // Just in case we were half-way extracting an archive.
+        await rmRFDir(this.path);
+        return;
+      }
+
+      throw e;
+    }
+  }
+
+  /** Does the download part and keeps a state of the process. */
+  private async downloadAndDecompress(signal: AbortSignal): Promise<number> {
+    this.state = {};
+
+    this.state.parentDir = path.dirname(this.path);
+    await ensureDirExists(this.state.parentDir);
+
+    this.state.fileExisted = await fileExists(this.path);
+    if (this.state.fileExisted) {
+      return await dirSize(this.path);
+    }
+
+    const { content, size } = await this.clientDownload.downloadBlob(
+      this.rInfo, {}, signal,
+    );
+    this.state.downloaded = true;
+
+    await createPathAtomically(this.logger, this.path, async (fPath: string) => {
+      this.state!.tempPath = fPath;
+      this.state!.archiveFormat = this.format;
+
+      switch (this.format) {
+        case 'tar':
+          await fsp.mkdir(fPath); // throws if a directory already exists.
+          const simpleUntar = Writable.toWeb(tar.extract(fPath));
+          await content.pipeTo(simpleUntar, { signal });
+          return;
+
+        case 'tgz':
+          await fsp.mkdir(fPath); // throws if a directory already exists.
+          const gunzip = Transform.toWeb(zlib.createGunzip());
+          const untar = Writable.toWeb(tar.extract(fPath));
+
+          await content
+            .pipeThrough(gunzip, { signal })
+            .pipeTo(untar, { signal });
+          return;
+
+        case 'zip':
+          this.state!.zipPath = this.path + '.zip';
+
+          const f = Writable.toWeb(fs.createWriteStream(this.state!.zipPath));
+          await content.pipeTo(f, { signal });
+          this.state!.zipPathCreated = true;
+
+          // Without this filter it fails with
+          // "EISDIR: illegal operation on a directory".
+          // The workaround is from
+          // https://github.com/kevva/decompress/issues/46#issuecomment-525048104
+          await decompress(this.state!.zipPath, fPath, {
+            filter: file => !file.path.endsWith('/'),
+          });
+          this.state!.zipDecompressed = true;
+
+          await fs.promises.rm(this.state!.zipPath);
+          this.state!.zipPathDeleted = true;
+
+          return;
+
+        default:
+          assertNever(this.format);
+      }
+    });
+
+    this.state.pathCreated = true;
+
+    return size;
+  }
+
+  getURL(): URLResult | undefined {
+    if (this.done) return { url: notEmpty(this.url) };
+
+    if (this.error) return { error: this.error };
+
+    return undefined;
+  }
+
+  private setDone(size: number) {
+    this.done = true;
+    this.size = size;
+    this.url = newFolderURL(this.signer, this.saveDir, this.path);
+  }
+
+  private setError(e: any) {
+    this.error = String(e);
+  }
+
+  abort(reason: string) {
+    this.signalCtl.abort(new URLAborted(reason));
+  }
+}
+
+/** 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) => {
+      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, size) => sum + size, 0);
+}
+
+/** Do rm -rf on dir. */
+export async function rmRFDir(path: string) {
+  await fsp.rm(path, { recursive: true, force: true });
+}
+
+/** Just a type that adds lots of context when the error happens. */
+type DownloadCtx = {
+  parentDir?: string;
+  fileExisted?: boolean;
+  downloaded?: boolean;
+  archiveFormat?: ArchiveFormat;
+  tempPath?: string;
+  zipPath?: string;
+  zipPathCreated?: boolean;
+  zipDecompressed?: boolean;
+  zipPathDeleted?: boolean;
+  pathCreated?: boolean;
+};
+
+/** Throws when a downloading aborts. */
+class URLAborted extends Error {}
+
+export function nonRecoverableError(e: any) {
+  return (
+    e instanceof URLAborted
+    || e instanceof NetworkError400
+    || e instanceof UnknownStorageError
+    || e instanceof WrongLocalFileUrl
+    // file that we downloads from was moved or deleted.
+    || e?.code == 'ENOENT'
+    // A resource was deleted.
+    || (e.name == 'RpcError' && (e.code == 'NOT_FOUND' || e.code == 'ABORTED'))
+    // wrong archive format
+    || (String(e).includes('incorrect header check'))
+  );
+}

package/src/drivers/download_blob_url/url.test.ts

@@ -0,0 +1,39 @@
+import path from 'path';
+import { describe, test, expect } from '@jest/globals';
+import { isFolderURL, getPathForFolderURL } from './url';
+import type { Signer } from '@milaboratories/ts-helpers';
+import { HmacSha256Signer } from '@milaboratories/ts-helpers';
+import { FolderURL } from '@milaboratories/pl-model-common';
+
+describe('isFolderURL', () => {
+  test('should return true for a valid URL', () => {
+    const folderUrl = 'plblob+folder://5976f110166cc5d8803c41181fbb708470b69075db19ad98d8971df350732028.31330_tgz.blob/path/to/folder';
+    expect(isFolderURL(folderUrl)).toBe(true);
+  });
+
+  test('should return false for URL with a different protocol', () => {
+    expect(isFolderURL('https://example.com/path/to/folder')).toBe(false);
+  });
+
+  test('should throw error for incorrect URLs', () => {
+    expect(() => {
+      isFolderURL('not_a_valid_url');
+    }).toThrow();
+  });
+});
+
+describe('getPathForFolderURL', () => {
+  const signer: Signer = {
+    sign: (data: string | Uint8Array) => 'signature',
+
+    verify: (data: string | Uint8Array, signature: string, validationErrorMessage?: string) => null,
+  };
+
+  test('should be ok', () => {
+    const folderURL = 'plblob+folder://signature.subfolder_tgz.blob/path/to/resource.html';
+
+    const result = getPathForFolderURL(signer, folderURL, '/test/dir');
+
+    expect(result).toBe(path.join('/test/dir/subfolder_tgz/path/to/resource.html'));
+  });
+});

package/src/drivers/download_blob_url/url.ts

@@ -0,0 +1,43 @@
+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

@@ -16,7 +16,7 @@ test('should download a tar archive and extracts its content and then deleted',
     const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir);
 
     const url = new URL(
-      'https://block.registry.platforma.bio/releases/v1/milaboratory/enter-numbers/0.4.1/frontend.tgz'
+      'https://block.registry.platforma.bio/releases/v1/milaboratory/enter-numbers/0.4.1/frontend.tgz',
     );
 
     const c = driver.getPath(url);
@@ -48,7 +48,7 @@ test('should show a error when 404 status code', async () => {
       const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir);
 
       const url = new URL(
-        'https://block.registry.platforma.bio/releases/v1/milaboratory/NOT_FOUND'
+        'https://block.registry.platforma.bio/releases/v1/milaboratory/NOT_FOUND',
       );
 
       const c = driver.getPath(url);
@@ -74,7 +74,7 @@ test('should abort a downloading process when we reset a state of a computable',
     const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir);
 
     const url = new URL(
-      'https://block.registry.platforma.bio/releases/v1/milaboratory/enter-numbers/0.4.1/frontend.tgz'
+      'https://block.registry.platforma.bio/releases/v1/milaboratory/enter-numbers/0.4.1/frontend.tgz',
     );
 
     const c = driver.getPath(url);

package/src/drivers/download_url.ts

@@ -1,12 +1,14 @@
-import { ChangeSource, Computable, ComputableCtx, Watcher } from '@milaboratories/computable';
+import type { ComputableCtx, Watcher } from '@milaboratories/computable';
+import { ChangeSource, Computable } from '@milaboratories/computable';
+import type {
+  MiLogger } from '@milaboratories/ts-helpers';
 import {
   CallersCounter,
-  MiLogger,
   TaskProcessor,
   createPathAtomically,
   ensureDirExists,
   fileExists,
-  notEmpty
+  notEmpty,
 } from '@milaboratories/ts-helpers';
 import { createHash, randomUUID } from 'node:crypto';
 import * as fsp from 'node:fs/promises';
@@ -14,11 +16,10 @@ 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 { Dispatcher } from 'undici';
+import type { Dispatcher } from 'undici';
 import { NetworkError400, RemoteFileDownloader } from '../helpers/download';
 import { FilesCache } from './helpers/files_cache';
 import { stringifyWithResourceId } from '@milaboratories/pl-client';
-import { DownloadBlobTask } from './download_blob_task';
 
 export interface DownloadUrlSyncReader {
   /** Returns a Computable that (when the time will come)
@@ -59,8 +60,8 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
     private readonly opts: DownloadUrlDriverOps = {
       cacheSoftSizeBytes: 50 * 1024 * 1024,
       withGunzip: true,
-      nConcurrentDownloads: 50
-    }
+      nConcurrentDownloads: 50,
+    },
   ) {
     this.downloadQueue = new TaskProcessor(this.logger, this.opts.nConcurrentDownloads);
     this.cache = new FilesCache(this.opts.cacheSoftSizeBytes);
@@ -75,7 +76,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
 
   getPath(
     url: URL,
-    ctx?: ComputableCtx
+    ctx?: ComputableCtx,
   ): Computable<PathResult | undefined> | PathResult | 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));
@@ -88,7 +89,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
     const result = this.getPathNoCtx(url, ctx.watcher, callerId);
     if (result?.path === undefined)
       ctx.markUnstable(
-        `a path to the downloaded and untared archive might be undefined. The current result: ${result}`
+        `a path to the downloaded and untared archive might be undefined. The current result: ${result}`,
       );
 
     return result;
@@ -106,7 +107,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
     const newTask = this.setNewTask(w, url, callerId);
     this.downloadQueue.push({
       fn: async () => this.downloadUrl(newTask, callerId),
-      recoverableErrorPredicate: (e) => true
+      recoverableErrorPredicate: (e) => true,
     });
 
     return newTask.getPath();
@@ -136,10 +137,10 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
 
           this.removeTask(
             task,
-            `the task ${stringifyWithResourceId(task.info())} was removed` +
-              `from cache along with ${stringifyWithResourceId(toDelete.map((t) => t.info()))}`
+            `the task ${stringifyWithResourceId(task.info())} was removed`
+            + `from cache along with ${stringifyWithResourceId(toDelete.map((t) => t.info()))}`,
           );
-        })
+        }),
       );
     } else {
       // The task is still in a downloading queue.
@@ -147,7 +148,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
       if (deleted)
         this.removeTask(
           task,
-          `the task ${stringifyWithResourceId(task.info())} was removed from cache`
+          `the task ${stringifyWithResourceId(task.info())} was removed from cache`,
         );
     }
   }
@@ -163,9 +164,9 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
 
         this.removeTask(
           task,
-          `the task ${stringifyWithResourceId(task.info())} was released when the driver was closed`
+          `the task ${stringifyWithResourceId(task.info())} was released when the driver was closed`,
         );
-      })
+      }),
     );
   }
 
@@ -201,7 +202,7 @@ class DownloadByUrlTask {
   constructor(
     private readonly logger: MiLogger,
     readonly path: string,
-    readonly url: URL
+    readonly url: URL,
   ) {}
 
   public info() {
@@ -210,7 +211,7 @@ class DownloadByUrlTask {
       path: this.path,
       done: this.done,
       size: this.size,
-      error: this.error
+      error: this.error,
     };
   }
 
@@ -240,7 +241,7 @@ class DownloadByUrlTask {
   private async downloadAndUntar(
     clientDownload: RemoteFileDownloader,
     withGunzip: boolean,
-    signal: AbortSignal
+    signal: AbortSignal,
   ): Promise<number> {
     await ensureDirExists(path.dirname(this.path));
 
@@ -301,7 +302,7 @@ async function dirSize(dir: string): Promise<number> {
 
       const stat = await fsp.stat(fPath);
       return stat.size;
-    })
+    }),
   );
 
   return sizes.reduce((sum, size) => sum + size, 0);

package/src/drivers/helpers/download_local_handle.ts

@@ -1,8 +1,8 @@
 /** Handle of locally downloaded blob. This handle is issued only after the
  * blob's content is downloaded locally, and ready for quick access. */
 
-import { LocalBlobHandle } from '@milaboratories/pl-model-common';
-import { Signer } from '@milaboratories/ts-helpers';
+import type { LocalBlobHandle } from '@milaboratories/pl-model-common';
+import type { Signer } from '@milaboratories/ts-helpers';
 
 // https://regex101.com/r/kfnBVX/1
 const localHandleRegex = /^blob\+local:\/\/download\/(?<path>.*)#(?<signature>.*)$/;

package/src/drivers/helpers/download_remote_handle.ts

@@ -1,19 +1,19 @@
 /** Handle of remote blob. This handle is issued as soon as the data becomes
  * available on the remote server. */
 
-import { Signer } from '@milaboratories/ts-helpers';
-import { OnDemandBlobResourceSnapshot } from '../types';
-import { RemoteBlobHandle } from '@milaboratories/pl-model-common';
-import { ResourceInfo } from '@milaboratories/pl-tree';
+import type { Signer } from '@milaboratories/ts-helpers';
+import type { OnDemandBlobResourceSnapshot } from '../types';
+import type { RemoteBlobHandle } from '@milaboratories/pl-model-common';
+import type { ResourceInfo } from '@milaboratories/pl-tree';
 import { bigintToResourceId } from '@milaboratories/pl-client';
 
 // https://regex101.com/r/rvbPZt/1
-const remoteHandleRegex =
-  /^blob\+remote:\/\/download\/(?<content>(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*))#(?<signature>.*)$/;
+const remoteHandleRegex
+  = /^blob\+remote:\/\/download\/(?<content>(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*))#(?<signature>.*)$/;
 
 export function newRemoteHandle(
   rInfo: OnDemandBlobResourceSnapshot,
-  signer: Signer
+  signer: Signer,
 ): RemoteBlobHandle {
   const content = `${rInfo.type.name}/${rInfo.type.version}/${BigInt(rInfo.id)}`;
   return `blob+remote://download/${content}#${signer.sign(content)}` as RemoteBlobHandle;
@@ -35,6 +35,6 @@ export function parseRemoteHandle(handle: RemoteBlobHandle, signer: Signer): Res
 
   return {
     id: bigintToResourceId(BigInt(resourceId)),
-    type: { name: resourceType, version: resourceVersion }
+    type: { name: resourceType, version: resourceVersion },
   };
 }

package/src/drivers/helpers/files_cache.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from '@jest/globals';
 import { CallersCounter } from '@milaboratories/ts-helpers';
-import { CachedFile, FilesCache } from './files_cache';
+import type { CachedFile } from './files_cache';
+import { FilesCache } from './files_cache';
 
 test('should delete blob3 when add 3 blobs, exceed a soft limit and nothing holds blob3', () => {
   const cache = new FilesCache(20);
@@ -8,17 +9,17 @@ test('should delete blob3 when add 3 blobs, exceed a soft limit and nothing hold
   const blob1: CachedFile = {
     path: 'path1',
     size: 5,
-    counter: new CallersCounter()
+    counter: new CallersCounter(),
   };
   const blob2: CachedFile = {
     path: 'path2',
     size: 10,
-    counter: new CallersCounter()
+    counter: new CallersCounter(),
   };
   const blob3: CachedFile = {
     path: 'path3',
     size: 10,
-    counter: new CallersCounter()
+    counter: new CallersCounter(),
   };
 
   // add blobs and check that we don't exceed the soft limit.
@@ -53,12 +54,12 @@ test('regression should allow to add empty files', () => {
   const blob1: CachedFile = {
     path: 'path1',
     size: 0,
-    counter: new CallersCounter()
+    counter: new CallersCounter(),
   };
   const blob2: CachedFile = {
     path: 'path2',
     size: 2,
-    counter: new CallersCounter()
+    counter: new CallersCounter(),
   };
 
   // add a blob with 0 size.

package/src/drivers/helpers/files_cache.ts

@@ -1,4 +1,5 @@
-import { CallersCounter, mapEntries, mapGet } from '@milaboratories/ts-helpers';
+import type { CallersCounter } from '@milaboratories/ts-helpers';
+import { mapEntries, mapGet } from '@milaboratories/ts-helpers';
 
 type PathLike = string;
 

package/src/drivers/helpers/helpers.ts

@@ -4,7 +4,7 @@ import {
   isNullResourceId,
   PlClient,
   ResourceId,
-  valErr
+  valErr,
 } from '@milaboratories/pl-client';
 
 /** Throws when a driver gets a resource with a wrong resource type. */

package/src/drivers/helpers/logs_handle.ts

@@ -1,8 +1,8 @@
 /** Handle of logs. This handle should be passed
  * to the driver for retrieving logs. */
 
-import { ResourceInfo } from '@milaboratories/pl-tree';
-import * as sdk from '@milaboratories/pl-model-common';
+import type { ResourceInfo } from '@milaboratories/pl-tree';
+import type * as sdk from '@milaboratories/pl-model-common';
 import { bigintToResourceId } from '@milaboratories/pl-client';
 
 export function newLogHandle(live: boolean, rInfo: ResourceInfo): sdk.AnyLogHandle {
@@ -17,8 +17,8 @@ export function newLogHandle(live: boolean, rInfo: ResourceInfo): sdk.AnyLogHand
  * The resource that represents a log can be deleted,
  * in this case the handle should be refreshed. */
 
-export const liveHandleRegex =
-  /^log\+live:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
+export const liveHandleRegex
+  = /^log\+live:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
 
 export function isLiveLogHandle(handle: string): handle is sdk.LiveLogHandle {
   return liveHandleRegex.test(handle);
@@ -26,8 +26,8 @@ export function isLiveLogHandle(handle: string): handle is sdk.LiveLogHandle {
 
 /** Handle of the ready logs of a program. */
 
-export const readyHandleRegex =
-  /^log\+ready:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
+export const readyHandleRegex
+  = /^log\+ready:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
 
 export function isReadyLogHandle(handle: string): handle is sdk.ReadyLogHandle {
   return readyHandleRegex.test(handle);
@@ -47,6 +47,6 @@ export function getResourceInfoFromLogHandle(handle: sdk.AnyLogHandle): Resource
 
   return {
     id: bigintToResourceId(BigInt(resourceId)),
-    type: { name: resourceType, version: resourceVersion }
+    type: { name: resourceType, version: resourceVersion },
   };
 }

package/src/drivers/helpers/ls_remote_import_handle.ts

@@ -1,14 +1,14 @@
-import * as sdk from '@milaboratories/pl-model-common';
-import { Signer } from '@milaboratories/ts-helpers';
+import type * as sdk from '@milaboratories/pl-model-common';
+import type { Signer } from '@milaboratories/ts-helpers';
 import { ImportFileHandleIndexData, ImportFileHandleUploadData } from '../types';
 
 export function createIndexImportHandle(
   storageName: string,
-  path: string
+  path: string,
 ): sdk.ImportFileHandleIndex {
   const data: ImportFileHandleIndexData = {
     storageId: storageName,
-    path: path
+    path: path,
   };
 
   return `index://index/${encodeURIComponent(JSON.stringify(data))}`;
@@ -18,13 +18,13 @@ export function createUploadImportHandle(
   localPath: string,
   signer: Signer,
   sizeBytes: bigint,
-  modificationTimeSeconds: bigint
+  modificationTimeSeconds: bigint,
 ): sdk.ImportFileHandleUpload {
   const data: ImportFileHandleUploadData = {
     localPath,
     pathSignature: signer.sign(localPath),
     sizeBytes: String(sizeBytes),
-    modificationTime: String(modificationTimeSeconds)
+    modificationTime: String(modificationTimeSeconds),
   };
 
   return `upload://upload/${encodeURIComponent(JSON.stringify(data))}`;
@@ -33,7 +33,7 @@ export function createUploadImportHandle(
 export function parseUploadHandle(handle: sdk.ImportFileHandleUpload): ImportFileHandleUploadData {
   const url = new URL(handle);
   return ImportFileHandleUploadData.parse(
-    JSON.parse(decodeURIComponent(url.pathname.substring(1)))
+    JSON.parse(decodeURIComponent(url.pathname.substring(1))),
   );
 }