@milaboratories/pl-drivers 1.5.69 → 1.5.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-drivers",
-  "version": "1.5.69",
+  "version": "1.5.71",
   "engines": {
     "node": ">=20"
   },
@@ -31,12 +31,12 @@
     "undici": "~7.10.0",
     "zod": "~3.23.8",
     "upath": "^2.0.1",
+    "@milaboratories/helpers": "^1.6.14",
     "@milaboratories/ts-helpers": "^1.4.0",
-    "@milaboratories/helpers": "^1.6.13",
     "@milaboratories/computable": "^2.5.0",
-    "@milaboratories/pl-tree": "^1.6.9",
-    "@milaboratories/pl-model-common": "^1.15.5",
-    "@milaboratories/pl-client": "^2.11.0"
+    "@milaboratories/pl-tree": "^1.6.10",
+    "@milaboratories/pl-client": "^2.11.1",
+    "@milaboratories/pl-model-common": "^1.15.5"
   },
   "devDependencies": {
     "eslint": "^9.25.1",

package/src/clients/constructors.ts

@@ -1,4 +1,4 @@
-import type { PlClient } from '@milaboratories/pl-client';
+import type { GrpcClientProviderFactory, PlClient } from '@milaboratories/pl-client';
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { Dispatcher } from 'undici';
@@ -16,39 +16,39 @@ export function createDownloadClient(
 ) {
   return client.getDriver({
     name: 'DownloadBlob',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientDownload(grpcTransport, httpDispatcher, logger, localProjections),
+    init: (_: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher) =>
+      new ClientDownload(grpcClientProviderFactory, httpDispatcher, logger, localProjections),
   });
 }
 
 export function createLogsClient(client: PlClient, logger: MiLogger) {
   return client.getDriver({
     name: 'StreamLogs',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientLogs(grpcTransport, httpDispatcher, logger),
+    init: (_: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher) =>
+      new ClientLogs(grpcClientProviderFactory, httpDispatcher, logger),
   });
 }
 
 export function createUploadProgressClient(client: PlClient, logger: MiLogger) {
   return client.getDriver({
     name: 'UploadProgress',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientProgress(grpcTransport, httpDispatcher, client, logger),
+    init: (_: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher) =>
+      new ClientProgress(grpcClientProviderFactory, httpDispatcher, client, logger),
   });
 }
 
 export function createUploadBlobClient(client: PlClient, logger: MiLogger) {
   return client.getDriver({
     name: 'UploadBlob',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientUpload(grpcTransport, httpDispatcher, client, logger),
+    init: (_: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher) =>
+      new ClientUpload(grpcClientProviderFactory, httpDispatcher, client, logger),
   });
 }
 
 export function createLsFilesClient(client: PlClient, logger: MiLogger) {
   return client.getDriver({
     name: 'LsFiles',
-    init: (_client: PlClient, grpcTransport: GrpcTransport, _httpDispatcher: Dispatcher) =>
-      new ClientLs(grpcTransport, logger),
+    init: (_client: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, _httpDispatcher: Dispatcher) =>
+      new ClientLs(grpcClientProviderFactory, logger),
   });
 }

package/src/clients/download.ts

@@ -1,8 +1,8 @@
 /* eslint-disable n/no-unsupported-features/node-builtins */
+import type { GrpcClientProvider, GrpcClientProviderFactory } from '@milaboratories/pl-client';
 import { addRTypeToMetadata } from '@milaboratories/pl-client';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 import type { MiLogger } from '@milaboratories/ts-helpers';
-import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import * as fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
@@ -20,20 +20,20 @@ import { toHeadersMap } from './helpers';
 /** Gets URLs for downloading from pl-core, parses them and reads or downloads
  * files locally and from the web. */
 export class ClientDownload {
-  public readonly grpcClient: DownloadClient;
+  public readonly grpcClient: GrpcClientProvider<DownloadClient>;
   private readonly remoteFileDownloader: RemoteFileDownloader;
 
   /** Helps to find a storage root directory by a storage id from URL scheme. */
   private readonly localStorageIdsToRoot: Map<string, string>;
 
   constructor(
-    public readonly grpcTransport: GrpcTransport,
+    grpcClientProviderFactory: GrpcClientProviderFactory,
     public readonly httpClient: Dispatcher,
     public readonly logger: MiLogger,
     /** Pl storages available locally */
     localProjections: LocalStorageProjection[],
   ) {
-    this.grpcClient = new DownloadClient(this.grpcTransport);
+    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new DownloadClient(transport));
     this.remoteFileDownloader = new RemoteFileDownloader(httpClient);
     this.localStorageIdsToRoot = newLocalStorageIdsToRoot(localProjections);
   }
@@ -84,7 +84,7 @@ export class ClientDownload {
     const withAbort = options ?? {};
     withAbort.abort = signal;
 
-    return await this.grpcClient.getDownloadURL(
+    return await this.grpcClient.get().getDownloadURL(
       { resourceId: id },
       addRTypeToMetadata(type, withAbort),
     ).response;

package/src/clients/logs.ts

@@ -1,22 +1,22 @@
 import { StreamingClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client';
-import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import { notEmpty } from '@milaboratories/ts-helpers';
 import type { Dispatcher } from 'undici';
+import type { GrpcClientProvider, GrpcClientProviderFactory } from '@milaboratories/pl-client';
 import { addRTypeToMetadata } from '@milaboratories/pl-client';
 import type { StreamingAPI_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 
 export class ClientLogs {
-  public readonly grpcClient: StreamingClient;
+  public readonly grpcClient: GrpcClientProvider<StreamingClient>;
 
   constructor(
-    public readonly grpcTransport: GrpcTransport,
+    grpcClientProviderFactory: GrpcClientProviderFactory,
     public readonly httpClient: Dispatcher,
     public readonly logger: MiLogger,
   ) {
-    this.grpcClient = new StreamingClient(this.grpcTransport);
+    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new StreamingClient(transport));
   }
 
   close() {}
@@ -32,7 +32,7 @@ export class ClientLogs {
     options?: RpcOptions,
   ): Promise<StreamingAPI_Response> {
     return (
-      await this.grpcClient.lastLines(
+      await this.grpcClient.get().lastLines(
         {
           resourceId: rId,
           lineCount: lineCount,
@@ -55,7 +55,7 @@ export class ClientLogs {
     options?: RpcOptions,
   ): Promise<StreamingAPI_Response> {
     return (
-      await this.grpcClient.readText(
+      await this.grpcClient.get().readText(
         {
           resourceId: notEmpty(rId),
           readLimit: BigInt(lineCount),

package/src/clients/ls_api.ts

@@ -1,19 +1,19 @@
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import type { LsAPI_List_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol';
 import { LSClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol.client';
-import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
+import type { GrpcClientProvider, GrpcClientProviderFactory } from '@milaboratories/pl-client';
 import { addRTypeToMetadata } from '@milaboratories/pl-client';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 
 export class ClientLs {
-  private readonly grpcClient: LSClient;
+  private readonly grpcClient: GrpcClientProvider<LSClient>;
 
   constructor(
-    grpcTransport: GrpcTransport,
+    grpcClientProviderFactory: GrpcClientProviderFactory,
     private readonly logger: MiLogger,
   ) {
-    this.grpcClient = new LSClient(grpcTransport);
+    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new LSClient(transport));
   }
 
   close() {}
@@ -23,7 +23,7 @@ export class ClientLs {
     path: string,
     options?: RpcOptions,
   ): Promise<LsAPI_List_Response> {
-    return await this.grpcClient.list(
+    return await this.grpcClient.get().list(
       {
         resourceId: rInfo.id,
         location: path,

package/src/clients/progress.ts

@@ -2,7 +2,7 @@ import { ProgressClient } from '../proto/github.com/milaboratory/pl/controllers/
 import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import { Duration } from '../proto/google/protobuf/duration';
-import type { PlClient } from '@milaboratories/pl-client';
+import type { GrpcClientProvider, GrpcClientProviderFactory, PlClient } from '@milaboratories/pl-client';
 import { addRTypeToMetadata } from '@milaboratories/pl-client';
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import { notEmpty } from '@milaboratories/ts-helpers';
@@ -21,22 +21,22 @@ export type ProgressStatus = {
 // When blobs are transfered, one can got a status of transfering
 // using this API.
 export class ClientProgress {
-  public readonly grpcClient: ProgressClient;
+  public readonly grpcClient: GrpcClientProvider<ProgressClient>;
 
   constructor(
-    public readonly grpcTransport: GrpcTransport,
+    grpcClientProviderFactory: GrpcClientProviderFactory,
     _: Dispatcher,
     public readonly client: PlClient,
     public readonly logger: MiLogger,
   ) {
-    this.grpcClient = new ProgressClient(this.grpcTransport);
+    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new ProgressClient(transport));
   }
 
   close() {}
 
   /** getStatus gets a progress status by given rId and rType. */
   async getStatus({ id, type }: ResourceInfo, options?: RpcOptions): Promise<ProgressStatus> {
-    const status = await this.grpcClient.getStatus(
+    const status = await this.grpcClient.get().getStatus(
       { resourceId: id },
       addRTypeToMetadata(type, options),
     );
@@ -68,7 +68,7 @@ export class ClientProgress {
     });
 
     try {
-      const { responses } = this.grpcClient.realtimeStatus(
+      const { responses } = this.grpcClient.get().realtimeStatus(
         {
           resourceId: id,
           updateInterval: updateInterval,

package/src/clients/upload.ts

@@ -1,8 +1,7 @@
-import type { PlClient, ResourceId, ResourceType } from '@milaboratories/pl-client';
+import type { GrpcClientProvider, GrpcClientProviderFactory, PlClient, ResourceId, ResourceType } from '@milaboratories/pl-client';
 import { addRTypeToMetadata } from '@milaboratories/pl-client';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 import type { MiLogger } from '@milaboratories/ts-helpers';
-import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import * as fs from 'node:fs/promises';
 import type { Dispatcher } from 'undici';
@@ -33,15 +32,15 @@ export class NoFileForUploading extends Error {
  * The user should pass here a concrete BlobUpload/<storageId> resource,
  * it can be got from handle field of BlobUpload. */
 export class ClientUpload {
-  private readonly grpcClient: UploadClient;
+  private readonly grpcClient: GrpcClientProvider<UploadClient>;
 
   constructor(
-    public readonly grpcTransport: GrpcTransport,
+    grpcClientProviderFactory: GrpcClientProviderFactory,
     public readonly httpClient: Dispatcher,
     _: PlClient,
     public readonly logger: MiLogger,
   ) {
-    this.grpcClient = new UploadClient(this.grpcTransport);
+    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new UploadClient(transport));
   }
 
   close() {}
@@ -126,7 +125,7 @@ export class ClientUpload {
   }
 
   private async grpcInit(id: ResourceId, type: ResourceType, options?: RpcOptions) {
-    return await this.grpcClient.init({ resourceId: id }, addRTypeToMetadata(type, options))
+    return await this.grpcClient.get().init({ resourceId: id }, addRTypeToMetadata(type, options))
       .response;
   }
 
@@ -136,7 +135,7 @@ export class ClientUpload {
     uploadedPartSize: bigint,
     options?: RpcOptions,
   ) {
-    return await this.grpcClient.getPartURL(
+    return await this.grpcClient.get().getPartURL(
       { resourceId: id, partNumber, uploadedPartSize },
       addRTypeToMetadata(type, options),
     ).response;
@@ -147,7 +146,7 @@ export class ClientUpload {
     bytesProcessed: bigint,
     options?: RpcOptions,
   ) {
-    await this.grpcClient.updateProgress(
+    await this.grpcClient.get().updateProgress(
       {
         resourceId: id,
         bytesProcessed,
@@ -157,7 +156,7 @@ export class ClientUpload {
   }
 
   private async grpcFinalize({ id, type }: ResourceInfo, options?: RpcOptions) {
-    return await this.grpcClient.finalize({ resourceId: id }, addRTypeToMetadata(type, options))
+    return await this.grpcClient.get().finalize({ resourceId: id }, addRTypeToMetadata(type, options))
       .response;
   }
 }