@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/core/StatefulPromise.ts

@@ -1,4 +1,4 @@
-type PromiseState = 'pending' | 'fulfilled' | 'rejected';
+type PromiseState = "pending" | "fulfilled" | "rejected";
 
 type StatefulPromiseOptions<T> = {
   /**
@@ -30,32 +30,41 @@ export class StatefulPromise<T> implements Promise<T> {
     return new StatefulPromise(promise, options);
   }
 
-  static fromDeferredReject<T>(promise: Promise<T>, onUnwrap?: (promise: StatefulPromise<T>) => void): StatefulPromise<T> {
+  static fromDeferredReject<T>(
+    promise: Promise<T>,
+    onUnwrap?: (promise: StatefulPromise<T>) => void,
+  ): StatefulPromise<T> {
     return new StatefulPromise(promise, { deferReject: true, onUnwrap });
   }
 
-  static fromDeferredRejectCallback<T>(asyncFn: () => Promise<T>, onUnwrap?: (promise: StatefulPromise<T>) => void): StatefulPromise<T> {
+  static fromDeferredRejectCallback<T>(
+    asyncFn: () => Promise<T>,
+    onUnwrap?: (promise: StatefulPromise<T>) => void,
+  ): StatefulPromise<T> {
     return new StatefulPromise(asyncFn(), { deferReject: true, onUnwrap });
   }
 
-  private constructor(private readonly promise: Promise<T>, private readonly options: StatefulPromiseOptions<T> = {}) {
-    this._state = 'pending';
+  private constructor(
+    private readonly promise: Promise<T>,
+    private readonly options: StatefulPromiseOptions<T> = {},
+  ) {
+    this._state = "pending";
     this._id = StatefulPromise.idCounter++;
 
     this.promise
       .then((value) => {
-        this._state = 'fulfilled';
+        this._state = "fulfilled";
         return value;
       })
       .catch((err) => {
-        this._state = 'rejected';
+        this._state = "rejected";
         if (!options.deferReject) {
           throw err;
         }
       });
   }
 
-  readonly [Symbol.toStringTag] = 'Promise';
+  readonly [Symbol.toStringTag] = "Promise";
 
   get id(): bigint {
     return this._id;

package/src/core/abstract_stream.ts

@@ -1,4 +1,4 @@
-import type { DuplexStreamingCall } from '@protobuf-ts/runtime-rpc';
+import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
 
 export interface RequestsStream<T> {
   /**
@@ -20,6 +20,5 @@ export interface BiDiStream<I extends object, O extends object> {
 }
 
 // Compile-time type compatibility check: BiDiStream is compatible with DuplexStreamingCall implementaions.
-type _CompatibilityTest<I extends object, O extends object> = DuplexStreamingCall<I, O> extends BiDiStream<I, O>
-  ? true
-  : never;
+type _CompatibilityTest<I extends object, O extends object> =
+  DuplexStreamingCall<I, O> extends BiDiStream<I, O> ? true : never;

package/src/core/advisory_locks.ts

@@ -18,7 +18,7 @@ class AwaitLock {
    */
   release(): boolean {
     if (!this.acquired) {
-      throw new Error('Cannot release an unacquired lock');
+      throw new Error("Cannot release an unacquired lock");
     }
 
     if (this.resolvers.length) {

package/src/core/auth.ts

@@ -1,5 +1,5 @@
-import type { AuthInformation } from './config';
-import { parsePlJwt } from '../util/pl';
+import type { AuthInformation } from "./config";
+import { parsePlJwt } from "../util/pl";
 
 /** Returns a timestamp when current authorization information should be refreshed.
  * Compare the value with Date.now(). */

package/src/core/cache.ts

@@ -1,4 +1,4 @@
-import type { BasicResourceData, ResourceData } from './types';
+import type { BasicResourceData, ResourceData } from "./types";
 
 export type ResourceDataCacheRecord = {
   /** There is a slight chance of inconsistent data retrieval from tx if we allow later transactions to leak resource data into earlier transactions.

package/src/core/client.test.ts

@@ -1,25 +1,25 @@
-import { getTestClient, getTestClientConf } from '../test/test_config';
-import { PlClient } from './client';
-import { PlDriver, PlDriverDefinition } from './driver';
-import { Dispatcher, request } from 'undici';
-import { GrpcClientProviderFactory } from './grpc';
-import { test, expect } from 'vitest';
+import { getTestClient, getTestClientConf } from "../test/test_config";
+import { PlClient } from "./client";
+import { PlDriver, PlDriverDefinition } from "./driver";
+import { Dispatcher, request } from "undici";
+import { GrpcClientProviderFactory } from "./grpc";
+import { test, expect } from "vitest";
 
-test('test client init', async () => {
-  const client = await getTestClient(undefined);
+test("test client init", async () => {
+  await getTestClient(undefined);
 });
 
-test('test client alternative root init', async () => {
-  const aRootName = 'test_root';
+test("test client alternative root init", async () => {
+  const aRootName = "test_root";
   const { conf, auth } = await getTestClientConf();
-  const clientA = await PlClient.init({ ...conf, alternativeRoot: aRootName }, auth);
+  await PlClient.init({ ...conf, alternativeRoot: aRootName }, auth);
   const clientB = await PlClient.init(conf, auth);
   const result = await clientB.deleteAlternativeRoot(aRootName);
   expect(result).toBe(true);
 });
 
-test('test client init', async () => {
-  const client = await getTestClient();
+test("test client init 2", async () => {
+  await getTestClient();
 });
 
 interface SimpleDriver extends PlDriver {
@@ -27,22 +27,26 @@ interface SimpleDriver extends PlDriver {
 }
 
 const SimpleDriverDefinition: PlDriverDefinition<SimpleDriver> = {
-  name: 'SimpleDriver',
-  init(pl: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher): SimpleDriver {
+  name: "SimpleDriver",
+  init(
+    pl: PlClient,
+    grpcClientProviderFactory: GrpcClientProviderFactory,
+    httpDispatcher: Dispatcher,
+  ): SimpleDriver {
     return {
       async ping(): Promise<string> {
-        const response = await request('https://cdn.milaboratory.com/ping', {
-          dispatcher: httpDispatcher
+        const response = await request("https://cdn.milaboratory.com/ping", {
+          dispatcher: httpDispatcher,
         });
         return await response.body.text();
       },
-      close() {}
+      close() {},
     };
-  }
+  },
 };
 
-test('test driver', async () => {
+test("test driver", async () => {
   const client = await getTestClient();
   const drv = client.getDriver(SimpleDriverDefinition);
-  expect(await drv.ping()).toEqual('pong');
+  expect(await drv.ping()).toEqual("pong");
 });

package/src/core/client.ts

@@ -1,28 +1,31 @@
-import type { AuthOps, PlClientConfig, PlConnectionStatusListener, wireProtocol } from './config';
-import type { PlCallOps } from './ll_client';
-import { LLPlClient } from './ll_client';
-import type { AnyResourceRef } from './transaction';
-import { PlTransaction, toGlobalResourceId, TxCommitConflict } from './transaction';
-import { createHash } from 'node:crypto';
-import type { OptionalResourceId, ResourceId } from './types';
-import { ensureResourceIdNotNull, isNullResourceId, NullResourceId } from './types';
-import { ClientRoot } from '../helpers/pl';
-import type { MiLogger, RetryOptions } from '@milaboratories/ts-helpers';
-import { assertNever, createRetryState, nextRetryStateOrError } from '@milaboratories/ts-helpers';
-import type { PlDriver, PlDriverDefinition } from './driver';
-import type { MaintenanceAPI_Ping_Response, MaintenanceAPI_License_Response } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
-import { MaintenanceAPI_Ping_Response_Compression } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
-import * as tp from 'node:timers/promises';
-import type { Dispatcher } from 'undici';
-import { LRUCache } from 'lru-cache';
-import type { ResourceDataCacheRecord } from './cache';
-import type { FinalResourceDataPredicate } from './final';
-import { DefaultFinalResourceDataPredicate } from './final';
-import type { AllTxStat, TxStat } from './stat';
-import { addStat, initialTxStat } from './stat';
-import type { WireConnection } from './wire';
-import { advisoryLock } from './advisory_locks';
-import { plAddressToConfig } from './config';
+import type { AuthOps, PlClientConfig, PlConnectionStatusListener, wireProtocol } from "./config";
+import type { PlCallOps } from "./ll_client";
+import { LLPlClient } from "./ll_client";
+import type { AnyResourceRef } from "./transaction";
+import { PlTransaction, toGlobalResourceId, TxCommitConflict } from "./transaction";
+import { createHash } from "node:crypto";
+import type { OptionalResourceId, ResourceId } from "./types";
+import { ensureResourceIdNotNull, isNullResourceId, NullResourceId } from "./types";
+import { ClientRoot } from "../helpers/pl";
+import type { MiLogger, RetryOptions } from "@milaboratories/ts-helpers";
+import { assertNever, createRetryState, nextRetryStateOrError } from "@milaboratories/ts-helpers";
+import type { PlDriver, PlDriverDefinition } from "./driver";
+import type {
+  MaintenanceAPI_Ping_Response,
+  MaintenanceAPI_License_Response,
+} from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
+import { MaintenanceAPI_Ping_Response_Compression } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
+import * as tp from "node:timers/promises";
+import type { Dispatcher } from "undici";
+import { LRUCache } from "lru-cache";
+import type { ResourceDataCacheRecord } from "./cache";
+import type { FinalResourceDataPredicate } from "./final";
+import { DefaultFinalResourceDataPredicate } from "./final";
+import type { AllTxStat, TxStat } from "./stat";
+import { addStat, initialTxStat } from "./stat";
+import type { WireConnection } from "./wire";
+import { advisoryLock } from "./advisory_locks";
+import { plAddressToConfig } from "./config";
 
 export type TxOps = PlCallOps & {
   sync?: boolean;
@@ -35,7 +38,7 @@ const defaultTxOps = {
   sync: false,
 };
 
-const AnonymousClientRoot = 'AnonymousRoot';
+const AnonymousClientRoot = "AnonymousRoot";
 
 function alternativeRootFieldName(alternativeRoot: string): string {
   return `alternative_root_${alternativeRoot}`;
@@ -55,12 +58,15 @@ export class PlClient {
   /** Last resort measure to solve complicated race conditions in pl. */
   private readonly defaultRetryOptions: RetryOptions;
 
-  private readonly buildLLPlClient: (shouldUseGzip: boolean, wireProtocol?: wireProtocol) => Promise<LLPlClient>;
+  private readonly buildLLPlClient: (
+    shouldUseGzip: boolean,
+    wireProtocol?: wireProtocol,
+  ) => Promise<LLPlClient>;
   private _ll?: LLPlClient;
 
   private get ll(): LLPlClient {
     if (this._ll === undefined) {
-      throw new Error('LLPlClient not initialized');
+      throw new Error("LLPlClient not initialized");
     }
     return this._ll;
   }
@@ -93,9 +99,13 @@ export class PlClient {
       logger?: MiLogger;
     } = {},
   ) {
-    const conf = typeof configOrAddress === 'string' ? plAddressToConfig(configOrAddress) : configOrAddress;
+    const conf =
+      typeof configOrAddress === "string" ? plAddressToConfig(configOrAddress) : configOrAddress;
 
-    this.buildLLPlClient = async (shouldUseGzip: boolean, wireProtocol?: wireProtocol): Promise<LLPlClient> => {
+    this.buildLLPlClient = async (
+      shouldUseGzip: boolean,
+      wireProtocol?: wireProtocol,
+    ): Promise<LLPlClient> => {
       if (wireProtocol) conf.wireProtocol = wireProtocol;
       return await LLPlClient.build(conf, { auth, ...ops, shouldUseGzip });
     };
@@ -108,18 +118,18 @@ export class PlClient {
       sizeCalculation: (v) => (v.basicData.data?.length ?? 0) + 64,
     });
     switch (conf.retryBackoffAlgorithm) {
-      case 'exponential':
+      case "exponential":
         this.defaultRetryOptions = {
-          type: 'exponentialBackoff',
+          type: "exponentialBackoff",
           initialDelay: conf.retryInitialDelay,
           maxAttempts: conf.retryMaxAttempts,
           backoffMultiplier: conf.retryExponentialBackoffMultiplier,
           jitter: conf.retryJitter,
         };
         break;
-      case 'linear':
+      case "linear":
         this.defaultRetryOptions = {
-          type: 'linearBackoff',
+          type: "linearBackoff",
           initialDelay: conf.retryInitialDelay,
           maxAttempts: conf.retryMaxAttempts,
           backoffStep: conf.retryLinearBackoffStep,
@@ -180,7 +190,7 @@ export class PlClient {
   }
 
   private checkInitialized() {
-    if (!this.initialized) throw new Error('Client not initialized');
+    if (!this.initialized) throw new Error("Client not initialized");
   }
 
   public get clientRoot(): ResourceId {
@@ -195,7 +205,7 @@ export class PlClient {
 
   /** Currently implements custom logic to emulate future behaviour with single root. */
   private async init() {
-    if (this.initialized) throw new Error('Already initialized');
+    if (this.initialized) throw new Error("Already initialized");
 
     // Initial client is created without gzip to perform server ping and detect optimal wire protocol.
     // LLPlClient.build() internally calls detectOptimalWireProtocol() which starts with default 'grpc',
@@ -208,8 +218,8 @@ export class PlClient {
 
     // calculating reproducible root name from the username
     const user = this._ll.authUser;
-    const mainRootName
-       = user === null ? AnonymousClientRoot : createHash('sha256').update(user).digest('hex');
+    const mainRootName =
+      user === null ? AnonymousClientRoot : createHash("sha256").update(user).digest("hex");
 
     this._serverInfo = await this.ping();
     if (this._serverInfo.compression === MaintenanceAPI_Ping_Response_Compression.GZIP) {
@@ -217,7 +227,7 @@ export class PlClient {
       this._ll = await this.buildLLPlClient(true, wireProtocol);
     }
 
-    this._clientRoot = await this._withTx('initialization', true, NullResourceId, async (tx) => {
+    this._clientRoot = await this._withTx("initialization", true, NullResourceId, async (tx) => {
       let mainRoot: AnyResourceRef;
 
       if (await tx.checkResourceNameExists(mainRootName))
@@ -238,7 +248,7 @@ export class PlClient {
 
         const altRoot = tx.createEphemeral(ClientRoot);
         tx.lock(altRoot);
-        tx.createField(aFId, 'Dynamic');
+        tx.createField(aFId, "Dynamic");
         tx.setField(aFId, altRoot);
         await tx.commit();
 
@@ -251,8 +261,8 @@ export class PlClient {
   public async deleteAlternativeRoot(alternativeRootName: string): Promise<boolean> {
     this.checkInitialized();
     if (this.ll.conf.alternativeRoot !== undefined)
-      throw new Error('Initialized with alternative root.');
-    return await this.withWriteTx('delete-alternative-root', async (tx) => {
+      throw new Error("Initialized with alternative root.");
+    return await this.withWriteTx("delete-alternative-root", async (tx) => {
       const fId = {
         resourceId: tx.clientRoot,
         fieldName: alternativeRootFieldName(alternativeRootName),
@@ -307,7 +317,7 @@ export class PlClient {
             // collecting stat
             this._txConflictStat = addStat(this._txConflictStat, tx.stat);
           } else {
-          // collecting stat
+            // collecting stat
             this._txErrorStat = addStat(this._txErrorStat, tx.stat);
             throw e;
           }
@@ -325,8 +335,7 @@ export class PlClient {
 
         if (ok) {
           // syncing on transaction if requested
-          if (ops?.sync === undefined ? this.forceSync : ops?.sync)
-            await this.ll.txSync(txId);
+          if (ops?.sync === undefined ? this.forceSync : ops?.sync) await this.ll.txSync(txId);
 
           // introducing artificial delay, if requested
           if (writable && this.txDelay > 0)

package/src/core/config.test.ts

@@ -1,86 +1,86 @@
-import { DEFAULT_RO_TX_TIMEOUT, DEFAULT_RW_TX_TIMEOUT, plAddressToConfig } from './config';
-import { test, expect } from 'vitest';
+import { DEFAULT_RO_TX_TIMEOUT, DEFAULT_RW_TX_TIMEOUT, plAddressToConfig } from "./config";
+import { test, expect } from "vitest";
 
-test('config form url no auth', () => {
-  const conf = plAddressToConfig('http://127.0.0.1:6345');
+test("config form url no auth", () => {
+  const conf = plAddressToConfig("http://127.0.0.1:6345");
   expect(conf.user).toBeUndefined();
   expect(conf.password).toBeUndefined();
 });
 
-test('config form url with auth', () => {
-  const conf = plAddressToConfig('http://user1:password2@127.0.0.1:6345');
-  expect(conf.user).toEqual('user1');
-  expect(conf.password).toEqual('password2');
+test("config form url with auth", () => {
+  const conf = plAddressToConfig("http://user1:password2@127.0.0.1:6345");
+  expect(conf.user).toEqual("user1");
+  expect(conf.password).toEqual("password2");
 });
 
-test('config form url with auth and special symbols', () => {
-  const conf = plAddressToConfig('http://user1:password232$@127.0.0.1:6345');
-  expect(conf.user).toEqual('user1');
-  expect(conf.password).toEqual('password232$');
+test("config form url with auth and special symbols", () => {
+  const conf = plAddressToConfig("http://user1:password232$@127.0.0.1:6345");
+  expect(conf.user).toEqual("user1");
+  expect(conf.password).toEqual("password232$");
   expect(conf.defaultROTransactionTimeout).toEqual(DEFAULT_RO_TX_TIMEOUT);
   expect(conf.defaultRWTransactionTimeout).toEqual(DEFAULT_RW_TX_TIMEOUT);
 });
 
-test('config form url with auth and special symbols and tx timeout', () => {
-  const conf = plAddressToConfig('http://user1:password232$@127.0.0.1:6345/?tx-timeout=11341');
-  expect(conf.user).toEqual('user1');
-  expect(conf.password).toEqual('password232$');
+test("config form url with auth and special symbols and tx timeout", () => {
+  const conf = plAddressToConfig("http://user1:password232$@127.0.0.1:6345/?tx-timeout=11341");
+  expect(conf.user).toEqual("user1");
+  expect(conf.password).toEqual("password232$");
   expect(conf.defaultROTransactionTimeout).toEqual(11341);
   expect(conf.defaultRWTransactionTimeout).toEqual(11341);
 });
 
-test('config form url with auth and special symbols and ro tx timeout', () => {
-  const conf = plAddressToConfig('http://user1:password232$@127.0.0.1:6345/?ro-tx-timeout=11341');
-  expect(conf.user).toEqual('user1');
-  expect(conf.password).toEqual('password232$');
+test("config form url with auth and special symbols and ro tx timeout", () => {
+  const conf = plAddressToConfig("http://user1:password232$@127.0.0.1:6345/?ro-tx-timeout=11341");
+  expect(conf.user).toEqual("user1");
+  expect(conf.password).toEqual("password232$");
   expect(conf.defaultROTransactionTimeout).toEqual(11341);
   expect(conf.defaultRWTransactionTimeout).toEqual(DEFAULT_RW_TX_TIMEOUT);
 });
 
-test('should correctly handle http URL with no explicit port, defaulting to 80', () => {
-  const config = plAddressToConfig('http://example.com');
-  expect(config.hostAndPort).toBe('example.com:80');
+test("should correctly handle http URL with no explicit port, defaulting to 80", () => {
+  const config = plAddressToConfig("http://example.com");
+  expect(config.hostAndPort).toBe("example.com:80");
   expect(config.ssl).toBe(false);
 });
 
-test('should correctly handle http URL with explicit port 80', () => {
-  const config = plAddressToConfig('http://example.com:80');
-  expect(config.hostAndPort).toBe('example.com:80');
+test("should correctly handle http URL with explicit port 80", () => {
+  const config = plAddressToConfig("http://example.com:80");
+  expect(config.hostAndPort).toBe("example.com:80");
   expect(config.ssl).toBe(false);
 });
 
-test('should correctly handle https URL with no explicit port, defaulting to 443', () => {
-  const config = plAddressToConfig('https://example.com');
-  expect(config.hostAndPort).toBe('example.com:443');
+test("should correctly handle https URL with no explicit port, defaulting to 443", () => {
+  const config = plAddressToConfig("https://example.com");
+  expect(config.hostAndPort).toBe("example.com:443");
   expect(config.ssl).toBe(true);
 });
 
-test('should correctly handle https URL with explicit port 443', () => {
-  const config = plAddressToConfig('https://example.com:443');
-  expect(config.hostAndPort).toBe('example.com:443');
+test("should correctly handle https URL with explicit port 443", () => {
+  const config = plAddressToConfig("https://example.com:443");
+  expect(config.hostAndPort).toBe("example.com:443");
   expect(config.ssl).toBe(true);
 });
 
-test('should retain non-default port for http URL', () => {
-  const config = plAddressToConfig('http://example.com:8080');
-  expect(config.hostAndPort).toBe('example.com:8080');
+test("should retain non-default port for http URL", () => {
+  const config = plAddressToConfig("http://example.com:8080");
+  expect(config.hostAndPort).toBe("example.com:8080");
   expect(config.ssl).toBe(false);
 });
 
-test('should retain non-default port for https URL', () => {
-  const config = plAddressToConfig('https://example.com:8443');
-  expect(config.hostAndPort).toBe('example.com:8443');
+test("should retain non-default port for https URL", () => {
+  const config = plAddressToConfig("https://example.com:8443");
+  expect(config.hostAndPort).toBe("example.com:8443");
   expect(config.ssl).toBe(true);
 });
 
-test('should throw an error for grpc URL without an explicit port', () => {
-  expect(() => plAddressToConfig('grpc://example.com')).toThrow(
-    'Port must be specified explicitly for grpc: protocol.',
+test("should throw an error for grpc URL without an explicit port", () => {
+  expect(() => plAddressToConfig("grpc://example.com")).toThrow(
+    "Port must be specified explicitly for grpc: protocol.",
   );
 });
 
-test('should throw an error for tls URL without an explicit port', () => {
-  expect(() => plAddressToConfig('tls://example.com')).toThrow(
-    'Port must be specified explicitly for tls: protocol.',
+test("should throw an error for tls URL without an explicit port", () => {
+  expect(() => plAddressToConfig("tls://example.com")).toThrow(
+    "Port must be specified explicitly for tls: protocol.",
   );
 });