@milaboratories/pl-client 2.16.10 → 2.16.12

package/dist/helpers/retry_strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry_strategy.js","sources":["../../src/helpers/retry_strategy.ts"],"sourcesContent":["export interface RetryConfig {\n  maxAttempts: number;\n  initialDelay: number;\n  maxDelay: number;\n}\n\nexport const DEFAULT_RETRY_CONFIG: RetryConfig = {\n  maxAttempts: 10,\n  initialDelay: 100,\n  maxDelay: 30000,\n};\n\nexport interface RetryCallbacks {\n  onRetry: () => void;\n  onMaxAttemptsReached: (error: Error) => void;\n}\n\nexport class RetryStrategy {\n  private attempts = 0;\n  private timer: ReturnType<typeof setTimeout> | null = null;\n  private readonly config: RetryConfig;\n  private readonly callbacks: RetryCallbacks;\n  private readonly backoff: ExponentialBackoff;\n\n  constructor(config: Partial<RetryConfig>, callbacks: RetryCallbacks) {\n    this.config = { ...DEFAULT_RETRY_CONFIG, ...config };\n    this.callbacks = callbacks;\n    this.backoff = new ExponentialBackoff({\n      initialDelay: this.config.initialDelay,\n      maxDelay: this.config.maxDelay,\n      factor: 2,\n      jitter: 0.1,\n    });\n  }\n\n  schedule(): void {\n    if (this.timer) return;\n    if (this.hasExceededLimit()) {\n      this.notifyMaxAttemptsReached();\n      return;\n    }\n\n    this.timer = setTimeout(() => {\n      this.timer = null;\n      this.attempts++;\n      this.callbacks.onRetry();\n    }, this.backoff.delay());\n  }\n\n  cancel(): void {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = null;\n    }\n  }\n\n  reset(): void {\n    this.attempts = 0;\n    this.backoff.reset();\n  }\n\n  private hasExceededLimit(): boolean {\n    return this.attempts >= this.config.maxAttempts;\n  }\n\n  private notifyMaxAttemptsReached(): void {\n    const error = new Error(\n      `Max retry attempts (${this.config.maxAttempts}) reached`,\n    );\n    this.callbacks.onMaxAttemptsReached(error);\n  }\n}\n\ninterface ExponentialBackoffConfig {\n  initialDelay: number;\n  maxDelay: number;\n  factor: number;\n  jitter: number;\n}\n\nclass ExponentialBackoff {\n  private readonly initialDelay: number;\n  private readonly maxDelay: number;\n\n  private currentDelay: number;\n\n  private readonly factor: number;\n  private readonly jitter: number;\n\n  constructor(config: ExponentialBackoffConfig) {\n    this.initialDelay = config.initialDelay;\n    this.maxDelay = config.maxDelay;\n    this.factor = config.factor;\n    this.jitter = config.jitter;\n    this.currentDelay = config.initialDelay;\n  }\n\n  delay(): number {\n    if (this.currentDelay >= this.maxDelay) {\n      return this.applyJitter(this.maxDelay);\n    }\n\n    this.currentDelay = this.currentDelay * this.factor;\n\n    if (this.currentDelay > this.maxDelay) {\n      this.currentDelay = this.maxDelay;\n    }\n\n    return this.applyJitter(this.currentDelay);\n  }\n\n  reset(): void {\n    this.currentDelay = this.initialDelay;\n  }\n\n  private applyJitter(delay: number): number {\n    if (delay === 0 || this.jitter === 0) {\n      return delay;\n    }\n    const delayFactor = 1 - (this.jitter / 2) + Math.random() * this.jitter;\n    return delay * delayFactor;\n  }\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-client",
-  "version": "2.16.10",
+  "version": "2.16.12",
   "engines": {
     "node": ">=22.19.0"
   },
@@ -36,8 +36,8 @@
     "utility-types": "^3.11.0",
     "yaml": "^2.8.0",
     "@milaboratories/pl-http": "1.2.0",
-    "@milaboratories/ts-helpers": "1.5.4",
-    "@milaboratories/pl-model-common": "1.21.9"
+    "@milaboratories/pl-model-common": "1.21.9",
+    "@milaboratories/ts-helpers": "1.5.4"
   },
   "devDependencies": {
     "@protobuf-ts/plugin": "2.11.1",
@@ -47,9 +47,9 @@
     "@vitest/coverage-v8": "^4.0.7",
     "vitest": "^4.0.7",
     "typescript": "~5.6.3",
-    "@milaboratories/build-configs": "1.0.8",
+    "@milaboratories/ts-builder": "1.0.5",
     "@milaboratories/ts-configs": "1.0.6",
-    "@milaboratories/ts-builder": "1.0.5"
+    "@milaboratories/build-configs": "1.0.8"
   },
   "scripts": {
     "type-check": "ts-builder types --target node",

package/src/core/errors.ts

@@ -24,6 +24,7 @@ export function isUnauthenticated(err: unknown, nested: boolean = false): boolea
 
 export function isTimeoutOrCancelError(err: unknown, nested: boolean = false): boolean {
   if (err instanceof Aborted || (err as any).name == 'AbortError') return true;
+  if ((err as any).name == 'TimeoutError') return true;
   if ((err as any).code == 'ABORT_ERR') return true;
   if ((err as any).code == Code.ABORTED) return true;
   if (

package/src/core/ll_client.ts

@@ -28,6 +28,7 @@ import type * as grpcTypes from '../proto-grpc/github.com/milaboratory/pl/plapi/
 import { type PlApiPaths, type PlRestClientType, createClient, parseResponseError } from '../proto-rest';
 import { notEmpty } from '@milaboratories/ts-helpers';
 import { Code } from '../proto-grpc/google/rpc/code';
+import { WebSocketBiDiStream } from './websocket_stream';
 
 export interface PlCallOps {
   timeout?: number;
@@ -172,6 +173,7 @@ export class LLPlClient implements WireClientProviderFactory {
   private initGrpcConnection(gzip: boolean) {
     const clientOptions: ClientOptions = {
       'grpc.keepalive_time_ms': 30_000, // 30 seconds
+      'grpc.service_config_disable_resolution': 1, // Disable DNS TXT lookups for service config
       'interceptors': this._grpcInterceptors,
     };
 
@@ -478,17 +480,32 @@ export class LLPlClient implements WireClientProviderFactory {
       let totalAbortSignal = abortSignal;
       if (ops.abortSignal) totalAbortSignal = AbortSignal.any([totalAbortSignal, ops.abortSignal]);
 
+      const timeout = ops.timeout ?? (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout);
+
       const cl = this.clientProvider.get();
-      if (!(cl instanceof GrpcPlApiClient)) {
-        // TODO: add WebSockets
-        throw new Error('tx is not supported for REST client');
+      if (cl instanceof GrpcPlApiClient) {
+        return cl.tx({
+          abort: totalAbortSignal,
+          timeout,
+        });
       }
 
-      return cl.tx({
-        abort: totalAbortSignal,
-        timeout: ops.timeout
-          ?? (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout),
-      });
+      if (this._wireProto === 'rest') {
+        // For REST/WebSocket protocol, timeout needs to be converted to AbortSignal
+        if (timeout !== undefined) {
+          totalAbortSignal = AbortSignal.any([totalAbortSignal, AbortSignal.timeout(timeout)]);
+        }
+        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);
+      }
+      throw new Error('tx is not supported for this wire protocol');
     });
   }
 

package/src/core/ll_transaction.test.ts

@@ -6,6 +6,24 @@ import { test, expect } from 'vitest';
 import { isTimeoutOrCancelError } from './errors';
 import { Aborted } from '@milaboratories/ts-helpers';
 
+test('check successful transaction', async () => {
+  const client = await getTestLLClient();
+  const tx = client.createTx(true);
+
+  const openResp = await tx.send({
+    oneofKind: 'txOpen',
+    txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+  }, false);
+  const commitResp = await tx.send({
+    oneofKind: 'txCommit',
+    txCommit: {}
+  }, false);
+
+  expect(openResp.txOpen.tx?.isValid).toBeTruthy();
+  expect(commitResp.txCommit.success).toBeTruthy();
+  await tx.await();
+});
+
 test('transaction timeout test', async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true, { timeout: 500 });

package/src/core/ll_transaction.ts

@@ -236,6 +236,13 @@ export class LLPlTransaction {
           (currentHandler as AnySingleResponseHandler).resolve(message.response);
           currentHandler = undefined;
         }
+
+        // After receiving a terminal response (txCommit or txDiscard), we proactively close the client stream.
+        // This ensures consistent behavior between the gRPC and WebSocket transports,
+        // since the server closes the connection automatically upon transaction completion in both cases.
+        if (this.isTerminalResponse(message) && this.responseHandlerQueue.length === 0) {
+          await this.stream.requests.complete();
+        }
       }
     } catch (e: any) {
       return this.assignErrorFactoryIfNotSet(() => {
@@ -332,4 +339,9 @@ export class LLPlTransaction {
     this._completed = true;
     await this.stream.requests.complete();
   }
+
+  private isTerminalResponse(message: TxAPI_ServerMessage): boolean {
+    const kind = message.response.oneofKind;
+    return kind === 'txCommit' || kind === 'txDiscard';
+  }
 }

package/src/core/websocket_stream.test.ts

@@ -0,0 +1,412 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  TxAPI_ClientMessage as ClientMessageType,
+  TxAPI_ServerMessage as ServerMessageType,
+} from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
+
+// Mock WebSocket - must be hoisted for vi.mock
+const MockWebSocket = vi.hoisted(() => {
+  class MockWS {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+
+    readyState = 0;
+    binaryType = 'blob';
+
+    private listeners: Map<string, Set<Function>> = new Map();
+
+    constructor(
+      public url: string,
+      public options?: { headers?: Record<string, string> },
+    ) {
+      MockWS.instances.push(this);
+    }
+
+    static instances: MockWS[] = [];
+
+    static reset() {
+      MockWS.instances = [];
+    }
+
+    addEventListener(event: string, callback: Function) {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, new Set());
+      }
+      this.listeners.get(event)!.add(callback);
+    }
+
+    removeEventListener(event: string, callback: Function) {
+      this.listeners.get(event)?.delete(callback);
+    }
+
+    emit(event: string, data?: unknown) {
+      this.listeners.get(event)?.forEach((cb) => cb(data));
+    }
+
+    send = vi.fn();
+    close = vi.fn(() => {
+      this.readyState = MockWS.CLOSED;
+      this.emit('close');
+    });
+
+    simulateOpen() {
+      this.readyState = MockWS.OPEN;
+      this.emit('open');
+    }
+
+    simulateMessage(data: ArrayBuffer) {
+      this.emit('message', { data });
+    }
+
+    simulateError(error: Error) {
+      this.emit('error', error);
+    }
+
+    simulateClose() {
+      this.readyState = MockWS.CLOSED;
+      this.emit('close');
+    }
+  }
+  return MockWS;
+});
+
+vi.mock('undici', () => ({
+  WebSocket: MockWebSocket,
+}));
+
+import { WebSocketBiDiStream } from './websocket_stream';
+import type { RetryConfig } from '../helpers/retry_strategy';
+
+type MockWS = InstanceType<typeof MockWebSocket>;
+
+interface StreamContext {
+  stream: WebSocketBiDiStream;
+  ws: MockWS;
+  controller: AbortController;
+}
+
+function createStream(token?: string, retryConfig?: Partial<RetryConfig>): StreamContext {
+  const controller = new AbortController();
+  const stream = new WebSocketBiDiStream(
+    'ws://localhost:8080',
+    controller.signal,
+    token,
+    retryConfig,
+  );
+  const ws = MockWebSocket.instances[MockWebSocket.instances.length - 1];
+  return { stream, ws, controller };
+}
+
+async function openConnection(ws: MockWS): Promise<void> {
+  ws.simulateOpen();
+  await vi.runAllTimersAsync();
+}
+
+function createServerMessageBuffer(): ArrayBuffer {
+  const message = ServerMessageType.create({});
+  const binary = ServerMessageType.toBinary(message);
+  return binary.buffer.slice(binary.byteOffset, binary.byteOffset + binary.byteLength) as ArrayBuffer;
+}
+
+function createClientMessage(): ClientMessageType {
+  return ClientMessageType.create({});
+}
+
+async function collectMessages(
+  stream: WebSocketBiDiStream,
+  count: number,
+): Promise<ServerMessageType[]> {
+  const messages: ServerMessageType[] = [];
+  for await (const msg of stream.responses) {
+    messages.push(msg);
+    if (messages.length >= count) break;
+  }
+  return messages;
+}
+
+describe('WebSocketBiDiStream', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    MockWebSocket.reset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('constructor', () => {
+    test('should pass JWT token in authorization header', () => {
+      createStream('test-token');
+
+      expect(MockWebSocket.instances[0].options?.headers?.authorization).toBe(
+        'Bearer test-token',
+      );
+    });
+
+    test('should not create WebSocket if already aborted', () => {
+      const controller = new AbortController();
+      controller.abort();
+
+      new WebSocketBiDiStream('ws://localhost:8080', controller.signal);
+
+      expect(MockWebSocket.instances).toHaveLength(0);
+    });
+  });
+
+  describe('send messages', () => {
+    test('should queue message and send when connected', async () => {
+      const { stream, ws } = createStream();
+
+      const sendPromise = stream.requests.send(createClientMessage());
+      expect(ws.send).not.toHaveBeenCalled();
+
+      await openConnection(ws);
+      await sendPromise;
+
+      expect(ws.send).toHaveBeenCalledTimes(1);
+    });
+
+    test('should throw error when sending after complete', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+      await stream.requests.complete();
+
+      await expect(stream.requests.send(createClientMessage())).rejects.toThrow(
+        'Cannot send: stream already completed',
+      );
+    });
+
+    test('should throw error when sending after abort', async () => {
+      const { stream, ws, controller } = createStream();
+
+      await openConnection(ws);
+      controller.abort();
+
+      await expect(stream.requests.send(createClientMessage())).rejects.toThrow(
+        'Cannot send: stream aborted',
+      );
+    });
+  });
+
+  describe('receive messages', () => {
+    test('should receive messages via async iterator', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+
+      const buffer = createServerMessageBuffer();
+      const responsePromise = collectMessages(stream, 2);
+
+      ws.simulateMessage(buffer);
+      ws.simulateMessage(buffer);
+
+      const messages = await responsePromise;
+      expect(messages).toHaveLength(2);
+    });
+
+    test('should buffer messages when no consumer', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+
+      const buffer = createServerMessageBuffer();
+      ws.simulateMessage(buffer);
+      ws.simulateMessage(buffer);
+
+      const messages = await collectMessages(stream, 2);
+      expect(messages).toHaveLength(2);
+    });
+
+    test('should end iterator when stream completes', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+
+      const iteratorPromise = (async () => {
+        const messages: ServerMessageType[] = [];
+        for await (const msg of stream.responses) {
+          messages.push(msg);
+        }
+        return messages;
+      })();
+
+      await stream.requests.complete();
+
+      const messages = await iteratorPromise;
+      expect(messages).toHaveLength(0);
+    });
+  });
+
+  describe('complete', () => {
+    test('should close WebSocket after complete', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+      await stream.requests.complete();
+
+      expect(ws.close).toHaveBeenCalled();
+    });
+
+    test('should be idempotent', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+      await stream.requests.complete();
+      await stream.requests.complete();
+      await stream.requests.complete();
+
+      expect(ws.close).toHaveBeenCalledTimes(1);
+    });
+
+    test('should drain send queue before closing', async () => {
+      const { stream, ws } = createStream();
+
+      const sendPromise1 = stream.requests.send(createClientMessage());
+      const sendPromise2 = stream.requests.send(createClientMessage());
+      const completePromise = stream.requests.complete();
+
+      await openConnection(ws);
+
+      await sendPromise1;
+      await sendPromise2;
+      await completePromise;
+
+      expect(ws.send).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('abort signal', () => {
+    test('should close stream when aborted', async () => {
+      const { ws, controller } = createStream();
+
+      await openConnection(ws);
+      controller.abort();
+
+      expect(ws.close).toHaveBeenCalled();
+    });
+
+    test('should reject pending sends when aborted', async () => {
+      const { stream, controller } = createStream();
+
+      const sendPromise = stream.requests.send(createClientMessage());
+      sendPromise.catch(() => {});
+
+      controller.abort();
+      await vi.runAllTimersAsync();
+
+      await expect(sendPromise).rejects.toThrow();
+    });
+
+    test('should end response iterator when aborted', async () => {
+      const { stream, ws, controller } = createStream();
+
+      await openConnection(ws);
+
+      const iteratorPromise = (async () => {
+        const messages: ServerMessageType[] = [];
+        try {
+          for await (const msg of stream.responses) {
+            messages.push(msg);
+          }
+        } catch {
+          // Expected to throw on abort
+        }
+        return messages;
+      })();
+
+      controller.abort();
+      await vi.runAllTimersAsync();
+
+      const messages = await iteratorPromise;
+      expect(messages).toHaveLength(0);
+    });
+  });
+
+  describe('reconnection', () => {
+    const retryConfig: Partial<RetryConfig> = {
+      initialDelay: 50,
+      maxDelay: 100,
+      maxAttempts: 5,
+    };
+
+    test('should attempt reconnection on unexpected close', async () => {
+      const { ws } = createStream(undefined, retryConfig);
+
+      await openConnection(ws);
+
+      ws.readyState = MockWebSocket.CLOSED;
+      ws.emit('close');
+      await vi.advanceTimersByTimeAsync(150);
+
+      expect(MockWebSocket.instances.length).toBeGreaterThan(1);
+    });
+
+    test('should stop reconnecting after max attempts', async () => {
+      createStream(undefined, { maxAttempts: 3, initialDelay: 10, maxDelay: 100 });
+
+      for (let i = 0; i < 5; i++) {
+        const ws = MockWebSocket.instances[MockWebSocket.instances.length - 1];
+        ws.simulateError(new Error('Connection failed'));
+        await vi.advanceTimersByTimeAsync(200);
+      }
+
+      expect(MockWebSocket.instances.length).toBeLessThanOrEqual(4);
+    });
+
+    test('should not reconnect after complete', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+      await stream.requests.complete();
+      await vi.advanceTimersByTimeAsync(1000);
+
+      expect(MockWebSocket.instances).toHaveLength(1);
+    });
+  });
+
+  describe('error handling', () => {
+    test('should reject response iterator on parse error', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+
+      const iterator = stream.responses[Symbol.asyncIterator]();
+      const nextPromise = iterator.next();
+
+      await Promise.resolve();
+
+      const invalidData = new Uint8Array([
+        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01,
+      ]);
+      ws.simulateMessage(invalidData.buffer);
+
+      await expect(nextPromise).rejects.toThrow();
+    });
+
+    test('should throw on unsupported message format', async () => {
+      const { stream, ws } = createStream();
+
+      await openConnection(ws);
+
+      const iteratorPromise = (async () => {
+        try {
+          for await (const _ of stream.responses) {
+            // Should not reach here
+          }
+          return 'completed';
+        } catch (e) {
+          return e;
+        }
+      })();
+
+      ws.emit('message', { data: 'not a buffer' });
+
+      const result = await iteratorPromise;
+      expect(result).toBeInstanceOf(Error);
+    });
+  });
+
+});