@milaboratories/pl-client 2.16.12 → 2.16.14

package/src/core/ll_client.test.ts

@@ -1,5 +1,5 @@
 import { LLPlClient } from './ll_client';
-import { getTestConfig, getTestLLClient, getTestClientConf } from '../test/test_config';
+import { getTestConfig, plAddressToTestConfig, getTestLLClient, getTestClientConf } from '../test/test_config';
 import { TxAPI_Open_Request_WritableTx } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
 import { request } from 'undici';
 import * as tp from 'node:timers/promises';
@@ -29,7 +29,7 @@ test('unauthenticated status change', async () => {
     return;
   }
 
-  const client = new LLPlClient(cfg.address);
+  const client = await LLPlClient.build(plAddressToTestConfig(cfg.address));
   expect(client.status).toBe('OK');
 
   const tx = client.createTx(true);
@@ -54,10 +54,16 @@ test('unauthenticated status change', async () => {
 });
 
 test('automatic token update', async () => {
+  const cfg = getTestConfig();
+  if (cfg.test_password === undefined) {
+    console.log("skipping test because target server doesn't support authentication");
+    return;
+  }
+
   const { conf, auth } = await getTestClientConf();
   conf.authMaxRefreshSeconds = 1;
   let numberOfAuthUpdates = 0;
-  const client = new LLPlClient(conf, {
+  const client = await LLPlClient.build(conf, {
     auth: {
       authInformation: auth.authInformation,
       onUpdate: (auth) => {

package/src/core/ll_client.ts

@@ -26,9 +26,10 @@ 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';
 
 export interface PlCallOps {
   timeout?: number;
@@ -53,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 */
@@ -69,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[];
@@ -81,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) {
@@ -119,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;
@@ -141,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;
@@ -157,12 +165,12 @@ 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);
     }
   }
 
   private initRestConnection(): void {
-    const dispatcher = defaultHttpDispatcher(this.conf.httpProxy, this._restInterceptors);
+    const dispatcher = defaultHttpDispatcher(this.conf.grpcProxy, this._restInterceptors);
     this._replaceWireConnection({ type: 'rest', Config: this.conf, Dispatcher: dispatcher, Middlewares: this._restMiddlewares });
   }
 
@@ -220,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++) {
@@ -268,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}. */
@@ -443,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) {
@@ -490,22 +529,38 @@ export class LLPlClient implements WireClientProviderFactory {
         });
       }
 
-      if (this._wireProto === 'rest') {
+      const wireConn = this.wireConnection;
+      if (wireConn.type === 'rest') {
         // For REST/WebSocket protocol, timeout needs to be converted to AbortSignal
         if (timeout !== undefined) {
           totalAbortSignal = AbortSignal.any([totalAbortSignal, AbortSignal.timeout(timeout)]);
         }
+
+        // The gRPC transport has the auth interceptor that already handles it, but here we need to refresh the auth information to be safe.
+        this.refreshAuthInformationIfNeeded();
+
         const wsUrl = this.conf.ssl
           ? `wss://${this.conf.hostAndPort}/v1/ws/tx`
           : `ws://${this.conf.hostAndPort}/v1/ws/tx`;
 
-        // The gRPC transport has the auth interceptor that already handles it, so we need to refresh the auth information here.
-        this.refreshAuthInformationIfNeeded();
-        const jwtToken = this.authInformation?.jwtToken;
-
-        return new WebSocketBiDiStream(wsUrl, totalAbortSignal, jwtToken);
+        return new WebSocketBiDiStream(wsUrl,
+          (msg) => TxAPI_ClientMessage.toBinary(msg),
+          (data) => TxAPI_ServerMessage.fromBinary(new Uint8Array(data)),
+          {
+            abortSignal: totalAbortSignal,
+            jwtToken: this.authInformation?.jwtToken,
+            dispatcher: wireConn.Dispatcher,
+
+            onComplete: async (stream) => stream.requests.send({
+              // Ask server to gracefully close the stream on its side, if not done yet.
+              requestId: 0,
+              request: { oneofKind: 'streamClose', streamClose: {} },
+            }),
+          },
+        );
       }
-      throw new Error('tx is not supported for this wire protocol');
+
+      throw new Error(`transactions are not supported for wire protocol ${this._wireProto}`);
     });
   }
 

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.test.ts

@@ -82,7 +82,7 @@ import type { RetryConfig } from '../helpers/retry_strategy';
 type MockWS = InstanceType<typeof MockWebSocket>;
 
 interface StreamContext {
-  stream: WebSocketBiDiStream;
+  stream: WebSocketBiDiStream<ClientMessageType, ServerMessageType>;
   ws: MockWS;
   controller: AbortController;
 }
@@ -91,9 +91,13 @@ function createStream(token?: string, retryConfig?: Partial<RetryConfig>): Strea
   const controller = new AbortController();
   const stream = new WebSocketBiDiStream(
     'ws://localhost:8080',
-    controller.signal,
-    token,
-    retryConfig,
+    (message: ClientMessageType) => ClientMessageType.toBinary(message),
+    (data) => ServerMessageType.fromBinary(data),
+    {
+      abortSignal: controller.signal,
+      jwtToken: token,
+      retryConfig: retryConfig,
+    },
   );
   const ws = MockWebSocket.instances[MockWebSocket.instances.length - 1];
   return { stream, ws, controller };
@@ -115,7 +119,7 @@ function createClientMessage(): ClientMessageType {
 }
 
 async function collectMessages(
-  stream: WebSocketBiDiStream,
+  stream: WebSocketBiDiStream<ClientMessageType, ServerMessageType>,
   count: number,
 ): Promise<ServerMessageType[]> {
   const messages: ServerMessageType[] = [];
@@ -149,7 +153,14 @@ describe('WebSocketBiDiStream', () => {
       const controller = new AbortController();
       controller.abort();
 
-      new WebSocketBiDiStream('ws://localhost:8080', controller.signal);
+      new WebSocketBiDiStream(
+        'ws://localhost:8080', 
+        (message: ClientMessageType) => ClientMessageType.toBinary(message),
+        (data) => ServerMessageType.fromBinary(data),
+        {
+          abortSignal: controller.signal,
+        },
+      );
 
       expect(MockWebSocket.instances).toHaveLength(0);
     });
@@ -332,7 +343,7 @@ describe('WebSocketBiDiStream', () => {
       maxAttempts: 5,
     };
 
-    test('should attempt reconnection on unexpected close', async () => {
+    test('should not attempt reconnection on unexpected close', async () => {
       const { ws } = createStream(undefined, retryConfig);
 
       await openConnection(ws);
@@ -341,7 +352,7 @@ describe('WebSocketBiDiStream', () => {
       ws.emit('close');
       await vi.advanceTimersByTimeAsync(150);
 
-      expect(MockWebSocket.instances.length).toBeGreaterThan(1);
+      expect(MockWebSocket.instances.length).toBe(1);
     });
 
     test('should stop reconnecting after max attempts', async () => {