@milaboratories/pl-client 2.7.13 → 2.8.0

package/src/core/default_client.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
-import { AuthInformation, plAddressToConfig, PlClientConfig } from './config';
+import type { AuthInformation, PlClientConfig } from './config';
+import { plAddressToConfig } from './config';
 import canonicalize from 'canonicalize';
 import YAML from 'yaml';
 import * as os from 'node:os';
@@ -7,7 +8,7 @@ import * as path from 'node:path';
 import { notEmpty } from '@milaboratories/ts-helpers';
 import { UnauthenticatedPlClient } from './unauth_client';
 import { PlClient } from './client';
-import { createHash } from 'crypto';
+import { createHash } from 'node:crypto';
 import { inferAuthRefreshTime } from './auth';
 
 const CONFIG_FILE_LOCAL_JSON = 'pl.json';
@@ -18,7 +19,7 @@ const CONF_FILE_SEQUENCE = [
   CONFIG_FILE_LOCAL_JSON,
   CONFIG_FILE_LOCAL_YAML,
   CONFIG_FILE_USER_JSON,
-  CONFIG_FILE_USER_YAML
+  CONFIG_FILE_USER_YAML,
 ];
 
 const AUTH_DATA_FILE = '.pl_auth.json';
@@ -44,7 +45,7 @@ const FILE_CONFIG_OVERRIDE_FIELDS: FileConfigOverrideFields[] = [
   'defaultRWTransactionTimeout',
   'defaultRequestTimeout',
   'authTTLSeconds',
-  'authMaxRefreshSeconds'
+  'authMaxRefreshSeconds',
 ];
 
 type PlConfigFile = {
@@ -70,7 +71,7 @@ export function tryGetFileConfig(): [PlConfigFile, string] | undefined {
 
 function saveAuthInfoCallback(
   confHash: string,
-  authMaxRefreshSeconds: number
+  authMaxRefreshSeconds: number,
 ): (newAuthInfo: AuthInformation) => void {
   return (newAuthInfo) => {
     fs.writeFileSync(
@@ -79,10 +80,10 @@ function saveAuthInfoCallback(
         JSON.stringify({
           confHash,
           authInformation: newAuthInfo,
-          expiration: inferAuthRefreshTime(newAuthInfo, authMaxRefreshSeconds)
-        } as AuthCache)
+          expiration: inferAuthRefreshTime(newAuthInfo, authMaxRefreshSeconds),
+        } as AuthCache),
       ),
-      'utf8'
+      'utf8',
     );
   };
 }
@@ -109,7 +110,7 @@ export async function defaultPlClient(): Promise<PlClient> {
   }
 
   if (config === undefined)
-    throw new Error("Can't find configuration to create default platform client.");
+    throw new Error('Can\'t find configuration to create default platform client.');
 
   if (process.env.PL_USER !== undefined) config.user = process.env.PL_USER;
 
@@ -147,17 +148,17 @@ export async function defaultPlClient(): Promise<PlClient> {
         JSON.stringify({
           confHash,
           authInformation,
-          expiration: inferAuthRefreshTime(authInformation, config.authMaxRefreshSeconds)
-        } as AuthCache)
+          expiration: inferAuthRefreshTime(authInformation, config.authMaxRefreshSeconds),
+        } as AuthCache),
       ),
-      'utf8'
+      'utf8',
     );
   }
 
   return await PlClient.init(config, {
     authInformation,
-    onUpdate: (newAuthInfo) => saveAuthInfoCallback(confHash, config!.authMaxRefreshSeconds),
+    onUpdate: (_newAuthInfo) => saveAuthInfoCallback(confHash, config.authMaxRefreshSeconds),
     onUpdateError: cleanAuthInfoCallback,
-    onAuthError: cleanAuthInfoCallback
+    onAuthError: cleanAuthInfoCallback,
   });
 }

package/src/core/driver.ts

@@ -1,8 +1,8 @@
-import { PlClient } from './client';
-import { GrpcTransport } from '@protobuf-ts/grpc-transport';
+import type { PlClient } from './client';
+import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import { Dispatcher } from 'undici';
-import { ResourceType } from './types';
+import type { Dispatcher } from 'undici';
+import type { ResourceType } from './types';
 
 /** Drivers must implement this interface */
 export interface PlDriver {

package/src/core/errors.ts

@@ -1,4 +1,4 @@
-import { Status } from '../proto/github.com/googleapis/googleapis/google/rpc/status';
+import type { Status } from '../proto/github.com/googleapis/googleapis/google/rpc/status';
 import { Aborted } from '@milaboratories/ts-helpers';
 
 export function isConnectionProblem(err: unknown, nested: boolean = false): boolean {
@@ -23,8 +23,8 @@ export function isTimeoutOrCancelError(err: unknown, nested: boolean = false): b
   if (err instanceof Aborted || (err as any).name == 'AbortError') return true;
   if ((err as any).code == 'ABORT_ERR') return true;
   if (
-    (err as any).name == 'RpcError' &&
-    ((err as any).code == 'CANCELLED' || (err as any).code == 'DEADLINE_EXCEEDED')
+    (err as any).name == 'RpcError'
+    && ((err as any).code == 'CANCELLED' || (err as any).code == 'DEADLINE_EXCEEDED')
   )
     return true;
   if ((err as any).cause !== undefined && !nested)

package/src/core/final.ts

@@ -1,10 +1,12 @@
-import { Optional } from 'utility-types';
-import {
+import type { Optional } from 'utility-types';
+import type {
   BasicResourceData,
+  ResourceData,
+} from './types';
+import {
   getField,
   isNotNullResourceId,
   isNullResourceId,
-  ResourceData
 } from './types';
 
 /**
@@ -41,13 +43,14 @@ const unknownResourceTypeNames = new Set<string>();
 /** Default implementation, defining behaviour for built-in resource types. */
 export const DefaultFinalResourceDataPredicate: FinalResourceDataPredicate = (r): boolean => {
   switch (r.type.name) {
-    case 'StreamManager':
+    case 'StreamManager': {
       if (!readyOrDuplicateOrError(r)) return false;
       if (r.fields === undefined) return true; // if fields are not provided basic resource state is not expected to change in the future
       if (isNotNullResourceId(r.error)) return true;
       const downloadable = getField(r as ResourceData, 'downloadable');
       const stream = getField(r as ResourceData, 'stream');
       return stream.value === downloadable.value;
+    }
     case 'StdMap':
     case 'std/map':
     case 'EphStdMap':

package/src/core/ll_client.ts

@@ -1,22 +1,24 @@
 import { PlatformClient } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api.client';
+import type { ClientOptions, Interceptor } from '@grpc/grpc-js';
 import {
   ChannelCredentials,
   InterceptingCall,
-  Interceptor,
-  status as GrpcStatus
+  status as GrpcStatus,
+  compressionAlgorithms,
 } from '@grpc/grpc-js';
-import {
+import type {
   AuthInformation,
   AuthOps,
-  plAddressToConfig,
   PlClientConfig,
   PlConnectionStatus,
-  PlConnectionStatusListener
+  PlConnectionStatusListener,
 } from './config';
-import { GrpcOptions, GrpcTransport } from '@protobuf-ts/grpc-transport';
+import { plAddressToConfig } from './config';
+import type { GrpcOptions } from '@protobuf-ts/grpc-transport';
+import { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import { LLPlTransaction } from './ll_transaction';
 import { parsePlJwt } from '../util/pl';
-import { Dispatcher } from 'undici';
+import type { Dispatcher } from 'undici';
 import { inferAuthRefreshTime } from './auth';
 import { defaultHttpDispatcher } from '@milaboratories/pl-http';
 
@@ -43,38 +45,63 @@ export class LLPlClient {
   private _status: PlConnectionStatus = 'OK';
   private readonly statusListener?: PlConnectionStatusListener;
 
-  public readonly grpcTransport: GrpcTransport;
-  public readonly grpcPl: PlatformClient;
+  private readonly grpcInterceptors: Interceptor[];
+  private _grpcTransport!: GrpcTransport;
+  private _grpcPl!: PlatformClient;
 
   public readonly httpDispatcher: Dispatcher;
 
   constructor(
     configOrAddress: PlClientConfig | string,
-    ops: {
+    private readonly ops: {
       auth?: AuthOps;
       statusListener?: PlConnectionStatusListener;
-    } = {}
+      shouldUseGzip?: boolean;
+    } = {},
   ) {
-    this.conf =
-      typeof configOrAddress === 'string' ? plAddressToConfig(configOrAddress) : configOrAddress;
+    this.conf
+      = typeof configOrAddress === 'string' ? plAddressToConfig(configOrAddress) : configOrAddress;
 
-    const grpcInterceptors: Interceptor[] = [];
+    this.grpcInterceptors = [];
 
-    const { auth, statusListener } = ops;
+    const { auth, statusListener, shouldUseGzip } = ops;
 
     if (auth !== undefined) {
       this.refreshTimestamp = inferAuthRefreshTime(
         auth.authInformation,
-        this.conf.authMaxRefreshSeconds
+        this.conf.authMaxRefreshSeconds,
       );
-      grpcInterceptors.push(this.createAuthInterceptor());
+      this.grpcInterceptors.push(this.createAuthInterceptor());
       this.authInformation = auth.authInformation;
       this.onAuthUpdate = auth.onUpdate;
       this.onAuthRefreshProblem = auth.onUpdateError;
       this.onAuthError = auth.onAuthError;
     }
 
-    grpcInterceptors.push(this.createErrorInterceptor());
+    this.grpcInterceptors.push(this.createErrorInterceptor());
+
+    // initialize _grpcTransport and _grpcPl
+    this.initGrpc(shouldUseGzip ?? false);
+
+    this.httpDispatcher = defaultHttpDispatcher(this.conf.httpProxy);
+
+    if (statusListener !== undefined) {
+      this.statusListener = statusListener;
+      statusListener(this._status);
+    }
+  }
+
+  /**
+   * Initializes (or reinitializes) _grpcTransport and _grpcPl
+   * @param gzip - whether to enable gzip compression
+   */
+  private initGrpc(gzip: boolean) {
+    const clientOptions: ClientOptions = {
+      'grpc.keepalive_time_ms': 30_000, // 30 seconds
+      'interceptors': this.grpcInterceptors,
+    };
+
+    if (gzip) clientOptions['grpc.default_compression_algorithm'] = compressionAlgorithms.gzip;
 
     //
     // Leaving it here for now
@@ -89,24 +116,26 @@ export class LLPlClient {
       channelCredentials: this.conf.ssl
         ? ChannelCredentials.createSsl()
         : ChannelCredentials.createInsecure(),
-      clientOptions: {
-        'grpc.keepalive_time_ms': 30_000, // 30 seconds
-        interceptors: grpcInterceptors
-      }
+      clientOptions,
     };
 
     if (this.conf.grpcProxy) process.env.grpc_proxy = this.conf.grpcProxy;
     else delete process.env.grpc_proxy;
 
-    this.grpcTransport = new GrpcTransport(grpcOptions);
-    this.grpcPl = new PlatformClient(this.grpcTransport);
+    const oldTransport = this._grpcTransport;
 
-    this.httpDispatcher = defaultHttpDispatcher(this.conf.httpProxy);
+    this._grpcTransport = new GrpcTransport(grpcOptions);
+    this._grpcPl = new PlatformClient(this._grpcTransport);
 
-    if (statusListener !== undefined) {
-      this.statusListener = statusListener;
-      statusListener(this._status);
-    }
+    if (oldTransport !== undefined) oldTransport.close();
+  }
+
+  public get grpcTransport(): GrpcTransport {
+    return this._grpcTransport;
+  }
+
+  public get grpcPl(): PlatformClient {
+    return this._grpcPl;
   }
 
   /** Returns true if client is authenticated. Even with anonymous auth information
@@ -142,27 +171,27 @@ export class LLPlClient {
 
   private refreshAuthInformationIfNeeded(): void {
     if (
-      this.refreshTimestamp === undefined ||
-      Date.now() < this.refreshTimestamp ||
-      this.authRefreshInProgress ||
-      this._status === 'Unauthenticated'
+      this.refreshTimestamp === undefined
+      || Date.now() < this.refreshTimestamp
+      || this.authRefreshInProgress
+      || this._status === 'Unauthenticated'
     )
       return;
 
-    // Running refresh in background
+    // Running refresh in background`
     this.authRefreshInProgress = true;
-    (async () => {
+    void (async () => {
       try {
         const response = await this.grpcPl.getJWTToken({
           expiration: {
             seconds: BigInt(this.conf.authTTLSeconds),
-            nanos: 0
-          }
+            nanos: 0,
+          },
         }).response;
         this.authInformation = { jwtToken: response.token };
         this.refreshTimestamp = inferAuthRefreshTime(
           this.authInformation,
-          this.conf.authMaxRefreshSeconds
+          this.conf.authMaxRefreshSeconds,
         );
         if (this.onAuthUpdate) this.onAuthUpdate(this.authInformation);
       } catch (e: unknown) {
@@ -187,9 +216,9 @@ export class LLPlClient {
                 // (!!!) don't change to "==="
                 this.updateStatus('Disconnected');
               next(status);
-            }
+            },
           });
-        }
+        },
       });
     };
   }
@@ -206,7 +235,7 @@ export class LLPlClient {
           } else {
             next(metadata, listener);
           }
-        }
+        },
       });
     };
   }
@@ -218,8 +247,8 @@ export class LLPlClient {
       return this.grpcPl.tx({
         abort: totalAbortSignal,
         timeout:
-          ops.timeout ??
-          (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout)
+          ops.timeout
+          ?? (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout),
       });
     });
   }

package/src/core/ll_transaction.ts

@@ -1,15 +1,15 @@
-import {
+import type {
   TxAPI_ClientMessage,
-  TxAPI_ServerMessage
+  TxAPI_ServerMessage,
 } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api';
-import { DuplexStreamingCall } from '@protobuf-ts/runtime-rpc';
+import type { DuplexStreamingCall } from '@protobuf-ts/runtime-rpc';
 import Denque from 'denque';
-import { Status } from '../proto/github.com/googleapis/googleapis/google/rpc/status';
+import type { Status } from '../proto/github.com/googleapis/googleapis/google/rpc/status';
 import {
   PlErrorCodeNotFound,
   RecoverablePlError,
   rethrowMeaningfulError,
-  UnrecoverablePlError
+  UnrecoverablePlError,
 } from './errors';
 
 export type ClientMessageRequest = TxAPI_ClientMessage['request'];
@@ -51,7 +51,7 @@ function createResponseHandler<Kind extends ServerMessageResponse['oneofKind']>(
   resolve:
     | ((v: OneOfKind<ServerMessageResponse, Kind>) => void)
     | ((v: OneOfKind<ServerMessageResponse, Kind>[]) => void),
-  reject: (e: Error) => void
+  reject: (e: Error) => void,
 ): AnyResponseHandler {
   return { kind, expectMultiResponse, resolve, reject } as AnyResponseHandler;
 }
@@ -108,7 +108,7 @@ export class LLPlTransaction {
 
   private assignErrorFactoryIfNotSet(
     errorFactory: () => never,
-    reject?: (e: Error) => void
+    reject?: (e: Error) => void,
   ): () => never {
     if (reject !== undefined) reject(new RethrowError(errorFactory));
     if (this.errorFactory) return errorFactory;
@@ -158,7 +158,7 @@ export class LLPlTransaction {
             currentHandler.reject(
               new RethrowError(() => {
                 throw new RecoverablePlError(status);
-              })
+              }),
             );
             currentHandler = undefined;
 
@@ -183,10 +183,10 @@ export class LLPlTransaction {
         }
 
         if (
-          currentHandler!.kind !== message.response.oneofKind &&
-          message?.multiMessage?.isEmpty !== true
+          currentHandler.kind !== message.response.oneofKind
+          && message?.multiMessage?.isEmpty !== true
         ) {
-          const errorMessage = `inconsistent request response types: ${currentHandler!.kind} !== ${message.response.oneofKind}`;
+          const errorMessage = `inconsistent request response types: ${currentHandler.kind} !== ${message.response.oneofKind}`;
 
           this.assignErrorFactoryIfNotSet(() => {
             throw new Error(errorMessage);
@@ -196,8 +196,8 @@ export class LLPlTransaction {
           break;
         }
 
-        if (currentHandler!.expectMultiResponse !== (message.multiMessage !== undefined)) {
-          const errorMessage = `inconsistent multi state: ${currentHandler!.expectMultiResponse} !== ${message.multiMessage !== undefined}`;
+        if (currentHandler.expectMultiResponse !== (message.multiMessage !== undefined)) {
+          const errorMessage = `inconsistent multi state: ${currentHandler.expectMultiResponse} !== ${message.multiMessage !== undefined}`;
 
           this.assignErrorFactoryIfNotSet(() => {
             throw new Error(errorMessage);
@@ -252,7 +252,7 @@ export class LLPlTransaction {
     this.closed = true;
 
     // Rejecting all messages
-    let handler: AnyResponseHandler | undefined = undefined;
+
     while (true) {
       const handler = this.responseHandlerQueue.shift();
       if (!handler) break;
@@ -294,7 +294,7 @@ export class LLPlTransaction {
   /** Generate proper client message and send it to the server, and returns a promise of future response. */
   public async send<Kind extends ClientMessageRequest['oneofKind']>(
     r: OneOfKind<ClientMessageRequest, Kind>,
-    expectMultiResponse: boolean
+    expectMultiResponse: boolean,
   ): Promise<OneOfKind<ServerMessageResponse, Kind> | OneOfKind<ServerMessageResponse, Kind>[]> {
     if (this.errorFactory) return Promise.reject(new RethrowError(this.errorFactory));
 
@@ -303,7 +303,7 @@ export class LLPlTransaction {
     // Note: Promise synchronously executes a callback passed to a constructor
     const result = new Promise<OneOfKind<ServerMessageResponse, Kind>>((resolve, reject) => {
       this.responseHandlerQueue.push(
-        createResponseHandler(r.oneofKind, expectMultiResponse, resolve, reject)
+        createResponseHandler(r.oneofKind, expectMultiResponse, resolve, reject),
       );
     });
 
@@ -311,7 +311,7 @@ export class LLPlTransaction {
     // There is no hurry, we are not going to receive a response until message is sent.
     await this.stream.requests.send({
       requestId: this.requestIdxCounter++,
-      request: r
+      request: r,
     });
 
     try {

package/src/core/stat.ts

@@ -60,7 +60,7 @@ export function initialTxStat(): TxStat {
     kvListEntries: 0,
     kvListBytes: 0,
     kvGetRequests: 0,
-    kvGetBytes: 0
+    kvGetBytes: 0,
   };
 }
 
@@ -91,7 +91,7 @@ export function addStat(a: TxStat, b: TxStat): TxStat {
     kvListEntries: a.kvListEntries + b.kvListEntries,
     kvListBytes: a.kvListBytes + b.kvListBytes,
     kvGetRequests: a.kvGetRequests + b.kvGetRequests,
-    kvGetBytes: a.kvGetBytes + b.kvGetBytes
+    kvGetBytes: a.kvGetBytes + b.kvGetBytes,
   };
 }