@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/core/types.test.ts

@@ -1,11 +1,11 @@
-import { expect, test } from 'vitest';
+import { expect, test } from "vitest";
 import {
   createGlobalResourceId,
   createLocalResourceId,
   NullResourceId,
   resourceIdFromString,
-  resourceIdToString
-} from './types';
+  resourceIdToString,
+} from "./types";
 
 test.each(
   [
@@ -13,11 +13,11 @@ test.each(
     createGlobalResourceId(true, 0x3457748574857n),
     createGlobalResourceId(false, 0x3457748574857n),
     createLocalResourceId(true, 1234, 34423),
-    createLocalResourceId(false, 1234, 34423)
+    createLocalResourceId(false, 1234, 34423),
   ].map((rid) => ({
     name: resourceIdToString(rid),
-    rid
-  }))
+    rid,
+  })),
 )(`resource id to and from string: $name`, ({ rid }) => {
   expect(resourceIdFromString(resourceIdToString(rid))).toEqual(rid);
 });

package/src/core/types.ts

@@ -1,17 +1,17 @@
-import { cachedDeserialize, notEmpty } from '@milaboratories/ts-helpers';
+import { cachedDeserialize, notEmpty } from "@milaboratories/ts-helpers";
 
 // more details here: https://egghead.io/blog/using-branded-types-in-typescript
 declare const __resource_id_type__: unique symbol;
 type BrandResourceId<B> = bigint & { [__resource_id_type__]: B };
 
 /** Global resource id */
-export type ResourceId = BrandResourceId<'global'>;
+export type ResourceId = BrandResourceId<"global">;
 
 /** Null resource id */
-export type NullResourceId = BrandResourceId<'null'>;
+export type NullResourceId = BrandResourceId<"null">;
 
 /** Local resource id */
-export type LocalResourceId = BrandResourceId<'local'>;
+export type LocalResourceId = BrandResourceId<"local">;
 
 /** Any non-null resource id */
 export type AnyResourceId = ResourceId | LocalResourceId;
@@ -33,7 +33,7 @@ export function isNotNullResourceId(resourceId: OptionalResourceId): resourceId
 }
 
 export function ensureResourceIdNotNull(resourceId: OptionalResourceId): ResourceId {
-  if (!isNotNullResourceId(resourceId)) throw new Error('null resource id');
+  if (!isNotNullResourceId(resourceId)) throw new Error("null resource id");
   return resourceId;
 }
 
@@ -43,13 +43,13 @@ export function isAnyResourceId(resourceId: bigint): resourceId is AnyResourceId
 
 // see local / global resource logic below...
 
-export type ResourceKind = 'Structural' | 'Value';
+export type ResourceKind = "Structural" | "Value";
 
-export type FieldType = 'Input' | 'Output' | 'Service' | 'OTW' | 'Dynamic' | 'MTW';
+export type FieldType = "Input" | "Output" | "Service" | "OTW" | "Dynamic" | "MTW";
 
-export type FutureFieldType = 'Output' | 'Input' | 'Service';
+export type FutureFieldType = "Output" | "Input" | "Service";
 
-export type FieldStatus = 'Empty' | 'Assigned' | 'Resolved';
+export type FieldStatus = "Empty" | "Assigned" | "Resolved";
 
 export interface ResourceType {
   readonly name: string;
@@ -174,16 +174,16 @@ export function createLocalResourceId(
   localTxId: number,
 ): LocalResourceId {
   if (
-    localCounterValue > MaxLocalId
-    || localTxId > MaxTxId
-    || localCounterValue < 0
-    || localTxId <= 0
+    localCounterValue > MaxLocalId ||
+    localTxId > MaxTxId ||
+    localCounterValue < 0 ||
+    localTxId <= 0
   )
-    throw Error('wrong local id or tx id');
-  return ((isRoot ? ResourceIdRootMask : 0n)
-    | ResourceIdLocalMask
-    | BigInt(localCounterValue)
-    | (BigInt(localTxId) << LocalResourceIdTxIdOffset)) as LocalResourceId;
+    throw Error("wrong local id or tx id");
+  return ((isRoot ? ResourceIdRootMask : 0n) |
+    ResourceIdLocalMask |
+    BigInt(localCounterValue) |
+    (BigInt(localTxId) << LocalResourceIdTxIdOffset)) as LocalResourceId;
 }
 
 export function createGlobalResourceId(isRoot: boolean, unmaskedId: bigint): ResourceId {
@@ -198,40 +198,40 @@ export function checkLocalityOfResourceId(resourceId: AnyResourceId, expectedTxI
   if (!isLocalResourceId(resourceId)) return;
   if (extractTxId(resourceId) !== expectedTxId)
     throw Error(
-      'local id from another transaction, globalize id before leaking it from the transaction',
+      "local id from another transaction, globalize id before leaking it from the transaction",
     );
 }
 
 export function resourceIdToString(resourceId: OptionalAnyResourceId): string {
-  if (isNullResourceId(resourceId)) return 'XX:0x0';
+  if (isNullResourceId(resourceId)) return "XX:0x0";
   if (isLocalResourceId(resourceId))
     return (
-      (isRootResourceId(resourceId) ? 'R' : 'N')
-      + 'L:0x'
-      + (LocalIdMask & resourceId).toString(16)
-      + '[0x'
-      + extractTxId(resourceId).toString(16)
-      + ']'
+      (isRootResourceId(resourceId) ? "R" : "N") +
+      "L:0x" +
+      (LocalIdMask & resourceId).toString(16) +
+      "[0x" +
+      extractTxId(resourceId).toString(16) +
+      "]"
     );
   else
     return (
-      (isRootResourceId(resourceId) ? 'R' : 'N')
-      + 'G:0x'
-      + (NoFlagsIdMask & resourceId).toString(16)
+      (isRootResourceId(resourceId) ? "R" : "N") +
+      "G:0x" +
+      (NoFlagsIdMask & resourceId).toString(16)
     );
 }
 
-const resourceIdRegexp
-  = /^(?:(?<xx>XX)|(?<rn>[XRN])(?<lg>[XLG])):0x(?<rid>[0-9a-fA-F]+)(?:\[0x(?<txid>[0-9a-fA-F]+)])?$/;
+const resourceIdRegexp =
+  /^(?:(?<xx>XX)|(?<rn>[XRN])(?<lg>[XLG])):0x(?<rid>[0-9a-fA-F]+)(?:\[0x(?<txid>[0-9a-fA-F]+)])?$/;
 
 export function resourceIdFromString(str: string): OptionalAnyResourceId | undefined {
   const match = str.match(resourceIdRegexp);
   if (match === null) return undefined;
   const { xx, rn, lg, rid, txid } = match.groups!;
   if (xx) return NullResourceId;
-  if (lg === 'L')
-    return createLocalResourceId(rn === 'R', Number.parseInt(rid, 16), Number.parseInt(txid, 16));
-  else return createGlobalResourceId(rn === 'R', BigInt('0x' + rid));
+  if (lg === "L")
+    return createLocalResourceId(rn === "R", Number.parseInt(rid, 16), Number.parseInt(txid, 16));
+  else return createGlobalResourceId(rn === "R", BigInt("0x" + rid));
 }
 
 /** Converts bigint to global resource id */
@@ -244,6 +244,6 @@ export function bigintToResourceId(resourceId: bigint): ResourceId {
 
 export function stringifyWithResourceId(object: unknown): string {
   return JSON.stringify(object, (key, value) =>
-    typeof value === 'bigint' ? resourceIdToString(value as OptionalAnyResourceId) : value,
+    typeof value === "bigint" ? resourceIdToString(value as OptionalAnyResourceId) : value,
   );
 }

package/src/core/unauth_client.test.ts

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

package/src/core/unauth_client.ts

@@ -1,11 +1,11 @@
-import type { AuthInformation, PlClientConfig } from './config';
+import type { AuthInformation, PlClientConfig } from "./config";
 import type {
   AuthAPI_ListMethods_Response,
   MaintenanceAPI_Ping_Response,
-} from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
-import { LLPlClient } from './ll_client';
-import { type MiLogger, notEmpty } from '@milaboratories/ts-helpers';
-import { UnauthenticatedError } from './errors';
+} from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
+import { LLPlClient } from "./ll_client";
+import { type MiLogger, notEmpty } from "@milaboratories/ts-helpers";
+import { UnauthenticatedError } from "./errors";
 
 /** Primarily used for initial authentication (login) */
 export class UnauthenticatedPlClient {
@@ -15,7 +15,10 @@ export class UnauthenticatedPlClient {
     this.ll = ll;
   }
 
-  public static async build(configOrAddress: PlClientConfig | string, ops?: { logger?: MiLogger }): Promise<UnauthenticatedPlClient> {
+  public static async build(
+    configOrAddress: PlClientConfig | string,
+    ops?: { logger?: MiLogger },
+  ): Promise<UnauthenticatedPlClient> {
     const ll = await LLPlClient.build(configOrAddress, ops);
     return new UnauthenticatedPlClient(ll);
   }
@@ -34,15 +37,14 @@ export class UnauthenticatedPlClient {
 
   public async login(user: string, password: string): Promise<AuthInformation> {
     try {
-      const token = await this.ll.getJwtToken(
-        BigInt(this.ll.conf.authTTLSeconds),
-        { authorization: 'Basic ' + Buffer.from(user + ':' + password).toString('base64') },
-      );
+      const token = await this.ll.getJwtToken(BigInt(this.ll.conf.authTTLSeconds), {
+        authorization: "Basic " + Buffer.from(user + ":" + password).toString("base64"),
+      });
       const jwtToken = notEmpty(token);
-      if (jwtToken === '') throw new Error('empty token');
+      if (jwtToken === "") throw new Error("empty token");
       return { jwtToken };
     } catch (e: any) {
-      if (e.code === 'UNAUTHENTICATED') throw new UnauthenticatedError(e.message);
+      if (e.code === "UNAUTHENTICATED") throw new UnauthenticatedError(e.message);
       throw new Error(e);
     }
   }

package/src/core/websocket_stream.test.ts

@@ -1,8 +1,8 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+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';
+} from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
 
 // Mock WebSocket - must be hoisted for vi.mock
 const MockWebSocket = vi.hoisted(() => {
@@ -13,7 +13,7 @@ const MockWebSocket = vi.hoisted(() => {
     static CLOSED = 3;
 
     readyState = 0;
-    binaryType = 'blob';
+    binaryType = "blob";
 
     private listeners: Map<string, Set<Function>> = new Map();
 
@@ -48,36 +48,36 @@ const MockWebSocket = vi.hoisted(() => {
     send = vi.fn();
     close = vi.fn(() => {
       this.readyState = MockWS.CLOSED;
-      this.emit('close');
+      this.emit("close");
     });
 
     simulateOpen() {
       this.readyState = MockWS.OPEN;
-      this.emit('open');
+      this.emit("open");
     }
 
     simulateMessage(data: ArrayBuffer) {
-      this.emit('message', { data });
+      this.emit("message", { data });
     }
 
     simulateError(error: Error) {
-      this.emit('error', error);
+      this.emit("error", error);
     }
 
     simulateClose() {
       this.readyState = MockWS.CLOSED;
-      this.emit('close');
+      this.emit("close");
     }
   }
   return MockWS;
 });
 
-vi.mock('undici', () => ({
+vi.mock("undici", () => ({
   WebSocket: MockWebSocket,
 }));
 
-import { WebSocketBiDiStream } from './websocket_stream';
-import type { RetryConfig } from '../helpers/retry_strategy';
+import { WebSocketBiDiStream } from "./websocket_stream";
+import type { RetryConfig } from "../helpers/retry_strategy";
 
 type MockWS = InstanceType<typeof MockWebSocket>;
 
@@ -90,7 +90,7 @@ interface StreamContext {
 function createStream(token?: string, retryConfig?: Partial<RetryConfig>): StreamContext {
   const controller = new AbortController();
   const stream = new WebSocketBiDiStream(
-    'ws://localhost:8080',
+    "ws://localhost:8080",
     (message: ClientMessageType) => ClientMessageType.toBinary(message),
     (data) => ServerMessageType.fromBinary(data),
     {
@@ -111,7 +111,10 @@ async function openConnection(ws: MockWS): Promise<void> {
 function createServerMessageBuffer(): ArrayBuffer {
   const message = ServerMessageType.create({});
   const binary = ServerMessageType.toBinary(message);
-  return binary.buffer.slice(binary.byteOffset, binary.byteOffset + binary.byteLength) as ArrayBuffer;
+  return binary.buffer.slice(
+    binary.byteOffset,
+    binary.byteOffset + binary.byteLength,
+  ) as ArrayBuffer;
 }
 
 function createClientMessage(): ClientMessageType {
@@ -130,7 +133,7 @@ async function collectMessages(
   return messages;
 }
 
-describe('WebSocketBiDiStream', () => {
+describe("WebSocketBiDiStream", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     MockWebSocket.reset();
@@ -140,21 +143,19 @@ describe('WebSocketBiDiStream', () => {
     vi.useRealTimers();
   });
 
-  describe('constructor', () => {
-    test('should pass JWT token in authorization header', () => {
-      createStream('test-token');
+  describe("constructor", () => {
+    test("should pass JWT token in authorization header", () => {
+      createStream("test-token");
 
-      expect(MockWebSocket.instances[0].options?.headers?.authorization).toBe(
-        'Bearer test-token',
-      );
+      expect(MockWebSocket.instances[0].options?.headers?.authorization).toBe("Bearer test-token");
     });
 
-    test('should not create WebSocket if already aborted', () => {
+    test("should not create WebSocket if already aborted", () => {
       const controller = new AbortController();
       controller.abort();
 
       new WebSocketBiDiStream(
-        'ws://localhost:8080', 
+        "ws://localhost:8080",
         (message: ClientMessageType) => ClientMessageType.toBinary(message),
         (data) => ServerMessageType.fromBinary(data),
         {
@@ -166,8 +167,8 @@ describe('WebSocketBiDiStream', () => {
     });
   });
 
-  describe('send messages', () => {
-    test('should queue message and send when connected', async () => {
+  describe("send messages", () => {
+    test("should queue message and send when connected", async () => {
       const { stream, ws } = createStream();
 
       const sendPromise = stream.requests.send(createClientMessage());
@@ -179,31 +180,31 @@ describe('WebSocketBiDiStream', () => {
       expect(ws.send).toHaveBeenCalledTimes(1);
     });
 
-    test('should throw error when sending after complete', async () => {
+    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',
+        "Cannot send: stream already completed",
       );
     });
 
-    test('should throw error when sending after abort', async () => {
+    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',
+        "Cannot send: stream aborted",
       );
     });
   });
 
-  describe('receive messages', () => {
-    test('should receive messages via async iterator', async () => {
+  describe("receive messages", () => {
+    test("should receive messages via async iterator", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -218,7 +219,7 @@ describe('WebSocketBiDiStream', () => {
       expect(messages).toHaveLength(2);
     });
 
-    test('should buffer messages when no consumer', async () => {
+    test("should buffer messages when no consumer", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -231,7 +232,7 @@ describe('WebSocketBiDiStream', () => {
       expect(messages).toHaveLength(2);
     });
 
-    test('should end iterator when stream completes', async () => {
+    test("should end iterator when stream completes", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -251,8 +252,8 @@ describe('WebSocketBiDiStream', () => {
     });
   });
 
-  describe('complete', () => {
-    test('should close WebSocket after complete', async () => {
+  describe("complete", () => {
+    test("should close WebSocket after complete", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -261,7 +262,7 @@ describe('WebSocketBiDiStream', () => {
       expect(ws.close).toHaveBeenCalled();
     });
 
-    test('should be idempotent', async () => {
+    test("should be idempotent", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -272,7 +273,7 @@ describe('WebSocketBiDiStream', () => {
       expect(ws.close).toHaveBeenCalledTimes(1);
     });
 
-    test('should drain send queue before closing', async () => {
+    test("should drain send queue before closing", async () => {
       const { stream, ws } = createStream();
 
       const sendPromise1 = stream.requests.send(createClientMessage());
@@ -289,8 +290,8 @@ describe('WebSocketBiDiStream', () => {
     });
   });
 
-  describe('abort signal', () => {
-    test('should close stream when aborted', async () => {
+  describe("abort signal", () => {
+    test("should close stream when aborted", async () => {
       const { ws, controller } = createStream();
 
       await openConnection(ws);
@@ -299,7 +300,7 @@ describe('WebSocketBiDiStream', () => {
       expect(ws.close).toHaveBeenCalled();
     });
 
-    test('should reject pending sends when aborted', async () => {
+    test("should reject pending sends when aborted", async () => {
       const { stream, controller } = createStream();
 
       const sendPromise = stream.requests.send(createClientMessage());
@@ -311,7 +312,7 @@ describe('WebSocketBiDiStream', () => {
       await expect(sendPromise).rejects.toThrow();
     });
 
-    test('should end response iterator when aborted', async () => {
+    test("should end response iterator when aborted", async () => {
       const { stream, ws, controller } = createStream();
 
       await openConnection(ws);
@@ -336,38 +337,38 @@ describe('WebSocketBiDiStream', () => {
     });
   });
 
-  describe('reconnection', () => {
+  describe("reconnection", () => {
     const retryConfig: Partial<RetryConfig> = {
       initialDelay: 50,
       maxDelay: 100,
       maxAttempts: 5,
     };
 
-    test('should not attempt reconnection on unexpected close', async () => {
+    test("should not attempt reconnection on unexpected close", async () => {
       const { ws } = createStream(undefined, retryConfig);
 
       await openConnection(ws);
 
       ws.readyState = MockWebSocket.CLOSED;
-      ws.emit('close');
+      ws.emit("close");
       await vi.advanceTimersByTimeAsync(150);
 
       expect(MockWebSocket.instances.length).toBe(1);
     });
 
-    test('should stop reconnecting after max attempts', async () => {
+    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'));
+        ws.simulateError(new Error("Connection failed"));
         await vi.advanceTimersByTimeAsync(200);
       }
 
       expect(MockWebSocket.instances.length).toBeLessThanOrEqual(4);
     });
 
-    test('should not reconnect after complete', async () => {
+    test("should not reconnect after complete", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -378,8 +379,8 @@ describe('WebSocketBiDiStream', () => {
     });
   });
 
-  describe('error handling', () => {
-    test('should reject response iterator on parse error', async () => {
+  describe("error handling", () => {
+    test("should reject response iterator on parse error", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -397,7 +398,7 @@ describe('WebSocketBiDiStream', () => {
       await expect(nextPromise).rejects.toThrow();
     });
 
-    test('should throw on unsupported message format', async () => {
+    test("should throw on unsupported message format", async () => {
       const { stream, ws } = createStream();
 
       await openConnection(ws);
@@ -407,17 +408,16 @@ describe('WebSocketBiDiStream', () => {
           for await (const _ of stream.responses) {
             // Should not reach here
           }
-          return 'completed';
+          return "completed";
         } catch (e) {
           return e;
         }
       })();
 
-      ws.emit('message', { data: 'not a buffer' });
+      ws.emit("message", { data: "not a buffer" });
 
       const result = await iteratorPromise;
       expect(result).toBeInstanceOf(Error);
     });
   });
-
 });