@milaboratories/pl-client 2.7.13 → 2.7.14

package/src/core/config.ts

@@ -108,7 +108,7 @@ type PlConfigOverrides = Partial<
 function parseInt(s: string | null | undefined): number | undefined {
   if (!s) return undefined;
   const num = Number(s);
-  if (num === Number.NaN) throw new Error(`Can't parse number: ${s}`);
+  if (Number.isNaN(num)) throw new Error(`Can't parse number: ${s}`);
   return num;
 }
 
@@ -116,7 +116,7 @@ function parseInt(s: string | null | undefined): number | undefined {
  * {@link PlClient} of {@link UnauthenticatedPlClient}. */
 export function plAddressToConfig(
   address: string,
-  overrides: PlConfigOverrides = {}
+  overrides: PlConfigOverrides = {},
 ): PlClientConfig {
   if (address.indexOf('://') === -1)
     // non-url address
@@ -140,16 +140,16 @@ export function plAddressToConfig(
       retryLinearBackoffStep: DEFAULT_RETRY_LINEAR_BACKOFF_STEP,
       retryJitter: DEFAULT_RETRY_JITTER,
 
-      ...overrides
+      ...overrides,
     };
 
   const url = new URL(address);
 
   if (
-    url.protocol !== 'https:' &&
-    url.protocol !== 'http:' &&
-    url.protocol !== 'grpc:' &&
-    url.protocol !== 'tls:'
+    url.protocol !== 'https:'
+    && url.protocol !== 'http:'
+    && url.protocol !== 'grpc:'
+    && url.protocol !== 'tls:'
   )
     throw new Error(`Unexpected URL schema: ${url.protocol}`);
 
@@ -163,13 +163,13 @@ export function plAddressToConfig(
     defaultRequestTimeout:
       parseInt(url.searchParams.get('request-timeout')) ?? DEFAULT_REQUEST_TIMEOUT,
     defaultROTransactionTimeout:
-      parseInt(url.searchParams.get('ro-tx-timeout')) ??
-      parseInt(url.searchParams.get('tx-timeout')) ??
-      DEFAULT_RO_TX_TIMEOUT,
+      parseInt(url.searchParams.get('ro-tx-timeout'))
+      ?? parseInt(url.searchParams.get('tx-timeout'))
+      ?? DEFAULT_RO_TX_TIMEOUT,
     defaultRWTransactionTimeout:
-      parseInt(url.searchParams.get('rw-tx-timeout')) ??
-      parseInt(url.searchParams.get('tx-timeout')) ??
-      DEFAULT_RW_TX_TIMEOUT,
+      parseInt(url.searchParams.get('rw-tx-timeout'))
+      ?? parseInt(url.searchParams.get('tx-timeout'))
+      ?? DEFAULT_RW_TX_TIMEOUT,
     authTTLSeconds: DEFAULT_TOKEN_TTL_SECONDS,
     authMaxRefreshSeconds: DEFAULT_AUTH_MAX_REFRESH,
     grpcProxy: url.searchParams.get('grpc-proxy') ?? undefined,
@@ -177,25 +177,25 @@ export function plAddressToConfig(
     user: url.username === '' ? undefined : url.username,
     password: url.password === '' ? undefined : url.password,
     txDelay: parseInt(url.searchParams.get('tx-delay')) ?? 0,
-    forceSync: Boolean(url.searchParams.get('force-sync')) ?? false,
+    forceSync: Boolean(url.searchParams.get('force-sync')),
 
     maxCacheBytes: parseInt(url.searchParams.get('max-cache-bytes')) ?? DEFAULT_MAX_CACHE_BYTES,
 
-    retryBackoffAlgorithm: (url.searchParams.get('retry-backoff-algorithm') ??
-      DEFAULT_RETRY_BACKOFF_ALGORITHM) as any,
+    retryBackoffAlgorithm: (url.searchParams.get('retry-backoff-algorithm')
+      ?? DEFAULT_RETRY_BACKOFF_ALGORITHM) as any,
     retryMaxAttempts:
       parseInt(url.searchParams.get('retry-max-attempts')) ?? DEFAULT_RETRY_MAX_ATTEMPTS,
     retryInitialDelay:
       parseInt(url.searchParams.get('retry-initial-delay')) ?? DEFAULT_RETRY_INITIAL_DELAY,
     retryExponentialBackoffMultiplier:
-      parseInt(url.searchParams.get('retry-exp-backoff-multiplier')) ??
-      DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER,
+      parseInt(url.searchParams.get('retry-exp-backoff-multiplier'))
+      ?? DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER,
     retryLinearBackoffStep:
-      parseInt(url.searchParams.get('retry-linear-backoff-step')) ??
-      DEFAULT_RETRY_LINEAR_BACKOFF_STEP,
+      parseInt(url.searchParams.get('retry-linear-backoff-step'))
+      ?? DEFAULT_RETRY_LINEAR_BACKOFF_STEP,
     retryJitter: parseInt(url.searchParams.get('retry-backoff-jitter')) ?? DEFAULT_RETRY_JITTER,
 
-    ...overrides
+    ...overrides,
   };
 }
 

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,26 @@
 import { PlatformClient } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api.client';
+import type {
+  Interceptor } from '@grpc/grpc-js';
 import {
   ChannelCredentials,
   InterceptingCall,
-  Interceptor,
-  status as GrpcStatus
+  status as GrpcStatus,
 } 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';
 
@@ -53,10 +57,10 @@ export class LLPlClient {
     ops: {
       auth?: AuthOps;
       statusListener?: PlConnectionStatusListener;
-    } = {}
+    } = {},
   ) {
-    this.conf =
-      typeof configOrAddress === 'string' ? plAddressToConfig(configOrAddress) : configOrAddress;
+    this.conf
+      = typeof configOrAddress === 'string' ? plAddressToConfig(configOrAddress) : configOrAddress;
 
     const grpcInterceptors: Interceptor[] = [];
 
@@ -65,7 +69,7 @@ export class LLPlClient {
     if (auth !== undefined) {
       this.refreshTimestamp = inferAuthRefreshTime(
         auth.authInformation,
-        this.conf.authMaxRefreshSeconds
+        this.conf.authMaxRefreshSeconds,
       );
       grpcInterceptors.push(this.createAuthInterceptor());
       this.authInformation = auth.authInformation;
@@ -91,8 +95,8 @@ export class LLPlClient {
         : ChannelCredentials.createInsecure(),
       clientOptions: {
         'grpc.keepalive_time_ms': 30_000, // 30 seconds
-        interceptors: grpcInterceptors
-      }
+        'interceptors': grpcInterceptors,
+      },
     };
 
     if (this.conf.grpcProxy) process.env.grpc_proxy = this.conf.grpcProxy;
@@ -142,27 +146,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 +191,9 @@ export class LLPlClient {
                 // (!!!) don't change to "==="
                 this.updateStatus('Disconnected');
               next(status);
-            }
+            },
           });
-        }
+        },
       });
     };
   }
@@ -206,7 +210,7 @@ export class LLPlClient {
           } else {
             next(metadata, listener);
           }
-        }
+        },
       });
     };
   }
@@ -218,8 +222,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,
   };
 }