@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/core/websocket_stream.ts

@@ -1,9 +1,9 @@
-import { WebSocket, type WebSocketInit, type Dispatcher, ErrorEvent } from 'undici';
-import type { BiDiStream } from './abstract_stream';
-import Denque from 'denque';
-import type { RetryConfig } from '../helpers/retry_strategy';
-import { RetryStrategy } from '../helpers/retry_strategy';
-import { DisconnectedError } from './errors';
+import { WebSocket, type WebSocketInit, type Dispatcher, ErrorEvent } from "undici";
+import type { BiDiStream } from "./abstract_stream";
+import Denque from "denque";
+import type { RetryConfig } from "../helpers/retry_strategy";
+import { RetryStrategy } from "../helpers/retry_strategy";
+import { DisconnectedError } from "./errors";
 
 interface QueuedMessage<InType extends object> {
   message: InType;
@@ -38,7 +38,10 @@ export type WSStreamOptions<ClientMsg extends object, ServerMsg extends object>
  * WebSocket-based bidirectional stream implementation for LLTransaction.
  * Implements BiDiStream interface which is compatible with DuplexStreamingCall.
  */
-export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends object> implements BiDiStream<ClientMsg, ServerMsg> {
+export class WebSocketBiDiStream<
+  ClientMsg extends object,
+  ServerMsg extends object,
+> implements BiDiStream<ClientMsg, ServerMsg> {
   // Connection
   private ws: WebSocket | null = null;
   private connectionState: ConnectionState = ConnectionState.NEW;
@@ -47,7 +50,9 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
   // Send management
   private readonly sendQueue = new Denque<QueuedMessage<ClientMsg>>();
   private sendCompleted = false;
-  private readonly onComplete: (stream: WebSocketBiDiStream<ClientMsg, ServerMsg>) => void | Promise<void>;
+  private readonly onComplete: (
+    stream: WebSocketBiDiStream<ClientMsg, ServerMsg>,
+  ) => void | Promise<void>;
 
   // Response management
   private readonly responseQueue = new Denque<ServerMsg>();
@@ -69,7 +74,7 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
       await this.drainSendQueue(); // ensure we sent all already queued messages before closing the stream
       try {
         await this.onComplete(this); // custom onComplete may send additional messages
-      } catch (_: unknown) {
+      } catch {
         // When 'complete' gets called concurrently with connection break or over a broken
         // transaction stream (server decided it should drop transaction), server would close
         // connection anyway on its end. We can safely ignore error here and just continue working.
@@ -106,7 +111,9 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
 
     const retryConfig = this.options.retryConfig ?? {};
     this.reconnection = new RetryStrategy(retryConfig, {
-      onRetry: () => { void this.connect(); },
+      onRetry: () => {
+        void this.connect();
+      },
       onMaxAttemptsReached: (error) => this.handleError(error),
     });
 
@@ -115,7 +122,7 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
       return;
     }
 
-    this.options.abortSignal?.addEventListener('abort', () => this.close());
+    this.options.abortSignal?.addEventListener("abort", () => this.close());
     this.connect();
   }
 
@@ -130,10 +137,10 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
     try {
       this.ws = this.createWebSocket();
 
-      this.ws.addEventListener('open', () => this.onOpen());
-      this.ws.addEventListener('message', (event) => this.onMessage(event.data));
-      this.ws.addEventListener('error', (error) => this.onError(error));
-      this.ws.addEventListener('close', () => this.onClose());
+      this.ws.addEventListener("open", () => this.onOpen());
+      this.ws.addEventListener("message", (event) => this.onMessage(event.data));
+      this.ws.addEventListener("error", (error) => this.onError(error));
+      this.ws.addEventListener("close", () => this.onClose());
     } catch (error) {
       this.lastError = this.toError(error);
       this.reconnection.schedule();
@@ -143,11 +150,12 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
   private createWebSocket(): WebSocket {
     const options: WebSocketInit = {};
 
-    if (this.options.jwtToken) options.headers = { authorization: `Bearer ${this.options.jwtToken}` };
+    if (this.options.jwtToken)
+      options.headers = { authorization: `Bearer ${this.options.jwtToken}` };
     if (this.options.dispatcher) options.dispatcher = this.options.dispatcher;
 
     const ws = new WebSocket(this.url, options);
-    ws.binaryType = 'arraybuffer';
+    ws.binaryType = "arraybuffer";
     return ws;
   }
 
@@ -208,11 +216,11 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
 
   private enqueueSend(message: ClientMsg): Promise<void> {
     if (this.sendCompleted) {
-      throw new Error('Cannot send: stream already completed');
+      throw new Error("Cannot send: stream already completed");
     }
 
     if (this.options.abortSignal?.aborted) {
-      throw new Error('Cannot send: stream aborted');
+      throw new Error("Cannot send: stream aborted");
     }
 
     return new Promise<void>((resolve, reject) => {
@@ -238,7 +246,7 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
     try {
       const ws = this.ws;
       if (!ws) {
-        throw new Error('WebSocket is not connected');
+        throw new Error("WebSocket is not connected");
       }
 
       // Check if WebSocket is in a valid state for sending
@@ -258,33 +266,27 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
     const POLL_INTERVAL_MS = 5;
 
     while (this.sendQueue.length > 0) {
-      await this.waitForCondition(
-        () => this.sendQueue.length === 0,
-        POLL_INTERVAL_MS,
-      );
+      await this.waitForCondition(() => this.sendQueue.length === 0, POLL_INTERVAL_MS);
     }
   }
 
-  private waitForCondition(
-    condition: () => boolean,
-    intervalMs: number,
-  ): Promise<void> {
+  private waitForCondition(condition: () => boolean, intervalMs: number): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       if (this.options.abortSignal?.aborted) {
-        return reject(this.toError(this.options.abortSignal.reason) ?? new Error('Stream aborted'));
+        return reject(this.toError(this.options.abortSignal.reason) ?? new Error("Stream aborted"));
       }
 
       let timeoutId: ReturnType<typeof setTimeout>;
       const onAbort = () => {
         clearTimeout(timeoutId);
-        reject(this.toError(this.options.abortSignal?.reason) ?? new Error('Stream aborted'));
+        reject(this.toError(this.options.abortSignal?.reason) ?? new Error("Stream aborted"));
       };
 
-      this.options.abortSignal?.addEventListener('abort', onAbort, { once: true });
+      this.options.abortSignal?.addEventListener("abort", onAbort, { once: true });
 
       const check = () => {
         if (condition() || this.isStreamEnded()) {
-          this.options.abortSignal?.removeEventListener('abort', onAbort);
+          this.options.abortSignal?.removeEventListener("abort", onAbort);
           resolve();
         } else {
           timeoutId = setTimeout(check, intervalMs);
@@ -379,16 +381,18 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
       if (reason instanceof Error) {
         return reason;
       }
-      return new Error('Stream aborted', { cause: reason });
+      return new Error("Stream aborted", { cause: reason });
     }
 
-    return new Error('Stream closed');
+    return new Error("Stream closed");
   }
 
   // === Helpers ===
 
   private isStreamEnded(): boolean {
-    return this.connectionState === ConnectionState.CLOSED || this.options.abortSignal?.aborted || false;
+    return (
+      this.connectionState === ConnectionState.CLOSED || this.options.abortSignal?.aborted || false
+    );
   }
 
   private toError(error: unknown): Error {
@@ -398,9 +402,9 @@ export class WebSocketBiDiStream<ClientMsg extends object, ServerMsg extends obj
       // undici WebSocket throws TypeError with empty message on socket close
       // (e.g., when connection is lost or server disconnects)
       if (err instanceof TypeError && !err.message) {
-        return new DisconnectedError('WebSocket connection closed unexpectedly');
+        return new DisconnectedError("WebSocket connection closed unexpectedly");
       }
-      return err instanceof Error ? err : new Error('WebSocket error', { cause: error });
+      return err instanceof Error ? err : new Error("WebSocket error", { cause: error });
     }
     return new Error(String(error));
   }

package/src/core/wire.ts

@@ -1,27 +1,27 @@
-import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
-import type { Dispatcher } from 'undici';
-import type { PlClientConfig, wireProtocol } from './config';
-import type { Middleware } from 'openapi-fetch';
+import type { GrpcTransport } from "@protobuf-ts/grpc-transport";
+import type { Dispatcher } from "undici";
+import type { PlClientConfig, wireProtocol } from "./config";
+import type { Middleware } from "openapi-fetch";
 
 /**
  * Options for the HTTP client to properly reach the PL server API when
  * it works in WebSocket + REST mode.
  */
 export type RestConnection = {
-  type: 'rest';
+  type: "rest";
   Config: PlClientConfig;
   Dispatcher: Dispatcher;
   Middlewares: Middleware[];
 };
 
 export type GrpcConnection = {
-  type: 'grpc';
+  type: "grpc";
   Transport: GrpcTransport;
 };
 
 export type WireConnection = RestConnection | GrpcConnection;
 // type compatibility check: types used in WireConnection should match known wire protocols.
-const _ct: Extract<WireConnection, { type: string }>['type'] = 'rest' as wireProtocol;
+const _ct: Extract<WireConnection, { type: string }>["type"] = "rest" as wireProtocol;
 
 /**
  * A provider for a wire (gRPC, HTTP, etc.) client.
@@ -36,5 +36,7 @@ export interface WireClientProvider<Client> {
  * A factory for wire client providers.
  */
 export interface WireClientProviderFactory {
-  createWireClientProvider<Client>(clientConstructor: (transport: WireConnection) => Client): WireClientProvider<Client>;
+  createWireClientProvider<Client>(
+    clientConstructor: (transport: WireConnection) => Client,
+  ): WireClientProvider<Client>;
 }

package/src/helpers/pl.ts

@@ -7,31 +7,31 @@
  *
  */
 
-import type { FutureFieldType, ResourceType } from '../core/types';
-import type { AnyRef, FieldRef, PlTransaction, ResourceRef } from '../core/transaction';
-import { field } from '../core/transaction';
+import type { FutureFieldType, ResourceType } from "../core/types";
+import type { AnyRef, FieldRef, PlTransaction, ResourceRef } from "../core/transaction";
+import { field } from "../core/transaction";
 
 function rt(name: string, version: string): ResourceType {
   return { name, version };
 }
 
-export const ClientRoot = rt('ClientRoot', '1');
+export const ClientRoot = rt("ClientRoot", "1");
 
-export const StructTestResource = rt('StructTest', '1');
-export const ValueTestResource = rt('ValueTest', '1');
+export const StructTestResource = rt("StructTest", "1");
+export const ValueTestResource = rt("ValueTest", "1");
 
-export const JsonString = rt('json/string', '1');
-export const JsonBool = rt('json/bool', '1');
-export const JsonObject = rt('json/object', '1');
-export const JsonGzObject = rt('json-gz/object', '1');
-export const JsonArray = rt('json/array', '1');
-export const JsonNumber = rt('json/number', '1');
-export const JsonNull = rt('json/null', '1');
+export const JsonString = rt("json/string", "1");
+export const JsonBool = rt("json/bool", "1");
+export const JsonObject = rt("json/object", "1");
+export const JsonGzObject = rt("json-gz/object", "1");
+export const JsonArray = rt("json/array", "1");
+export const JsonNumber = rt("json/number", "1");
+export const JsonNull = rt("json/null", "1");
 
-export const RNull = rt('Null', '1');
+export const RNull = rt("Null", "1");
 
-export const EphStdMap: ResourceType = rt('EphStdMap', '1');
-export const StdMap: ResourceType = rt('StdMap', '1');
+export const EphStdMap: ResourceType = rt("EphStdMap", "1");
+export const StdMap: ResourceType = rt("StdMap", "1");
 
 //
 // Standard value resources
@@ -96,7 +96,7 @@ export function createPlMap(
   const rId = ephemeral ? tx.createEphemeral(actualType) : tx.createStruct(actualType);
 
   for (const [name, value] of Array.isArray(entries) ? entries : plEntries(entries))
-    tx.createField(field(rId, name), 'Input', value);
+    tx.createField(field(rId, name), "Input", value);
 
   tx.lock(rId);
 
@@ -108,7 +108,7 @@ export function futureRecord<Key extends string>(
   rId: AnyRef,
   keys: Key[],
   fieldType: FutureFieldType,
-  prefix: string = '',
+  prefix: string = "",
 ): PlRecord<Key, FieldRef> {
   return Object.fromEntries(
     keys.map((k) => plEntry(k, tx.getFutureFieldValue(rId, `${prefix}${k}`, fieldType))),
@@ -122,12 +122,12 @@ export function futureRecord<Key extends string>(
 /** Name of the field in block holder, that references the actual block-pack. */
 export const Holder = StdMap;
 export const EphHolder = EphStdMap;
-export const HolderRefField = 'ref';
+export const HolderRefField = "ref";
 
 export function wrapInHolder(tx: PlTransaction, ref: AnyRef): ResourceRef {
   const holder = tx.createStruct(Holder);
   const mainHolderField = field(holder, HolderRefField);
-  tx.createField(mainHolderField, 'Input', ref);
+  tx.createField(mainHolderField, "Input", ref);
   tx.lock(holder);
   return holder;
 }
@@ -135,11 +135,11 @@ export function wrapInHolder(tx: PlTransaction, ref: AnyRef): ResourceRef {
 export function wrapInEphHolder(tx: PlTransaction, ref: AnyRef): ResourceRef {
   const holder = tx.createEphemeral(EphHolder);
   const mainHolderField = field(holder, HolderRefField);
-  tx.createField(mainHolderField, 'Input', ref);
+  tx.createField(mainHolderField, "Input", ref);
   tx.lock(holder);
   return holder;
 }
 
 export function unwrapHolder(tx: PlTransaction, ref: AnyRef): FieldRef {
-  return tx.getFutureFieldValue(ref, HolderRefField, 'Input');
+  return tx.getFutureFieldValue(ref, HolderRefField, "Input");
 }

package/src/helpers/poll.ts

@@ -1,28 +1,14 @@
-import type { PlClient } from '../core/client';
-import type {
-  RetryOptions,
-} from '@milaboratories/ts-helpers';
-import {
-  createRetryState,
-  nextRetryStateOrError,
-  notEmpty,
-} from '@milaboratories/ts-helpers';
-import type {
-  FieldData,
-  FieldType,
-  ResourceData,
-  ResourceId } from '../core/types';
-import {
-  isNotNullResourceId,
-  isNullResourceId,
-  resourceIdToString,
-} from '../core/types';
-import type { PlTransaction } from '../core/transaction';
-import * as tp from 'node:timers/promises';
+import type { PlClient } from "../core/client";
+import type { RetryOptions } from "@milaboratories/ts-helpers";
+import { createRetryState, nextRetryStateOrError, notEmpty } from "@milaboratories/ts-helpers";
+import type { FieldData, FieldType, ResourceData, ResourceId } from "../core/types";
+import { isNotNullResourceId, isNullResourceId, resourceIdToString } from "../core/types";
+import type { PlTransaction } from "../core/transaction";
+import * as tp from "node:timers/promises";
 
 /** This error tells state assertion mechanism that required state is not yet ready */
 export class ContinuePolling extends Error {
-  name = 'ContinuePolling';
+  name = "ContinuePolling";
 }
 
 export type PollFieldTraverseOps = {
@@ -68,8 +54,8 @@ export class PollResourceAccessor {
     }
 
     if (
-      ((expectedType === 'Input' || expectedType === 'Service') && this.data.inputsLocked)
-      || (expectedType === 'Output' && this.data.outputsLocked)
+      ((expectedType === "Input" || expectedType === "Service") && this.data.inputsLocked) ||
+      (expectedType === "Output" && this.data.outputsLocked)
     )
       throw new Error(
         // eslint-disable-next-line @typescript-eslint/no-base-to-string, @typescript-eslint/restrict-template-expressions
@@ -150,12 +136,12 @@ export class PollTxAccessor {
   async throwError(error: ResourceId, path: string[] = []): Promise<never> {
     const errorRes = await this.get(error);
     const errorText = Buffer.from(notEmpty(errorRes.data.data)).toString();
-    throw new Error(`${path.join(' -> ')} = ${errorText}`);
+    throw new Error(`${path.join(" -> ")} = ${errorText}`);
   }
 }
 
 export const DefaultPollingRetryOptions: RetryOptions = {
-  type: 'linearBackoff',
+  type: "linearBackoff",
   jitter: 0,
   maxAttempts: 100,
   backoffStep: 10,
@@ -166,7 +152,7 @@ export async function poll<T>(
   cl: PlClient,
   cb: (tx: PollTxAccessor) => Promise<T>,
   retryOptions: RetryOptions = DefaultPollingRetryOptions,
-  txName: string = 'polling',
+  txName: string = "polling",
 ): Promise<T> {
   let retryState = createRetryState(retryOptions);
   while (true) {

package/src/helpers/retry_strategy.ts

@@ -64,9 +64,7 @@ export class RetryStrategy {
   }
 
   private notifyMaxAttemptsReached(): void {
-    const error = new Error(
-      `Max retry attempts (${this.config.maxAttempts}) reached`,
-    );
+    const error = new Error(`Max retry attempts (${this.config.maxAttempts}) reached`);
     this.callbacks.onMaxAttemptsReached(error);
   }
 }
@@ -117,7 +115,7 @@ class ExponentialBackoff {
     if (delay === 0 || this.jitter === 0) {
       return delay;
     }
-    const delayFactor = 1 - (this.jitter / 2) + Math.random() * this.jitter;
+    const delayFactor = 1 - this.jitter / 2 + Math.random() * this.jitter;
     return delay * delayFactor;
   }
 }

package/src/helpers/rich_resource_types.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest';
+import { test } from "vitest";
 
 // type TestType1 = string;
 // type TestType2 = string | number | { a: number };
@@ -17,7 +17,7 @@ import { test } from 'vitest';
 //   return t2;
 // }
 
-test('simple test', () => {
+test("simple test", () => {
   // const t2 = '';
   // const t2a = withRichType(t2, RichType1);
   // const t2c = something(t2a);

package/src/helpers/state_helpers.ts

@@ -1,6 +1,6 @@
-import type { FieldData } from '../core/types';
-import { isNotNullResourceId } from '../core/types';
+import type { FieldData } from "../core/types";
+import { isNotNullResourceId } from "../core/types";
 
-export function fieldResolved(data: Pick<FieldData, 'value' | 'error'>) {
+export function fieldResolved(data: Pick<FieldData, "value" | "error">) {
   return isNotNullResourceId(data.error) || isNotNullResourceId(data.value);
 }

package/src/helpers/tx_helpers.ts

@@ -1,7 +1,7 @@
-import type { PlTransaction } from '../core/transaction';
-import type { FieldData, OptionalResourceId } from '../core/types';
-import { isNotNullResourceId } from '../core/types';
-import { cachedDeserialize, notEmpty } from '@milaboratories/ts-helpers';
+import type { PlTransaction } from "../core/transaction";
+import type { FieldData, OptionalResourceId } from "../core/types";
+import { isNotNullResourceId } from "../core/types";
+import { cachedDeserialize, notEmpty } from "@milaboratories/ts-helpers";
 
 export interface ValErr {
   valueId: OptionalResourceId;
@@ -13,15 +13,17 @@ export async function valErr(tx: PlTransaction, f: FieldData): Promise<ValErr> {
   const result = {
     valueId: f.value,
     errorId: f.error,
-    error: '',
+    error: "",
   };
 
   if (isNotNullResourceId(f.error)) {
     const e = await tx.getResourceData(f.error, true);
     const deserializationResult = cachedDeserialize(notEmpty(e.data));
-    if (typeof deserializationResult !== 'string') {
+    if (typeof deserializationResult !== "string") {
       const dataStr = notEmpty(e.data).toString();
-      throw new Error(`Unexpected error structure: ${dataStr.substring(0, Math.min(dataStr.length, 100))}...`);
+      throw new Error(
+        `Unexpected error structure: ${dataStr.substring(0, Math.min(dataStr.length, 100))}...`,
+      );
     }
     result.error = deserializationResult;
   }

package/src/index.ts

@@ -1,18 +1,18 @@
-export * from './core/types';
-export * as Pl from './helpers/pl';
-export * from './core/config';
-export * from './core/client';
-export * from './core/driver';
-export * from './core/transaction';
-export * from './core/errors';
-export * from './core/default_client';
-export * from './core/unauth_client';
-export * from './core/auth';
-export * from './core/final';
-export * from './core/wire';
-export * from './helpers/tx_helpers';
-export * from './helpers/poll';
+export * from "./core/types";
+export * as Pl from "./helpers/pl";
+export * from "./core/config";
+export * from "./core/client";
+export * from "./core/driver";
+export * from "./core/transaction";
+export * from "./core/errors";
+export * from "./core/default_client";
+export * from "./core/unauth_client";
+export * from "./core/auth";
+export * from "./core/final";
+export * from "./core/wire";
+export * from "./helpers/tx_helpers";
+export * from "./helpers/poll";
 
-export * as TestHelpers from './test/test_config';
+export * as TestHelpers from "./test/test_config";
 
-export * as RestAPI from './proto-rest';
+export * as RestAPI from "./proto-rest";

package/src/proto-grpc/google/protobuf/struct.ts

@@ -178,7 +178,7 @@ class Struct$Type extends MessageType<Struct> {
     /**
      * Encode `Struct` to JSON object.
      */
-    internalJsonWrite(message: Struct, options: JsonWriteOptions): JsonValue {
+    internalJsonWrite(message: Struct, _options: JsonWriteOptions): JsonValue {
         let json: JsonObject = {};
         for (let [k, v] of Object.entries(message.fields)) {
             json[k] = Value.toJson(v);

package/src/proto-rest/index.ts

@@ -4,11 +4,11 @@
 // After generating new clients from openapi specifications, add client types here.
 //
 
-import type { paths as PlApiPaths } from './plapi';
-import { default as createOpenApiClient, type Middleware, type Client } from 'openapi-fetch';
-import { Dispatcher, fetch as undiciFetch } from 'undici';
-import { RESTError, rethrowMeaningfulError } from '../core/errors';
-import { Code } from '../proto-grpc/google/rpc/code';
+import type { paths as PlApiPaths } from "./plapi";
+import { default as createOpenApiClient, type Middleware, type Client } from "openapi-fetch";
+import { Dispatcher, fetch as undiciFetch } from "undici";
+import { RESTError, rethrowMeaningfulError } from "../core/errors";
+import { Code } from "../proto-grpc/google/rpc/code";
 
 export { PlApiPaths };
 export type PlRestClientType = Client<PlApiPaths>;
@@ -18,10 +18,10 @@ export type RestClientConfig = {
   ssl: boolean;
   dispatcher: Dispatcher;
   middlewares: Middleware[];
-}
+};
 
 export function createClient<Paths extends {}>(opts: RestClientConfig): Client<Paths> {
-  const scheme = opts.ssl ? 'https://' : 'http://';
+  const scheme = opts.ssl ? "https://" : "http://";
   const client = createOpenApiClient<Paths>({
     baseUrl: `${scheme}${opts.hostAndPort}`,
     fetch: (input: Request): Promise<Response> => {
@@ -51,14 +51,14 @@ export function createClient<Paths extends {}>(opts: RestClientConfig): Client<P
 }
 
 export type ErrorResponse = {
-  code: Code,
-  message: string,
-  details: any[],
-}
+  code: Code;
+  message: string;
+  details: any[];
+};
 export async function parseResponseError(response: Response): Promise<{
-  error?: ErrorResponse | string,
-  origBody?: string,
-}>{
+  error?: ErrorResponse | string;
+  origBody?: string;
+}> {
   if (response.status < 400) {
     return {};
   }
@@ -67,11 +67,10 @@ export async function parseResponseError(response: Response): Promise<{
   const origBody = error;
   try {
     error = JSON.parse(error) as ErrorResponse;
-  } catch {
-  }
+  } catch {}
   return {
     error: error,
-    origBody
+    origBody,
   };
 }
 
@@ -88,7 +87,7 @@ function errorHandlerMiddleware(): Middleware {
         return new Response(body, { ...resOptions, status: response.status });
       }
 
-      if (typeof respErr.error === 'string') {
+      if (typeof respErr.error === "string") {
         throw new Error(respErr.error);
       }