@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/core/errors.ts

@@ -1,14 +1,15 @@
-import type { Status } from '../proto-grpc/github.com/googleapis/googleapis/google/rpc/status';
-import { Aborted } from '@milaboratories/ts-helpers';
-import { Code } from '../proto-grpc/google/rpc/code';
+import type { Status } from "../proto-grpc/github.com/googleapis/googleapis/google/rpc/status";
+import { Aborted } from "@milaboratories/ts-helpers";
+import { Code } from "../proto-grpc/google/rpc/code";
 
 export function isConnectionProblem(err: unknown, nested: boolean = false): boolean {
   if (err === undefined || err === null) return false;
 
   if (err instanceof DisconnectedError) return true;
-  if ((err as any).name == 'RpcError' && (err as any).code == 'UNAVAILABLE') return true;
-  if ((err as any).name == 'RESTError' && (err as any).status.code == Code.UNAVAILABLE) return true;
-  if ((err as any).cause !== undefined && !nested) return isConnectionProblem((err as any).cause, true);
+  if ((err as any).name == "RpcError" && (err as any).code == "UNAVAILABLE") return true;
+  if ((err as any).name == "RESTError" && (err as any).status.code == Code.UNAVAILABLE) return true;
+  if ((err as any).cause !== undefined && !nested)
+    return isConnectionProblem((err as any).cause, true);
   return false;
 }
 
@@ -16,18 +17,21 @@ export function isUnauthenticated(err: unknown, nested: boolean = false): boolea
   if (err === undefined || err === null) return false;
 
   if (err instanceof UnauthenticatedError) return true;
-  if ((err as any).name == 'RpcError' && (err as any).code == 'UNAUTHENTICATED') return true;
-  if ((err as any).name == 'RESTError' && (err as any).status.code == Code.UNAUTHENTICATED) return true;
-  if ((err as any).cause !== undefined && !nested) return isUnauthenticated((err as any).cause, true);
+  if ((err as any).name == "RpcError" && (err as any).code == "UNAUTHENTICATED") return true;
+  if ((err as any).name == "RESTError" && (err as any).status.code == Code.UNAUTHENTICATED)
+    return true;
+  if ((err as any).cause !== undefined && !nested)
+    return isUnauthenticated((err as any).cause, true);
   return false;
 }
 
 export function isTimeoutError(err: unknown, nested: boolean = false): boolean {
   if (err === undefined || err === null) return false;
 
-  if ((err as any).name == 'TimeoutError') return true;
-  if ((err as any).name == 'RpcError' && (err as any).code == 'DEADLINE_EXCEEDED') return true;
-  if ((err as any).name == 'RESTError' && (err as any).status.code == Code.DEADLINE_EXCEEDED) return true;
+  if ((err as any).name == "TimeoutError") return true;
+  if ((err as any).name == "RpcError" && (err as any).code == "DEADLINE_EXCEEDED") return true;
+  if ((err as any).name == "RESTError" && (err as any).status.code == Code.DEADLINE_EXCEEDED)
+    return true;
   if ((err as any).cause !== undefined && !nested) return isTimeoutError((err as any).cause, true);
   return false;
 }
@@ -35,8 +39,8 @@ export function isTimeoutError(err: unknown, nested: boolean = false): boolean {
 export function isCancelError(err: unknown, nested: boolean = false): boolean {
   if (err === undefined || err === null) return false;
 
-  if ((err as any).name == 'RpcError' && (err as any).code == 'CANCELLED') return true;
-  if ((err as any).name == 'RESTError' && (err as any).status.code == Code.CANCELLED) return true;
+  if ((err as any).name == "RpcError" && (err as any).code == "CANCELLED") return true;
+  if ((err as any).name == "RESTError" && (err as any).status.code == Code.CANCELLED) return true;
   if ((err as any).cause !== undefined && !nested) return isCancelError((err as any).cause, true);
   return false;
 }
@@ -44,11 +48,11 @@ export function isCancelError(err: unknown, nested: boolean = false): boolean {
 export function isAbortedError(err: unknown, nested: boolean = false): boolean {
   if (err === undefined || err === null) return false;
 
-  if (err instanceof Aborted || (err as any).name == 'AbortError') return true;
-  if ((err as any).code == 'ABORT_ERR') return true;
+  if (err instanceof Aborted || (err as any).name == "AbortError") return true;
+  if ((err as any).code == "ABORT_ERR") return true;
   if (err instanceof DOMException && err.code === DOMException.ABORT_ERR) return true; // WebSocket error
-  if ((err as any).name == 'RpcError' && (err as any).code == 'ABORTED') return true;
-  if ((err as any).name == 'RESTError' && (err as any).status.code == Code.ABORTED) return true;
+  if ((err as any).name == "RpcError" && (err as any).code == "ABORTED") return true;
+  if ((err as any).name == "RESTError" && (err as any).status.code == Code.ABORTED) return true;
   if ((err as any).cause !== undefined && !nested) isAbortedError((err as any).cause, true);
   return false;
 }
@@ -59,15 +63,16 @@ export function isTimeoutOrCancelError(err: unknown, nested: boolean = false): b
   if (isAbortedError(err, true)) return true;
   if (isTimeoutError(err, true)) return true;
   if (isCancelError(err, true)) return true;
-  if ((err as any).cause !== undefined && !nested) return isTimeoutOrCancelError((err as any).cause, true);
+  if ((err as any).cause !== undefined && !nested)
+    return isTimeoutOrCancelError((err as any).cause, true);
   return false;
 }
 
 export function isNotFoundError(err: unknown, nested: boolean = false): boolean {
   if (err === undefined || err === null) return false;
 
-  if ((err as any).name == 'RpcError' && (err as any).code == 'NOT_FOUND') return true;
-  if ((err as any).name == 'RESTError' && (err as any).status.code == Code.NOT_FOUND) return true;
+  if ((err as any).name == "RpcError" && (err as any).code == "NOT_FOUND") return true;
+  if ((err as any).name == "RESTError" && (err as any).status.code == Code.NOT_FOUND) return true;
   if ((err as any).cause !== undefined && !nested) return isNotFoundError((err as any).cause, true);
   return err instanceof RecoverablePlError && err.status.code === PlErrorCodeNotFound;
 }
@@ -75,8 +80,11 @@ export function isNotFoundError(err: unknown, nested: boolean = false): boolean
 export const PlErrorCodeNotFound: number = Code.NOT_FOUND;
 
 export class PlError extends Error {
-  name = 'PlError';
-  constructor(public readonly status: Status, opts?: ErrorOptions) {
+  name = "PlError";
+  constructor(
+    public readonly status: Status,
+    opts?: ErrorOptions,
+  ) {
     super(`code=${status.code} ${status.message}`, opts);
   }
 }
@@ -86,35 +94,35 @@ export function throwPlNotFoundError(message: string): never {
 }
 
 export class RecoverablePlError extends PlError {
-  name = 'RecoverablePlError';
+  name = "RecoverablePlError";
   constructor(status: Status) {
     super(status);
   }
 }
 
 export class UnrecoverablePlError extends PlError {
-  name = 'UnrecoverablePlError';
+  name = "UnrecoverablePlError";
   constructor(status: Status) {
     super(status);
   }
 }
 
 export class UnauthenticatedError extends Error {
-  name = 'UnauthenticatedError';
+  name = "UnauthenticatedError";
   constructor(message: string) {
-    super('LoginFailed: ' + message);
+    super("LoginFailed: " + message);
   }
 }
 
 export class DisconnectedError extends Error {
-  name = 'DisconnectedError';
+  name = "DisconnectedError";
   constructor(message: string) {
-    super('Disconnected: ' + message);
+    super("Disconnected: " + message);
   }
 }
 
 export class RESTError extends PlError {
-  name = 'RESTError';
+  name = "RESTError";
   constructor(status: Status, opts?: ErrorOptions) {
     super(status, opts);
   }
@@ -131,7 +139,7 @@ export function rethrowMeaningfulError(error: any, wrapIfUnknown: boolean = fals
   }
   if (isTimeoutOrCancelError(error)) throw new Aborted(error);
   if (wrapIfUnknown) {
-    const message = error.message || String(error) || 'Unknown error';
+    const message = error.message || String(error) || "Unknown error";
     throw new Error(message, { cause: error });
   } else throw error;
 }

package/src/core/final.ts

@@ -1,13 +1,6 @@
-import type { Optional } from 'utility-types';
-import type {
-  BasicResourceData,
-  ResourceData,
-} from './types';
-import {
-  getField,
-  isNotNullResourceId,
-  isNullResourceId,
-} from './types';
+import type { Optional } from "utility-types";
+import type { BasicResourceData, ResourceData } from "./types";
+import { getField, isNotNullResourceId, isNullResourceId } from "./types";
 
 /**
  * Function is used to guide multiple layers of caching in pl-client and derived pl-tree.
@@ -19,7 +12,7 @@ import {
  * "final" state should be calculated for "basic" part of resource data only.
  */
 export type FinalResourceDataPredicate = (
-  resourceData: Optional<ResourceData, 'fields'>
+  resourceData: Optional<ResourceData, "fields">,
 ) => boolean;
 
 function readyOrDuplicateOrError(r: ResourceData | BasicResourceData): boolean {
@@ -28,7 +21,7 @@ function readyOrDuplicateOrError(r: ResourceData | BasicResourceData): boolean {
   );
 }
 
-function readyAndHasAllOutputsFilled(r: Optional<ResourceData, 'fields'>): boolean {
+function readyAndHasAllOutputsFilled(r: Optional<ResourceData, "fields">): boolean {
   if (!readyOrDuplicateOrError(r)) return false;
   if (!r.outputsLocked) return false;
   if (r.fields === undefined) return true; // if fields are not provided basic resource state is not expected to change in the future
@@ -43,65 +36,65 @@ const unknownResourceTypeNames = new Set<string>();
 /** Default implementation, defining behaviour for built-in resource types. */
 export const DefaultFinalResourceDataPredicate: FinalResourceDataPredicate = (r): boolean => {
   switch (r.type.name) {
-    case 'StreamManager': {
+    case "StreamManager": {
       if (!readyOrDuplicateOrError(r)) return false;
       if (r.fields === undefined) return true; // if fields are not provided basic resource state is not expected to change in the future
       if (isNotNullResourceId(r.error)) return true;
-      const downloadable = getField(r as ResourceData, 'downloadable');
-      const stream = getField(r as ResourceData, 'stream');
+      const downloadable = getField(r as ResourceData, "downloadable");
+      const stream = getField(r as ResourceData, "stream");
       return stream.value === downloadable.value;
     }
-    case 'StdMap':
-    case 'std/map':
-    case 'EphStdMap':
-    case 'PFrame':
-    case 'ParquetChunk':
-    case 'BContext':
-    case 'BlockPackCustom':
-    case 'BinaryMap':
-    case 'BinaryValue':
-    case 'BlobMap':
-    case 'BResolveSingle':
-    case 'BResolveSingleNoResult':
-    case 'BQueryResult':
-    case 'TengoTemplate':
-    case 'TengoLib':
-    case 'SoftwareInfo':
-    case 'Dummy':
+    case "StdMap":
+    case "std/map":
+    case "EphStdMap":
+    case "PFrame":
+    case "ParquetChunk":
+    case "BContext":
+    case "BlockPackCustom":
+    case "BinaryMap":
+    case "BinaryValue":
+    case "BlobMap":
+    case "BResolveSingle":
+    case "BResolveSingleNoResult":
+    case "BQueryResult":
+    case "TengoTemplate":
+    case "TengoLib":
+    case "SoftwareInfo":
+    case "Dummy":
       return readyOrDuplicateOrError(r);
-    case 'json/resourceError':
-      return r.type.version === '1';
-    case 'json/object':
-    case 'json-gz/object':
-    case 'json/string':
-    case 'json/array':
-    case 'json/number':
-    case 'BContextEnd':
-    case 'Frontend/FromUrl':
-    case 'Frontend/FromFolder':
-    case 'BObjectSpec':
-    case 'Blob':
-    case 'Null':
-    case 'binary':
-    case 'LSProvider':
+    case "json/resourceError":
+      return r.type.version === "1";
+    case "json/object":
+    case "json-gz/object":
+    case "json/string":
+    case "json/array":
+    case "json/number":
+    case "BContextEnd":
+    case "Frontend/FromUrl":
+    case "Frontend/FromFolder":
+    case "BObjectSpec":
+    case "Blob":
+    case "Null":
+    case "binary":
+    case "LSProvider":
       return true;
-    case 'UserProject':
-    case 'Projects':
-    case 'ClientRoot':
+    case "UserProject":
+    case "Projects":
+    case "ClientRoot":
       return false;
     default:
-      if (r.type.name.startsWith('Blob/')) return true;
-      else if (r.type.name.startsWith('BlobUpload/') || r.type.name.startsWith('BlobIndex/')) {
+      if (r.type.name.startsWith("Blob/")) return true;
+      else if (r.type.name.startsWith("BlobUpload/") || r.type.name.startsWith("BlobIndex/")) {
         return readyAndHasAllOutputsFilled(r);
-      } else if (r.type.name.startsWith('PColumnData/')) {
+      } else if (r.type.name.startsWith("PColumnData/")) {
         return readyOrDuplicateOrError(r);
-      } else if (r.type.name.startsWith('StreamWorkdir/')) {
+      } else if (r.type.name.startsWith("StreamWorkdir/")) {
         return readyOrDuplicateOrError(r);
       } else {
         // Unknown resource type detected
         // Set used to log this message only once
         if (!unknownResourceTypeNames.has(r.type.name)) {
-          console.log('UNKNOWN RESOURCE TYPE: ' + r.type.name);
+          console.log("UNKNOWN RESOURCE TYPE: " + r.type.name);
           unknownResourceTypeNames.add(r.type.name);
         }
       }

package/src/core/ll_client.test.ts

@@ -1,37 +1,46 @@
-import { LLPlClient } from './ll_client';
-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';
-import { test, expect } from 'vitest';
-
-import { UnauthenticatedError } from './errors';
-
-test('wire protocol detection', async () => {
+import { LLPlClient } from "./ll_client";
+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";
+import { test, expect } from "vitest";
+
+import { UnauthenticatedError } from "./errors";
+
+test("wire protocol detection", async () => {
   const { conf, auth } = await getTestClientConf();
-  const expectedWireProtocol = conf.wireProtocol ?? 'grpc';
+  const expectedWireProtocol = conf.wireProtocol ?? "grpc";
   conf.wireProtocol = undefined;
 
   const client = await LLPlClient.build(conf, { auth });
   expect(client.wireProtocol).toBe(expectedWireProtocol);
 });
 
-test('authenticated instance test', async () => {
+test("authenticated instance test", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true);
   const response = await tx.send(
     {
-      oneofKind: 'txOpen',
-      txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+      oneofKind: "txOpen",
+      txOpen: {
+        name: "test",
+        writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+        enableFormattedErrors: false,
+      },
     },
-    false
+    false,
   );
   expect(response.txOpen.tx?.isValid).toBeTruthy();
   await tx.complete();
   await tx.await();
 });
 
-test('unauthenticated status change', async () => {
+test("unauthenticated status change", async () => {
   const cfg = getTestConfig();
   if (cfg.test_password === undefined) {
     console.log("skipping test because target server doesn't support authentication");
@@ -39,17 +48,21 @@ test('unauthenticated status change', async () => {
   }
 
   const client = await LLPlClient.build(plAddressToTestConfig(cfg.address));
-  expect(client.status).toBe('OK');
+  expect(client.status).toBe("OK");
 
   const tx = client.createTx(true);
 
   await expect(async () => {
     await tx.send(
       {
-        oneofKind: 'txOpen',
-        txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+        oneofKind: "txOpen",
+        txOpen: {
+          name: "test",
+          writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+          enableFormattedErrors: false,
+        },
       },
-      false
+      false,
     );
   }).rejects.toThrow(UnauthenticatedError);
 
@@ -59,10 +72,10 @@ test('unauthenticated status change', async () => {
 
   await tp.setImmediate();
 
-  expect(client.status).toEqual('Unauthenticated');
+  expect(client.status).toEqual("Unauthenticated");
 });
 
-test('automatic token update', 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");
@@ -78,18 +91,22 @@ test('automatic token update', async () => {
       onUpdate: (auth) => {
         console.log(auth);
         ++numberOfAuthUpdates;
-      }
-    }
+      },
+    },
   });
 
   for (let i = 0; i < 6; i++) {
     const tx = client.createTx(true);
     const response = await tx.send(
       {
-        oneofKind: 'txOpen',
-        txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+        oneofKind: "txOpen",
+        txOpen: {
+          name: "test",
+          writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+          enableFormattedErrors: false,
+        },
       },
-      false
+      false,
     );
     expect(response.txOpen.tx?.isValid).toBeTruthy();
     await tx.complete();
@@ -103,25 +120,25 @@ test('automatic token update', async () => {
   }
 }, 5000);
 
-test('test simple https call', async () => {
+test("test simple https call", async () => {
   const client = await getTestLLClient();
-  const response = await request('https://cdn.milaboratory.com/ping', {
-    dispatcher: client.httpDispatcher
+  const response = await request("https://cdn.milaboratory.com/ping", {
+    dispatcher: client.httpDispatcher,
   });
   const text = await response.body.text();
-  expect(text).toEqual('pong');
+  expect(text).toEqual("pong");
 });
 
-test('test https call via proxy', async () => {
+test("test https call via proxy", async () => {
   const testConfig = getTestConfig();
   if (testConfig.test_proxy === undefined) {
-    console.log('skipped');
+    console.log("skipped");
     return;
   }
   const client = await getTestLLClient({ httpProxy: testConfig.test_proxy });
-  const response = await request('https://cdn.milaboratory.com/ping', {
-    dispatcher: client.httpDispatcher
+  const response = await request("https://cdn.milaboratory.com/ping", {
+    dispatcher: client.httpDispatcher,
   });
   const text = await response.body.text();
-  expect(text).toEqual('pong');
+  expect(text).toEqual("pong");
 });