@milaboratories/pl-drivers 1.3.26 → 1.5.0

package/src/drivers/download_blob_task.ts

@@ -0,0 +1,126 @@
+import { ChangeSource, Watcher } from '@milaboratories/computable';
+import { LocalBlobHandle, LocalBlobHandleAndSize } from '@milaboratories/pl-model-common';
+import { ResourceSnapshot } from '@milaboratories/pl-tree';
+import {
+  CallersCounter,
+  ValueOrError,
+  ensureDirExists,
+  fileExists,
+  createPathAtomically,
+  MiLogger
+} from '@milaboratories/ts-helpers';
+import fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { Writable } from 'node:stream';
+import { ClientDownload, UnknownStorageError, WrongLocalFileUrl } from '../clients/download';
+import { NetworkError400 } from '../helpers/download';
+
+/** Downloads a blob. */
+export class DownloadBlobTask {
+  readonly counter = new CallersCounter();
+  readonly change = new ChangeSource();
+  private readonly signalCtl = new AbortController();
+  private error: any | undefined;
+  private done = false;
+  /** Represents a size in bytes of the downloaded blob. */
+  size = 0;
+
+  constructor(
+    private readonly logger: MiLogger,
+    private readonly clientDownload: ClientDownload,
+    readonly rInfo: ResourceSnapshot,
+    readonly path: string,
+    private readonly handle: LocalBlobHandle
+  ) {}
+
+  public attach(w: Watcher, callerId: string) {
+    this.counter.inc(callerId);
+    if (!this.done) this.change.attachWatcher(w);
+  }
+
+  public async download() {
+    try {
+      await ensureDirExists(path.dirname(this.path));
+      const { content, size } = await this.clientDownload.downloadBlob(this.rInfo);
+
+      if (await fileExists(this.path)) {
+        await content.cancel(`the file already exists.`); // finalize body
+      } else {
+        await createPathAtomically(this.logger, this.path, async (fPath: string) => {
+          const f = Writable.toWeb(fs.createWriteStream(fPath, { flags: 'wx' }));
+          await content.pipeTo(f);
+        });
+      }
+
+      this.setDone(size);
+      this.change.markChanged();
+    } catch (e: any) {
+      if (nonRecoverableError(e)) {
+        this.setError(e);
+        this.change.markChanged();
+        // Just in case we were half-way extracting an archive.
+        await fsp.rm(this.path);
+      }
+
+      throw e;
+    }
+  }
+
+  public abort(reason: string) {
+    this.signalCtl.abort(new DownloadAborted(reason));
+  }
+
+  public getBlob():
+    | { done: false }
+    | {
+        done: true;
+        result: ValueOrError<LocalBlobHandleAndSize>;
+      } {
+    if (!this.done) return { done: false };
+
+    if (this.error)
+      return {
+        done: true,
+        result: { ok: false, error: this.error }
+      };
+
+    return {
+      done: true,
+      result: {
+        ok: true,
+        value: {
+          handle: this.handle,
+          size: this.size
+        }
+      }
+    };
+  }
+
+  private setDone(sizeBytes: number) {
+    this.done = true;
+    this.size = sizeBytes;
+  }
+
+  private setError(e: any) {
+    this.done = true;
+    this.error = e;
+  }
+}
+
+export function nonRecoverableError(e: any) {
+  return (
+    e instanceof DownloadAborted ||
+    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'))
+  );
+}
+
+/** The downloading task was aborted by a signal.
+ * It may happen when the computable is done, for example. */
+class DownloadAborted extends Error {}

package/src/drivers/download_url.test.ts

@@ -38,7 +38,7 @@ test('should download a tar archive and extracts its content and then deleted',
 
     c.resetState();
   });
-});
+}, 15000);
 
 test('should show a error when 404 status code', async () => {
   try {

package/src/drivers/download_url.ts

@@ -1,20 +1,22 @@
+import { ChangeSource, Computable, ComputableCtx, Watcher } from '@milaboratories/computable';
 import {
   CallersCounter,
   MiLogger,
   TaskProcessor,
-  notEmpty,
-  fileExists
+  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 { Writable, Transform } from 'node:stream';
-import { ChangeSource, Computable, ComputableCtx, Watcher } from '@milaboratories/computable';
-import { randomUUID, createHash } from 'node:crypto';
+import { Transform, Writable } from 'node:stream';
 import * as zlib from 'node:zlib';
 import * as tar from 'tar-fs';
-import { FilesCache } from './helpers/files_cache';
 import { Dispatcher } from 'undici';
-import { DownloadHelper, NetworkError400 } from '../helpers/download';
+import { NetworkError400, RemoteFileDownloader } from '../helpers/download';
+import { FilesCache } from './helpers/files_cache';
 
 export interface DownloadUrlSyncReader {
   /** Returns a Computable that (when the time will come)
@@ -39,14 +41,14 @@ export type DownloadUrlDriverOps = {
 /** Downloads .tar or .tar.gz archives by given URLs
  * and extracts them into saveDir. */
 export class DownloadUrlDriver implements DownloadUrlSyncReader {
-  private readonly downloadHelper: DownloadHelper;
+  private readonly downloadHelper: RemoteFileDownloader;
 
-  private urlToDownload: Map<string, Download> = new Map();
+  private urlToDownload: Map<string, DownloadByUrlTask> = new Map();
   private downloadQueue: TaskProcessor;
 
   /** Writes and removes files to a hard drive and holds a counter for every
    * file that should be kept. */
-  private cache: FilesCache<Download>;
+  private cache: FilesCache<DownloadByUrlTask>;
 
   constructor(
     private readonly logger: MiLogger,
@@ -60,7 +62,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
   ) {
     this.downloadQueue = new TaskProcessor(this.logger, this.opts.nConcurrentDownloads);
     this.cache = new FilesCache(this.opts.cacheSoftSizeBytes);
-    this.downloadHelper = new DownloadHelper(httpClient);
+    this.downloadHelper = new RemoteFileDownloader(httpClient);
   }
 
   /** Use to get a path result inside a computable context */
@@ -109,7 +111,7 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
   }
 
   /** Downloads and extracts a tar archive if it wasn't downloaded yet. */
-  async downloadUrl(task: Download, callerId: string) {
+  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);
@@ -159,14 +161,14 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
   }
 
   private setNewTask(w: Watcher, url: URL, callerId: string) {
-    const result = new Download(this.getFilePath(url), url);
+    const result = new DownloadByUrlTask(this.logger, this.getFilePath(url), url);
     result.attach(w, callerId);
     this.urlToDownload.set(url.toString(), result);
 
     return result;
   }
 
-  private removeTask(task: Download, reason: string) {
+  private removeTask(task: DownloadByUrlTask, reason: string) {
     task.abort(reason);
     task.change.markChanged();
     this.urlToDownload.delete(task.url.toString());
@@ -178,15 +180,17 @@ export class DownloadUrlDriver implements DownloadUrlSyncReader {
   }
 }
 
-class Download {
+/** Downloads and extracts an archive to a directory. */
+class DownloadByUrlTask {
   readonly counter = new CallersCounter();
   readonly change = new ChangeSource();
-  readonly signalCtl = new AbortController();
+  private readonly signalCtl = new AbortController();
   error: string | undefined;
   done = false;
-  sizeBytes = 0;
+  size = 0;
 
   constructor(
+    private readonly logger: MiLogger,
     readonly path: string,
     readonly url: URL
   ) {}
@@ -196,17 +200,15 @@ class Download {
     if (!this.done) this.change.attachWatcher(w);
   }
 
-  async download(clientDownload: DownloadHelper, withGunzip: boolean) {
+  async download(clientDownload: RemoteFileDownloader, withGunzip: boolean) {
     try {
-      const sizeBytes = await this.downloadAndUntar(
-        clientDownload,
-        withGunzip,
-        this.signalCtl.signal
-      );
-      this.setDone(sizeBytes);
+      const size = await this.downloadAndUntar(clientDownload, withGunzip, this.signalCtl.signal);
+      this.setDone(size);
+      this.change.markChanged();
     } catch (e: any) {
       if (e instanceof URLAborted || e instanceof NetworkError400) {
         this.setError(e);
+        this.change.markChanged();
         // Just in case we were half-way extracting an archive.
         await rmRFDir(this.path);
         return;
@@ -217,23 +219,29 @@ class Download {
   }
 
   private async downloadAndUntar(
-    clientDownload: DownloadHelper,
+    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.downloadRemoteFile(this.url.toString(), {}, signal);
-    let content = resp.content;
+    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 });
     }
-    const untar = Writable.toWeb(tar.extract(this.path));
-    await content.pipeTo(untar, { 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;
   }
@@ -246,22 +254,21 @@ class Download {
     return undefined;
   }
 
-  private setDone(sizeBytes: number) {
+  private setDone(size: number) {
     this.done = true;
-    this.sizeBytes = sizeBytes;
-    this.change.markChanged();
-  }
-
-  abort(reason: string) {
-    this.signalCtl.abort(new URLAborted(reason));
+    this.size = size;
   }
 
   private setError(e: any) {
     this.error = String(e);
-    this.change.markChanged();
+  }
+
+  abort(reason: string) {
+    this.signalCtl.abort(new URLAborted(reason));
   }
 }
 
+/** Throws when a downloading aborts. */
 class URLAborted extends Error {}
 
 /** Gets a directory size by calculating sizes recursively. */

package/src/drivers/helpers/download_local_handle.ts

@@ -0,0 +1,29 @@
+/** 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';
+
+// https://regex101.com/r/kfnBVX/1
+const localHandleRegex = /^blob\+local:\/\/download\/(?<path>.*)#(?<signature>.*)$/;
+
+export function newLocalHandle(path: string, signer: Signer): LocalBlobHandle {
+  return `blob+local://download/${path}#${signer.sign(path)}` as LocalBlobHandle;
+}
+
+export function isLocalBlobHandle(handle: string): handle is LocalBlobHandle {
+  return Boolean(handle.match(localHandleRegex));
+}
+
+export function parseLocalHandle(handle: LocalBlobHandle, signer: Signer) {
+  const parsed = handle.match(localHandleRegex);
+
+  if (parsed === null) {
+    throw new Error(`Local handle is malformed: ${handle}, matches: ${parsed}`);
+  }
+
+  const { path, signature } = parsed.groups!;
+  signer.verify(path, signature, `Signature verification failed for: ${handle}`);
+
+  return { path, signature };
+}

package/src/drivers/helpers/download_remote_handle.ts

@@ -0,0 +1,40 @@
+/** 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 { bigintToResourceId } from '@milaboratories/pl-client';
+
+// https://regex101.com/r/rvbPZt/1
+const remoteHandleRegex =
+  /^blob\+remote:\/\/download\/(?<content>(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*))#(?<signature>.*)$/;
+
+export function newRemoteHandle(
+  rInfo: OnDemandBlobResourceSnapshot,
+  signer: Signer
+): RemoteBlobHandle {
+  const content = `${rInfo.type.name}/${rInfo.type.version}/${BigInt(rInfo.id)}`;
+  return `blob+remote://download/${content}#${signer.sign(content)}` as RemoteBlobHandle;
+}
+
+export function isRemoteBlobHandle(handle: string): handle is RemoteBlobHandle {
+  return Boolean(handle.match(remoteHandleRegex));
+}
+
+export function parseRemoteHandle(handle: RemoteBlobHandle, signer: Signer): ResourceInfo {
+  const parsed = handle.match(remoteHandleRegex);
+  if (parsed === null) {
+    throw new Error(`Remote handle is malformed: ${handle}, matches: ${parsed}`);
+  }
+
+  const { content, resourceType, resourceVersion, resourceId, signature } = parsed.groups!;
+
+  signer.verify(content, signature, `Signature verification failed for ${handle}`);
+
+  return {
+    id: bigintToResourceId(BigInt(resourceId)),
+    type: { name: resourceType, version: resourceVersion }
+  };
+}

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

@@ -1,22 +1,23 @@
-import { CachedFile, FilesCache } from './files_cache';
+import { expect, test } from '@jest/globals';
 import { CallersCounter } from '@milaboratories/ts-helpers';
+import { CachedFile, 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);
   const callerId1 = 'callerId1';
   const blob1: CachedFile = {
     path: 'path1',
-    sizeBytes: 5,
+    size: 5,
     counter: new CallersCounter()
   };
   const blob2: CachedFile = {
     path: 'path2',
-    sizeBytes: 10,
+    size: 10,
     counter: new CallersCounter()
   };
   const blob3: CachedFile = {
     path: 'path3',
-    sizeBytes: 10,
+    size: 10,
     counter: new CallersCounter()
   };
 
@@ -51,12 +52,12 @@ test('regression should allow to add empty files', () => {
   const callerId1 = 'callerId1';
   const blob1: CachedFile = {
     path: 'path1',
-    sizeBytes: 0,
+    size: 0,
     counter: new CallersCounter()
   };
   const blob2: CachedFile = {
     path: 'path2',
-    sizeBytes: 2,
+    size: 2,
     counter: new CallersCounter()
   };
 

package/src/drivers/helpers/files_cache.ts

@@ -3,7 +3,8 @@ import { CallersCounter, mapEntries, mapGet } from '@milaboratories/ts-helpers';
 type PathLike = string;
 
 export interface CachedFile {
-  sizeBytes: number;
+  /** Size in bytes. */
+  size: number;
   path: PathLike;
   counter: CallersCounter;
 }
@@ -50,7 +51,7 @@ export class FilesCache<T extends CachedFile> {
       .forEach(([path, _]) => {
         if (this.totalSizeBytes - freedBytes <= this.softSizeBytes) return;
         const file = mapGet(this.cache, path);
-        freedBytes += file.sizeBytes;
+        freedBytes += file.size;
         result.push(file);
       });
 
@@ -62,13 +63,13 @@ export class FilesCache<T extends CachedFile> {
     this.cache.set(file.path, file);
     file.counter.inc(callerId);
 
-    if (file.sizeBytes < 0) throw new Error(`empty sizeBytes: ${file}`);
+    if (file.size < 0) throw new Error(`empty sizeBytes: ${file}`);
 
-    if (created) this.totalSizeBytes += file.sizeBytes;
+    if (created) this.totalSizeBytes += file.size;
   }
 
   removeCache(file: T) {
     this.cache.delete(file.path);
-    this.totalSizeBytes -= file.sizeBytes;
+    this.totalSizeBytes -= file.size;
   }
 }

package/src/drivers/helpers/helpers.ts

@@ -1,37 +1,14 @@
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import { ClientLogs } from '../../clients/logs';
 import {
-  PlClient,
-  ResourceId,
   BasicResourceData,
+  getField,
   isNullResourceId,
-  valErr,
-  getField
+  PlClient,
+  ResourceId,
+  valErr
 } from '@milaboratories/pl-client';
-import { scheduler } from 'node:timers/promises';
-import { ResourceInfo } from '@milaboratories/pl-tree';
-
-// TODO: remove this when we switch to refreshState.
-
-/** It's an Updater but for tasks that happens in a while loop with sleeping between. */
-export class LongUpdater {
-  private updater: Updater;
-
-  constructor(
-    private readonly onUpdate: () => Promise<boolean>,
-    private readonly sleepMs: number
-  ) {
-    this.updater = new Updater(async () => {
-      while (true) {
-        const done = await this.onUpdate();
-        if (done) return;
-        await scheduler.wait(this.sleepMs);
-      }
-    });
-  }
 
-  schedule = () => this.updater.schedule();
-}
+/** Throws when a driver gets a resource with a wrong resource type. */
+export class WrongResourceTypeError extends Error {}
 
 /** Updater incorporates a pattern when someone wants to run a callback
  * that updates something only when it's not already running. */
@@ -54,74 +31,3 @@ export class Updater {
     }
   }
 }
-
-// TODO: remove all the code below to the computable that calculates Mixcr logs.
-
-export async function getStream(
-  client: PlClient,
-  streamManagerId: ResourceId
-): Promise<BasicResourceData | undefined> {
-  return client.withReadTx('LogsDriverGetStream', async (tx) => {
-    const sm = await tx.getResourceData(streamManagerId, true);
-    const stream = await valErr(tx, getField(sm, 'stream'));
-    if (stream.error != '') {
-      throw new Error(`while getting stream: ${stream.error}`);
-    }
-    if (isNullResourceId(stream.valueId)) return undefined;
-
-    return await tx.getResourceData(stream.valueId, false);
-  });
-}
-
-export type MixcrProgressResponse = { found: false } | ({ found: true } & MixcrProgressLine);
-
-export type MixcrProgressLine = {
-  stage: string; // Building pre-clones from tag groups
-  progress: string; // 35.3%
-  eta: string; // ETA: 00:00:07
-};
-
-/** Is set by a template code.
- * Mixcr adds this prefix to every log line that contains a progress. */
-const mixcrProgressPrefix = '8C7#F1328%9E089B3D22';
-const mixcrProgressRegex = /(?<stage>.*):\s*(?<progress>[\d.]+%)\s.*(?<eta>ETA:.*)/g;
-
-export function lineToProgress(line: string): MixcrProgressLine | undefined {
-  const noPrefix = line.replace(mixcrProgressPrefix, '');
-  const parsed = noPrefix.match(mixcrProgressRegex);
-
-  if (parsed == null || parsed.length != 4) {
-    return undefined;
-  }
-
-  const [_, stage, progress, eta] = parsed;
-
-  return {
-    stage, // For example, 'Building pre-clones from tag groups'
-    progress, // 35.3%
-    eta // ETA: 00:00:07
-  };
-}
-
-export async function mixcrProgressFromLogs(
-  rInfo: ResourceInfo,
-  client: ClientLogs,
-  options?: RpcOptions
-): Promise<MixcrProgressResponse> {
-  const lastLines = await client.lastLines(rInfo, 1, 0n, mixcrProgressPrefix, options);
-  if (lastLines.data == null || lastLines.data.length == 0) {
-    return { found: false };
-  }
-
-  const line = lastLines.data.toString().split(/\r?\n/)[0];
-  if (line == undefined) {
-    return { found: false };
-  }
-
-  const progress = lineToProgress(line);
-  if (progress === undefined) {
-    return { found: false };
-  }
-
-  return { found: true, ...progress };
-}

package/src/drivers/helpers/logs_handle.ts

@@ -0,0 +1,52 @@
+/** 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 { bigintToResourceId } from '@milaboratories/pl-client';
+
+export function newLogHandle(live: boolean, rInfo: ResourceInfo): sdk.AnyLogHandle {
+  if (live) {
+    return `log+live://log/${rInfo.type.name}/${rInfo.type.version}/${BigInt(rInfo.id)}` as sdk.LiveLogHandle;
+  }
+
+  return `log+ready://log/${rInfo.type.name}/${rInfo.type.version}/${BigInt(rInfo.id)}` as sdk.ReadyLogHandle;
+}
+
+/** Handle of the live logs of a program.
+ * 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 function isLiveLogHandle(handle: string): handle is sdk.LiveLogHandle {
+  return liveHandleRegex.test(handle);
+}
+
+/** Handle of the ready logs of a program. */
+
+export const readyHandleRegex =
+  /^log\+ready:\/\/log\/(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*)$/;
+
+export function isReadyLogHandle(handle: string): handle is sdk.ReadyLogHandle {
+  return readyHandleRegex.test(handle);
+}
+
+export function getResourceInfoFromLogHandle(handle: sdk.AnyLogHandle): ResourceInfo {
+  let parsed: RegExpMatchArray | null;
+
+  if (isLiveLogHandle(handle)) {
+    parsed = handle.match(liveHandleRegex);
+  } else if (isReadyLogHandle(handle)) {
+    parsed = handle.match(readyHandleRegex);
+  } else throw new Error(`Log handle is malformed: ${handle}`);
+  if (parsed == null) throw new Error(`Log handle wasn't parsed: ${handle}`);
+
+  const { resourceType, resourceVersion, resourceId } = parsed.groups!;
+
+  return {
+    id: bigintToResourceId(BigInt(resourceId)),
+    type: { name: resourceType, version: resourceVersion }
+  };
+}

package/src/drivers/helpers/ls_remote_import_handle.ts

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