@milaboratories/pl-client 2.16.13 → 2.16.14

package/src/core/ll_client.ts

@@ -26,7 +26,7 @@ import type { WireClientProvider, WireClientProviderFactory, WireConnection } fr
 import { parseHttpAuth } from '@milaboratories/pl-model-common';
 import type * as grpcTypes from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
 import { type PlApiPaths, type PlRestClientType, createClient, parseResponseError } from '../proto-rest';
-import { notEmpty } from '@milaboratories/ts-helpers';
+import { notEmpty, retry, withTimeout, type RetryOptions } from '@milaboratories/ts-helpers';
 import { Code } from '../proto-grpc/google/rpc/code';
 import { WebSocketBiDiStream } from './websocket_stream';
 import { TxAPI_ClientMessage, TxAPI_ServerMessage } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
@@ -54,8 +54,6 @@ class WireClientProviderImpl<Client> implements WireClientProvider<Client> {
 
 /** Abstract out low level networking and authorization details */
 export class LLPlClient implements WireClientProviderFactory {
-  public readonly conf: PlClientConfig;
-
   /** Initial authorization information */
   private authInformation?: AuthInformation;
   /** Will be executed by the client when it is required */
@@ -70,7 +68,7 @@ export class LLPlClient implements WireClientProviderFactory {
   private _status: PlConnectionStatus = 'OK';
   private readonly statusListener?: PlConnectionStatusListener;
 
-  private _wireProto: wireProtocol | undefined = undefined;
+  private _wireProto: wireProtocol = 'grpc';
   private _wireConn!: WireConnection;
 
   private readonly _restInterceptors: Dispatcher.DispatcherComposeInterceptor[];
@@ -82,18 +80,29 @@ export class LLPlClient implements WireClientProviderFactory {
 
   public readonly httpDispatcher: Dispatcher;
 
-  constructor(
+  public static async build(
     configOrAddress: PlClientConfig | string,
-    private readonly ops: {
+    ops: {
       auth?: AuthOps;
       statusListener?: PlConnectionStatusListener;
       shouldUseGzip?: boolean;
     } = {},
   ) {
-    this.conf = typeof configOrAddress === 'string'
-      ? plAddressToConfig(configOrAddress)
-      : configOrAddress;
+    const conf = typeof configOrAddress === 'string' ? plAddressToConfig(configOrAddress) : configOrAddress;
+
+    const pl = new LLPlClient(conf, ops);
+    await pl.detectOptimalWireProtocol();
+    return pl;
+  }
 
+  private constructor(
+    public readonly conf: PlClientConfig,
+    private readonly ops: {
+      auth?: AuthOps;
+      statusListener?: PlConnectionStatusListener;
+      shouldUseGzip?: boolean;
+    } = {},
+  ) {
     const { auth, statusListener } = ops;
 
     if (auth !== undefined) {
@@ -120,8 +129,11 @@ export class LLPlClient implements WireClientProviderFactory {
     this._grpcInterceptors.push(this.createGrpcErrorInterceptor());
 
     this.httpDispatcher = defaultHttpDispatcher(this.conf.httpProxy);
+    if (this.conf.wireProtocol) {
+      this._wireProto = this.conf.wireProtocol;
+    }
 
-    this.initWireConnection();
+    this.initWireConnection(this._wireProto);
 
     if (statusListener !== undefined) {
       this.statusListener = statusListener;
@@ -142,13 +154,8 @@ export class LLPlClient implements WireClientProviderFactory {
     });
   }
 
-  private initWireConnection() {
-    if (this._wireProto === undefined) {
-      // TODO: implement automatic server mode detection
-      this._wireProto = this.conf.wireProtocol ?? 'grpc';
-    }
-
-    switch (this._wireProto) {
+  private initWireConnection(protocol: wireProtocol) {
+    switch (protocol) {
       case 'rest':
         this.initRestConnection();
         return;
@@ -158,7 +165,7 @@ export class LLPlClient implements WireClientProviderFactory {
       default:
         ((v: never) => {
           throw new Error(`Unsupported wire protocol '${v as string}'. Use one of: ${SUPPORTED_WIRE_PROTOCOLS.join(', ')}`);
-        })(this._wireProto);
+        })(protocol);
     }
   }
 
@@ -221,6 +228,7 @@ export class LLPlClient implements WireClientProviderFactory {
   private _replaceWireConnection(newConn: WireConnection): void {
     const oldConn = this._wireConn;
     this._wireConn = newConn;
+    this._wireProto = newConn.type;
 
     // Reset all providers to let them reinitialize their clients
     for (let i = 0; i < this.providers.length; i++) {
@@ -269,6 +277,10 @@ export class LLPlClient implements WireClientProviderFactory {
     return this._wireConn;
   }
 
+  public get wireProtocol(): wireProtocol | undefined {
+    return this._wireProto;
+  }
+
   /** Returns true if client is authenticated. Even with anonymous auth information
    * connection is considered authenticated. Unauthenticated clients are used for
    * login and similar tasks, see {@link UnauthenticatedPlClient}. */
@@ -444,6 +456,32 @@ export class LLPlClient implements WireClientProviderFactory {
     }
   }
 
+  /**
+   * Detects the best available wire protocol.
+   * If wireProtocol is explicitly configured, does nothing.
+   * Otherwise probes the current protocol via ping; if it fails, switches to the alternative.
+   */
+  private async detectOptimalWireProtocol() {
+    if (this.conf.wireProtocol) {
+      return;
+    }
+
+    const retryOptions: RetryOptions = {
+      type: 'exponentialBackoff',
+      maxAttempts: 80,
+      initialDelay: 30,
+      backoffMultiplier: 1.3,
+      jitter: 0.2,
+      maxDelay: 500,
+    };
+
+    await retry(() => withTimeout(this.ping(), 500), retryOptions, () => {
+      const protocol = this._wireProto === 'grpc' ? 'rest' : 'grpc';
+      this.initWireConnection(protocol);
+      return true;
+    });
+  }
+
   public async license(): Promise<grpcTypes.MaintenanceAPI_License_Response> {
     const cl = this.clientProvider.get();
     if (cl instanceof GrpcPlApiClient) {

package/src/core/unauth_client.test.ts

@@ -1,16 +1,16 @@
 import { UnauthenticatedPlClient } from './unauth_client';
-import { getTestConfig } from '../test/test_config';
+import { getTestConfig, plAddressToTestConfig } from '../test/test_config';
 import { UnauthenticatedError } from './errors';
 import { test, expect } from 'vitest';
 
 test('ping test', async () => {
-  const client = new UnauthenticatedPlClient(getTestConfig().address);
+  const client = await UnauthenticatedPlClient.build(plAddressToTestConfig(getTestConfig().address));
   const response = await client.ping();
   expect(response).toHaveProperty('coreVersion');
 });
 
 test('get auth methods', async () => {
-  const client = new UnauthenticatedPlClient(getTestConfig().address);
+  const client = await UnauthenticatedPlClient.build(plAddressToTestConfig(getTestConfig().address));
   const response = await client.authMethods();
   expect(response).toHaveProperty('methods');
 });
@@ -21,7 +21,7 @@ test('wrong login', async () => {
     console.log('skipped');
     return;
   }
-  const client = new UnauthenticatedPlClient(testConfig.address);
+  const client = await UnauthenticatedPlClient.build(plAddressToTestConfig(testConfig.address));
   await expect(client.login(testConfig.test_user, testConfig.test_password + 'A')).rejects.toThrow(
     UnauthenticatedError
   );

package/src/core/unauth_client.ts

@@ -11,8 +11,13 @@ import { UnauthenticatedError } from './errors';
 export class UnauthenticatedPlClient {
   public readonly ll: LLPlClient;
 
-  constructor(configOrAddress: PlClientConfig | string) {
-    this.ll = new LLPlClient(configOrAddress);
+  private constructor(ll: LLPlClient) {
+    this.ll = ll;
+  }
+
+  public static async build(configOrAddress: PlClientConfig | string): Promise<UnauthenticatedPlClient> {
+    const ll = await LLPlClient.build(configOrAddress);
+    return new UnauthenticatedPlClient(ll);
   }
 
   public async ping(): Promise<MaintenanceAPI_Ping_Response> {

package/src/core/websocket_stream.ts

@@ -3,6 +3,7 @@ import type { BiDiStream } from './abstract_stream';
 import Denque from 'denque';
 import type { RetryConfig } from '../helpers/retry_strategy';
 import { RetryStrategy } from '../helpers/retry_strategy';
+import { DisconnectedError } from './errors';
 
 interface QueuedMessage<InType extends object> {
   message: InType;
@@ -183,6 +184,18 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
   private onClose(): void {
     this.progressConnectionState(ConnectionState.CLOSED);
 
+    // If abort signal was triggered, use that as the error source
+    if (this.options.abortSignal?.aborted && !this.lastError) {
+      const reason = this.options.abortSignal.reason;
+      if (reason instanceof Error) {
+        this.lastError = reason;
+      } else if (reason !== undefined) {
+        this.lastError = new Error(String(reason), { cause: reason });
+      } else {
+        this.lastError = this.createStreamClosedError();
+      }
+    }
+
     if (!this.lastError) {
       this.rejectAllSendOperations(this.createStreamClosedError());
       this.resolveAllPendingResponses(); // unblock active async iterator
@@ -380,7 +393,15 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
 
   private toError(error: unknown): Error {
     if (error instanceof Error) return error;
-    if (error instanceof ErrorEvent) return error.error;
+    if (error instanceof ErrorEvent) {
+      const err = error.error;
+      // undici WebSocket throws TypeError with empty message on socket close
+      // (e.g., when connection is lost or server disconnects)
+      if (err instanceof TypeError && !err.message) {
+        return new DisconnectedError('WebSocket connection closed unexpectedly');
+      }
+      return err instanceof Error ? err : new Error('WebSocket error', { cause: error });
+    }
     return new Error(String(error));
   }
 

package/src/test/test_config.ts

@@ -54,6 +54,16 @@ export function getTestConfig(): TestConfig {
   return conf as TestConfig;
 }
 
+/** Default request timeout for tests (ms) */
+export const TEST_REQUEST_TIMEOUT = 500;
+
+/** Returns PlClientConfig with reduced timeout for tests */
+export function plAddressToTestConfig(address: string): PlClientConfig {
+  const plConf = plAddressToConfig(address);
+  plConf.defaultRequestTimeout = TEST_REQUEST_TIMEOUT;
+  return plConf;
+}
+
 interface AuthCache {
   /** To check if config changed */
   conf: TestConfig;
@@ -109,9 +119,8 @@ export async function getTestClientConf(): Promise<{ conf: PlClientConfig; auth:
     }
   }
 
-  const plConf = plAddressToConfig(tConf.address);
-
-  const uClient = new UnauthenticatedPlClient(plConf);
+  const plConf = plAddressToTestConfig(tConf.address);
+  const uClient = await UnauthenticatedPlClient.build(plConf);
 
   const requireAuth = await uClient.requireAuth();
 
@@ -147,7 +156,7 @@ export async function getTestClientConf(): Promise<{ conf: PlClientConfig; auth:
 
 export async function getTestLLClient(confOverrides: Partial<PlClientConfig> = {}) {
   const { conf, auth } = await getTestClientConf();
-  return new LLPlClient({ ...conf, ...confOverrides }, { auth });
+  return await LLPlClient.build({ ...conf, ...confOverrides }, { auth });
 }
 
 export async function getTestClient(