@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/core/config.ts

@@ -1,7 +1,7 @@
-import type { ProxySettings } from '@milaboratories/pl-http';
-import type { ExponentialBackoffRetryOptions } from '@milaboratories/ts-helpers';
+import type { ProxySettings } from "@milaboratories/pl-http";
+import type { ExponentialBackoffRetryOptions } from "@milaboratories/ts-helpers";
 
-export const SUPPORTED_WIRE_PROTOCOLS = ['grpc', 'rest'] as const;
+export const SUPPORTED_WIRE_PROTOCOLS = ["grpc", "rest"] as const;
 export type wireProtocol = (typeof SUPPORTED_WIRE_PROTOCOLS)[number];
 
 /** Base configuration structure for PL client */
@@ -69,7 +69,7 @@ export interface PlClientConfig {
    * What type of backoff strategy to use in transaction retries
    * (pl uses optimistic transaction model with regular retries in write transactions)
    */
-  retryBackoffAlgorithm: 'exponential' | 'linear';
+  retryBackoffAlgorithm: "exponential" | "linear";
 
   /** Maximal number of attempts in */
   retryMaxAttempts: number;
@@ -95,7 +95,7 @@ export const DEFAULT_AUTH_MAX_REFRESH = 12 * 24 * 60 * 60;
 
 export const DEFAULT_MAX_CACHE_BYTES = 128_000_000; // 128 Mb
 
-export const DEFAULT_RETRY_BACKOFF_ALGORITHM = 'exponential';
+export const DEFAULT_RETRY_BACKOFF_ALGORITHM = "exponential";
 export const DEFAULT_RETRY_MAX_ATTEMPTS = 21; // 1st attempt + 20 retries
 export const DEFAULT_RETRY_INITIAL_DELAY = 20; // 20 ms * <jitter> of sleep after first failure
 export const DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER = 1.5; // + 50% on each round
@@ -103,7 +103,7 @@ export const DEFAULT_RETRY_LINEAR_BACKOFF_STEP = 50; // + 50 ms
 export const DEFAULT_RETRY_JITTER = 0.3; // 30%
 
 export const DefaultRetryOptions: ExponentialBackoffRetryOptions = {
-  type: 'exponentialBackoff',
+  type: "exponentialBackoff",
   maxAttempts: DEFAULT_RETRY_MAX_ATTEMPTS,
   initialDelay: DEFAULT_RETRY_INITIAL_DELAY,
   backoffMultiplier: DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER,
@@ -113,12 +113,12 @@ export const DefaultRetryOptions: ExponentialBackoffRetryOptions = {
 type PlConfigOverrides = Partial<
   Pick<
     PlClientConfig,
-    | 'ssl'
-    | 'defaultRequestTimeout'
-    | 'defaultROTransactionTimeout'
-    | 'defaultRWTransactionTimeout'
-    | 'httpProxy'
-    | 'grpcProxy'
+    | "ssl"
+    | "defaultRequestTimeout"
+    | "defaultROTransactionTimeout"
+    | "defaultRWTransactionTimeout"
+    | "httpProxy"
+    | "grpcProxy"
   >
 >;
 
@@ -135,7 +135,7 @@ export function plAddressToConfig(
   address: string,
   overrides: PlConfigOverrides = {},
 ): PlClientConfig {
-  if (address.indexOf('://') === -1)
+  if (address.indexOf("://") === -1)
     // non-url address
     return {
       hostAndPort: address,
@@ -163,24 +163,24 @@ export function plAddressToConfig(
   const url = new URL(address);
 
   if (
-    url.protocol !== 'https:'
-    && url.protocol !== 'http:'
-    && url.protocol !== 'grpc:'
-    && url.protocol !== 'tls:'
+    url.protocol !== "https:" &&
+    url.protocol !== "http:" &&
+    url.protocol !== "grpc:" &&
+    url.protocol !== "tls:"
   )
     throw new Error(`Unexpected URL schema: ${url.protocol}`);
 
-  if (url.pathname !== '/' && url.pathname !== '')
+  if (url.pathname !== "/" && url.pathname !== "")
     throw new Error(`Unexpected URL path: ${url.pathname}`);
 
   let port = url.port;
   if (!port) {
     switch (url.protocol) {
-      case 'http:':
-        port = '80';
+      case "http:":
+        port = "80";
         break;
-      case 'https:':
-        port = '443';
+      case "https:":
+        port = "443";
         break;
       default:
         throw new Error(`Port must be specified explicitly for ${url.protocol} protocol.`);
@@ -189,45 +189,45 @@ export function plAddressToConfig(
 
   return {
     hostAndPort: `${url.hostname}:${port}`,
-    alternativeRoot: url.searchParams.get('alternative-root') ?? undefined,
-    ssl: url.protocol === 'https:' || url.protocol === 'tls:',
+    alternativeRoot: url.searchParams.get("alternative-root") ?? undefined,
+    ssl: url.protocol === "https:" || url.protocol === "tls:",
 
-    wireProtocol: url.searchParams.get('wire-protocol') as wireProtocol ?? undefined,
+    wireProtocol: (url.searchParams.get("wire-protocol") as wireProtocol) ?? undefined,
 
     defaultRequestTimeout:
-      parseInt(url.searchParams.get('request-timeout')) ?? DEFAULT_REQUEST_TIMEOUT,
+      parseInt(url.searchParams.get("request-timeout")) ?? DEFAULT_REQUEST_TIMEOUT,
     defaultROTransactionTimeout:
-      parseInt(url.searchParams.get('ro-tx-timeout'))
-      ?? parseInt(url.searchParams.get('tx-timeout'))
-      ?? DEFAULT_RO_TX_TIMEOUT,
+      parseInt(url.searchParams.get("ro-tx-timeout")) ??
+      parseInt(url.searchParams.get("tx-timeout")) ??
+      DEFAULT_RO_TX_TIMEOUT,
     defaultRWTransactionTimeout:
-      parseInt(url.searchParams.get('rw-tx-timeout'))
-      ?? parseInt(url.searchParams.get('tx-timeout'))
-      ?? DEFAULT_RW_TX_TIMEOUT,
+      parseInt(url.searchParams.get("rw-tx-timeout")) ??
+      parseInt(url.searchParams.get("tx-timeout")) ??
+      DEFAULT_RW_TX_TIMEOUT,
     authTTLSeconds: DEFAULT_TOKEN_TTL_SECONDS,
     authMaxRefreshSeconds: DEFAULT_AUTH_MAX_REFRESH,
-    grpcProxy: url.searchParams.get('grpc-proxy') ?? undefined,
-    httpProxy: url.searchParams.get('http-proxy') ?? undefined,
-    user: url.username === '' ? undefined : url.username,
-    password: url.password === '' ? undefined : url.password,
-    txDelay: parseInt(url.searchParams.get('tx-delay')) ?? 0,
-    forceSync: Boolean(url.searchParams.get('force-sync')),
+    grpcProxy: url.searchParams.get("grpc-proxy") ?? undefined,
+    httpProxy: url.searchParams.get("http-proxy") ?? undefined,
+    user: url.username === "" ? undefined : url.username,
+    password: url.password === "" ? undefined : url.password,
+    txDelay: parseInt(url.searchParams.get("tx-delay")) ?? 0,
+    forceSync: Boolean(url.searchParams.get("force-sync")),
 
-    maxCacheBytes: parseInt(url.searchParams.get('max-cache-bytes')) ?? DEFAULT_MAX_CACHE_BYTES,
+    maxCacheBytes: parseInt(url.searchParams.get("max-cache-bytes")) ?? DEFAULT_MAX_CACHE_BYTES,
 
-    retryBackoffAlgorithm: (url.searchParams.get('retry-backoff-algorithm')
-      ?? DEFAULT_RETRY_BACKOFF_ALGORITHM) as any,
+    retryBackoffAlgorithm: (url.searchParams.get("retry-backoff-algorithm") ??
+      DEFAULT_RETRY_BACKOFF_ALGORITHM) as any,
     retryMaxAttempts:
-      parseInt(url.searchParams.get('retry-max-attempts')) ?? DEFAULT_RETRY_MAX_ATTEMPTS,
+      parseInt(url.searchParams.get("retry-max-attempts")) ?? DEFAULT_RETRY_MAX_ATTEMPTS,
     retryInitialDelay:
-      parseInt(url.searchParams.get('retry-initial-delay')) ?? DEFAULT_RETRY_INITIAL_DELAY,
+      parseInt(url.searchParams.get("retry-initial-delay")) ?? DEFAULT_RETRY_INITIAL_DELAY,
     retryExponentialBackoffMultiplier:
-      parseInt(url.searchParams.get('retry-exp-backoff-multiplier'))
-      ?? DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER,
+      parseInt(url.searchParams.get("retry-exp-backoff-multiplier")) ??
+      DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER,
     retryLinearBackoffStep:
-      parseInt(url.searchParams.get('retry-linear-backoff-step'))
-      ?? DEFAULT_RETRY_LINEAR_BACKOFF_STEP,
-    retryJitter: parseInt(url.searchParams.get('retry-backoff-jitter')) ?? DEFAULT_RETRY_JITTER,
+      parseInt(url.searchParams.get("retry-linear-backoff-step")) ??
+      DEFAULT_RETRY_LINEAR_BACKOFF_STEP,
+    retryJitter: parseInt(url.searchParams.get("retry-backoff-jitter")) ?? DEFAULT_RETRY_JITTER,
 
     ...overrides,
   };
@@ -257,7 +257,7 @@ export interface AuthOps {
 }
 
 /** Connection status. */
-export type PlConnectionStatus = 'OK' | 'Disconnected' | 'Unauthenticated';
+export type PlConnectionStatus = "OK" | "Disconnected" | "Unauthenticated";
 
 /** Listener that will be called each time connection status changes. */
 export type PlConnectionStatusListener = (status: PlConnectionStatus) => void;

package/src/core/connectivity.test.ts

@@ -1,70 +1,76 @@
-import { withTempRoot } from '../test/test_config';
-import { StructTestResource } from '../helpers/pl';
-import { toGlobalFieldId } from './transaction';
-import { test, expect } from 'vitest';
-import { sleep } from '@milaboratories/ts-helpers';
-import { DisconnectedError } from './errors';
+import { withTempRoot } from "../test/test_config";
+import { StructTestResource } from "../helpers/pl";
+import { toGlobalFieldId } from "./transaction";
+import { test, expect } from "vitest";
+import { sleep } from "@milaboratories/ts-helpers";
+import { DisconnectedError } from "./errors";
 
-test('connectivity: disconnect during tx', async () => {
-  await withTempRoot(async (pl, proxy) => {
-    await expect(async () => {
-      await pl.withWriteTx('resource1', async (tx) => {
-        const r0 = tx.createStruct(StructTestResource);
-        const r1 = tx.createStruct(StructTestResource);
-        const f0 = { resourceId: tx.clientRoot, fieldName: 'test0' };
-        const f1 = { resourceId: tx.clientRoot, fieldName: 'test1' };
-  
-        tx.createField(f0, 'Dynamic');
-        tx.createField(f1, 'Dynamic');
-        tx.setField(f0, r0);
-        tx.setField(f1, r1);
-  
-        await proxy?.disconnectAll();
+test("connectivity: disconnect during tx", async () => {
+  await withTempRoot(
+    async (pl, proxy) => {
+      await expect(async () => {
+        await pl.withWriteTx("resource1", async (tx) => {
+          const r0 = tx.createStruct(StructTestResource);
+          const r1 = tx.createStruct(StructTestResource);
+          const f0 = { resourceId: tx.clientRoot, fieldName: "test0" };
+          const f1 = { resourceId: tx.clientRoot, fieldName: "test1" };
 
-        await sleep(1);
-  
-        const theField1 = { resourceId: r1, fieldName: 'theField' };
-        tx.createField(theField1, 'Input');
-        tx.lock(r1);
-        tx.setField(theField1, tx.getFutureFieldValue(r0, 'theField', 'Input'));
-  
-        await tx.commit();
-  
-        return [await r0.globalId, await toGlobalFieldId(theField1)];
-      });
-    }).rejects.toThrow(DisconnectedError);
-  }, { viaTcpProxy: true });
+          tx.createField(f0, "Dynamic");
+          tx.createField(f1, "Dynamic");
+          tx.setField(f0, r0);
+          tx.setField(f1, r1);
+
+          await proxy?.disconnectAll();
+
+          await sleep(1);
+
+          const theField1 = { resourceId: r1, fieldName: "theField" };
+          tx.createField(theField1, "Input");
+          tx.lock(r1);
+          tx.setField(theField1, tx.getFutureFieldValue(r0, "theField", "Input"));
+
+          await tx.commit();
+
+          return [await r0.globalId, await toGlobalFieldId(theField1)];
+        });
+      }).rejects.toThrow(DisconnectedError);
+    },
+    { viaTcpProxy: true },
+  );
 });
 
-test.skip('connectivity: latency', async () => {
-  await withTempRoot(async (pl, proxy) => {
-    proxy?.setLatency(10_000);
-    await expect(async () => {
-      const result = await pl.withWriteTx('resource1', async (tx) => {
-        const r0 = tx.createStruct(StructTestResource);
-        const r1 = tx.createStruct(StructTestResource);
-        const f0 = { resourceId: tx.clientRoot, fieldName: 'test0' };
-        const f1 = { resourceId: tx.clientRoot, fieldName: 'test1' };
-  
-        tx.createField(f0, 'Dynamic');
-        tx.createField(f1, 'Dynamic');
-        tx.setField(f0, r0);
-        tx.setField(f1, r1);
-  
-        const theField1 = { resourceId: r1, fieldName: 'theField' };
-        tx.createField(theField1, 'Input');
-        tx.lock(r1);
-        tx.setField(theField1, tx.getFutureFieldValue(r0, 'theField', 'Input'));
-  
-        await tx.commit().catch((err) => console.log('error committing tx', err));
-  
-        return [await r0.globalId, await toGlobalFieldId(theField1)];
-      });
+test.skip("connectivity: latency", async () => {
+  await withTempRoot(
+    async (pl, proxy) => {
+      proxy?.setLatency(10_000);
+      await expect(async () => {
+        const result = await pl.withWriteTx("resource1", async (tx) => {
+          const r0 = tx.createStruct(StructTestResource);
+          const r1 = tx.createStruct(StructTestResource);
+          const f0 = { resourceId: tx.clientRoot, fieldName: "test0" };
+          const f1 = { resourceId: tx.clientRoot, fieldName: "test1" };
+
+          tx.createField(f0, "Dynamic");
+          tx.createField(f1, "Dynamic");
+          tx.setField(f0, r0);
+          tx.setField(f1, r1);
+
+          const theField1 = { resourceId: r1, fieldName: "theField" };
+          tx.createField(theField1, "Input");
+          tx.lock(r1);
+          tx.setField(theField1, tx.getFutureFieldValue(r0, "theField", "Input"));
+
+          await tx.commit().catch((err) => console.log("error committing tx", err));
+
+          return [await r0.globalId, await toGlobalFieldId(theField1)];
+        });
 
-      console.log('result', result);
+        console.log("result", result);
 
-      return result;
-    }).rejects.toThrow(Error);
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  }, { viaTcpProxy: true });
+        return result;
+      }).rejects.toThrow(Error);
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    },
+    { viaTcpProxy: true },
+  );
 }, 60_000);

package/src/core/default_client.ts

@@ -1,20 +1,20 @@
-import fs from 'node:fs';
-import type { AuthInformation, PlClientConfig } from './config';
-import { plAddressToConfig } from './config';
-import canonicalize from 'canonicalize';
-import YAML from 'yaml';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { notEmpty } from '@milaboratories/ts-helpers';
-import { UnauthenticatedPlClient } from './unauth_client';
-import { PlClient } from './client';
-import { createHash } from 'node:crypto';
-import { inferAuthRefreshTime } from './auth';
-
-const CONFIG_FILE_LOCAL_JSON = 'pl.json';
-const CONFIG_FILE_USER_JSON = path.join(os.homedir(), '.pl.json');
-const CONFIG_FILE_LOCAL_YAML = 'pl.yaml';
-const CONFIG_FILE_USER_YAML = path.join(os.homedir(), '.pl.yaml');
+import fs from "node:fs";
+import type { AuthInformation, PlClientConfig } from "./config";
+import { plAddressToConfig } from "./config";
+import canonicalize from "canonicalize";
+import YAML from "yaml";
+import * as os from "node:os";
+import * as path from "node:path";
+import { notEmpty } from "@milaboratories/ts-helpers";
+import { UnauthenticatedPlClient } from "./unauth_client";
+import { PlClient } from "./client";
+import { createHash } from "node:crypto";
+import { inferAuthRefreshTime } from "./auth";
+
+const CONFIG_FILE_LOCAL_JSON = "pl.json";
+const CONFIG_FILE_USER_JSON = path.join(os.homedir(), ".pl.json");
+const CONFIG_FILE_LOCAL_YAML = "pl.yaml";
+const CONFIG_FILE_USER_YAML = path.join(os.homedir(), ".pl.yaml");
 const CONF_FILE_SEQUENCE = [
   CONFIG_FILE_LOCAL_JSON,
   CONFIG_FILE_LOCAL_YAML,
@@ -22,30 +22,30 @@ const CONF_FILE_SEQUENCE = [
   CONFIG_FILE_USER_YAML,
 ];
 
-const AUTH_DATA_FILE = '.pl_auth.json';
+const AUTH_DATA_FILE = ".pl_auth.json";
 
 type FileConfigOverrideFields =
-  | 'grpcProxy'
-  | 'httpProxy'
-  | 'user'
-  | 'password'
-  | 'alternativeRoot'
-  | 'defaultROTransactionTimeout'
-  | 'defaultRWTransactionTimeout'
-  | 'defaultRequestTimeout'
-  | 'authTTLSeconds'
-  | 'authMaxRefreshSeconds';
+  | "grpcProxy"
+  | "httpProxy"
+  | "user"
+  | "password"
+  | "alternativeRoot"
+  | "defaultROTransactionTimeout"
+  | "defaultRWTransactionTimeout"
+  | "defaultRequestTimeout"
+  | "authTTLSeconds"
+  | "authMaxRefreshSeconds";
 const FILE_CONFIG_OVERRIDE_FIELDS: FileConfigOverrideFields[] = [
-  'grpcProxy',
-  'httpProxy',
-  'user',
-  'password',
-  'alternativeRoot',
-  'defaultROTransactionTimeout',
-  'defaultRWTransactionTimeout',
-  'defaultRequestTimeout',
-  'authTTLSeconds',
-  'authMaxRefreshSeconds',
+  "grpcProxy",
+  "httpProxy",
+  "user",
+  "password",
+  "alternativeRoot",
+  "defaultROTransactionTimeout",
+  "defaultRWTransactionTimeout",
+  "defaultRequestTimeout",
+  "authTTLSeconds",
+  "authMaxRefreshSeconds",
 ];
 
 type PlConfigFile = {
@@ -62,8 +62,8 @@ interface AuthCache {
 export function tryGetFileConfig(): [PlConfigFile, string] | undefined {
   for (const confPath of CONF_FILE_SEQUENCE)
     if (fs.existsSync(confPath)) {
-      const fileContent = fs.readFileSync(confPath, { encoding: 'utf-8' });
-      if (confPath.endsWith('json')) return [JSON.parse(fileContent) as PlConfigFile, confPath];
+      const fileContent = fs.readFileSync(confPath, { encoding: "utf-8" });
+      if (confPath.endsWith("json")) return [JSON.parse(fileContent) as PlConfigFile, confPath];
       else return [YAML.parse(fileContent) as PlConfigFile, confPath];
     }
   return undefined;
@@ -83,7 +83,7 @@ function saveAuthInfoCallback(
           expiration: inferAuthRefreshTime(newAuthInfo, authMaxRefreshSeconds),
         } as AuthCache),
       ),
-      'utf8',
+      "utf8",
     );
   };
 }
@@ -110,21 +110,21 @@ export async function defaultPlClient(): Promise<PlClient> {
   }
 
   if (config === undefined)
-    throw new Error('Can\'t find configuration to create default platform client.');
+    throw new Error("Can't find configuration to create default platform client.");
 
   if (process.env.PL_USER !== undefined) config.user = process.env.PL_USER;
 
   if (process.env.PL_PASSWORD !== undefined) config.user = process.env.PL_PASSWORD;
 
-  const confHash = createHash('sha256')
+  const confHash = createHash("sha256")
     .update(Buffer.from(canonicalize(config)!))
-    .digest('base64');
+    .digest("base64");
 
   let authInformation: AuthInformation | undefined = undefined;
 
   // try recover auth information from cache
   if (fs.existsSync(AUTH_DATA_FILE)) {
-    const cache: AuthCache = JSON.parse(fs.readFileSync(AUTH_DATA_FILE, { encoding: 'utf-8' }));
+    const cache: AuthCache = JSON.parse(fs.readFileSync(AUTH_DATA_FILE, { encoding: "utf-8" }));
     if (cache.confHash === confHash && cache.expiration > Date.now())
       authInformation = cache.authInformation;
   }
@@ -151,7 +151,7 @@ export async function defaultPlClient(): Promise<PlClient> {
           expiration: inferAuthRefreshTime(authInformation, config.authMaxRefreshSeconds),
         } as AuthCache),
       ),
-      'utf8',
+      "utf8",
     );
   }
 

package/src/core/driver.ts

@@ -1,8 +1,8 @@
-import type { PlClient } from './client';
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import type { Dispatcher } from 'undici';
-import type { ResourceType } from './types';
-import type { WireClientProviderFactory } from './wire';
+import type { PlClient } from "./client";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+import type { Dispatcher } from "undici";
+import type { ResourceType } from "./types";
+import type { WireClientProviderFactory } from "./wire";
 
 /** Drivers must implement this interface */
 export interface PlDriver {
@@ -24,7 +24,7 @@ export interface PlDriverDefinition<Drv extends PlDriver> {
 export function addRTypeToMetadata(rType: ResourceType, options?: RpcOptions) {
   options = options ?? {};
   options.meta = options.meta ?? {};
-  options.meta['resourceType'] = `${rType.name}:${rType.version}`;
+  options.meta["resourceType"] = `${rType.name}:${rType.version}`;
 
   return options;
 }

package/src/core/error.test.ts

@@ -1,14 +1,14 @@
-import * as tp from 'node:timers/promises';
-import { isTimeoutOrCancelError } from './errors';
-import { test, expect } from 'vitest';
+import * as tp from "node:timers/promises";
+import { isTimeoutOrCancelError } from "./errors";
+import { test, expect } from "vitest";
 
-test('timeout of sleep error type detection', async () => {
+test("timeout of sleep error type detection", async () => {
   let noError = false;
   try {
     await tp.setTimeout(1000, undefined, { signal: AbortSignal.timeout(10) });
     noError = true;
   } catch (err: unknown) {
-    expect((err as any).code).toStrictEqual('ABORT_ERR');
+    expect((err as any).code).toStrictEqual("ABORT_ERR");
     expect(isTimeoutOrCancelError(err)).toEqual(true);
   }
   expect(noError).toBe(false);

package/src/core/error_resource.ts

@@ -1,10 +1,10 @@
-import type { ResourceType } from './types';
+import type { ResourceType } from "./types";
 
 export type ErrorResourceData = {
   message: string;
 };
 
 export const ErrorResourceType: ResourceType = {
-  name: 'json/resourceError',
-  version: '1',
+  name: "json/resourceError",
+  version: "1",
 };