@alienplatform/platform-api 1.0.68 → 1.3.5

package/src/lib/retries.ts

@@ -2,29 +2,29 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { isConnectionError, isTimeoutError } from "./http.js"
+import { isConnectionError, isTimeoutError } from "./http.js";
 
 export type BackoffStrategy = {
-  initialInterval: number
-  maxInterval: number
-  exponent: number
-  maxElapsedTime: number
-}
+  initialInterval: number;
+  maxInterval: number;
+  exponent: number;
+  maxElapsedTime: number;
+};
 
 const defaultBackoff: BackoffStrategy = {
   initialInterval: 500,
   maxInterval: 60000,
   exponent: 1.5,
   maxElapsedTime: 3600000,
-}
+};
 
 export type RetryConfig =
   | { strategy: "none" }
   | {
-      strategy: "backoff"
-      backoff?: BackoffStrategy
-      retryConnectionErrors?: boolean
-    }
+      strategy: "backoff";
+      backoff?: BackoffStrategy;
+      retryConnectionErrors?: boolean;
+    };
 
 /**
  * PermanentError is an error that is not recoverable. Throwing this error will
@@ -32,23 +32,23 @@ export type RetryConfig =
  */
 export class PermanentError extends Error {
   /** The underlying cause of the error. */
-  override readonly cause: unknown
+  override readonly cause: unknown;
 
   constructor(message: string, options?: { cause?: unknown }) {
-    let msg = message
+    let msg = message;
     if (options?.cause) {
-      msg += `: ${options.cause}`
+      msg += `: ${options.cause}`;
     }
 
-    super(msg, options)
-    this.name = "PermanentError"
+    super(msg, options);
+    this.name = "PermanentError";
     // In older runtimes, the cause field would not have been assigned through
     // the super() call.
     if (typeof this.cause === "undefined") {
-      this.cause = options?.cause
+      this.cause = options?.cause;
     }
 
-    Object.setPrototypeOf(this, PermanentError.prototype)
+    Object.setPrototypeOf(this, PermanentError.prototype);
   }
 }
 
@@ -58,22 +58,22 @@ export class PermanentError extends Error {
  * error is thrown, the response will be returned to the caller.
  */
 export class TemporaryError extends Error {
-  response: Response
+  response: Response;
 
   constructor(message: string, response: Response) {
-    super(message)
-    this.response = response
-    this.name = "TemporaryError"
+    super(message);
+    this.response = response;
+    this.name = "TemporaryError";
 
-    Object.setPrototypeOf(this, TemporaryError.prototype)
+    Object.setPrototypeOf(this, TemporaryError.prototype);
   }
 }
 
 export async function retry(
   fetchFn: () => Promise<Response>,
   options: {
-    config: RetryConfig
-    statusCodes: string[]
+    config: RetryConfig;
+    statusCodes: string[];
   },
 ): Promise<Response> {
   switch (options.config.strategy) {
@@ -84,128 +84,135 @@ export async function retry(
           retryConnectionErrors: !!options.config.retryConnectionErrors,
         }),
         options.config.backoff ?? defaultBackoff,
-      )
+      );
     default:
-      return await fetchFn()
+      return await fetchFn();
   }
 }
 
 function wrapFetcher(
   fn: () => Promise<Response>,
   options: {
-    statusCodes: string[]
-    retryConnectionErrors: boolean
+    statusCodes: string[];
+    retryConnectionErrors: boolean;
   },
 ): () => Promise<Response> {
   return async () => {
     try {
-      const res = await fn()
+      const res = await fn();
       if (isRetryableResponse(res, options.statusCodes)) {
-        throw new TemporaryError("Response failed with retryable status code", res)
+        throw new TemporaryError(
+          "Response failed with retryable status code",
+          res,
+        );
       }
 
-      return res
+      return res;
     } catch (err: unknown) {
       if (err instanceof TemporaryError) {
-        throw err
+        throw err;
       }
 
-      if (options.retryConnectionErrors && (isTimeoutError(err) || isConnectionError(err))) {
-        throw err
+      if (
+        options.retryConnectionErrors &&
+        (isTimeoutError(err) || isConnectionError(err))
+      ) {
+        throw err;
       }
 
-      throw new PermanentError("Permanent error", { cause: err })
+      throw new PermanentError("Permanent error", { cause: err });
     }
-  }
+  };
 }
 
-const codeRangeRE = /^[0-9]xx$/i
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
 
 function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
-  const actual = `${res.status}`
+  const actual = `${res.status}`;
 
-  return statusCodes.some(code => {
+  return statusCodes.some((code) => {
     if (!codeRangeRE.test(code)) {
-      return code === actual
+      return code === actual;
     }
 
-    const expectFamily = code.charAt(0)
+    const expectFamily = code.charAt(0);
     if (!expectFamily) {
-      throw new Error("Invalid status code range")
+      throw new Error("Invalid status code range");
     }
 
-    const actualFamily = actual.charAt(0)
+    const actualFamily = actual.charAt(0);
     if (!actualFamily) {
-      throw new Error(`Invalid response status code: ${actual}`)
+      throw new Error(`Invalid response status code: ${actual}`);
     }
 
-    return actualFamily === expectFamily
-  })
+    return actualFamily === expectFamily;
+  });
 }
 
 async function retryBackoff(
   fn: () => Promise<Response>,
   strategy: BackoffStrategy,
 ): Promise<Response> {
-  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy
+  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
 
-  const start = Date.now()
-  let x = 0
+  const start = Date.now();
+  let x = 0;
 
   while (true) {
     try {
-      const res = await fn()
-      return res
+      const res = await fn();
+      return res;
     } catch (err: unknown) {
       if (err instanceof PermanentError) {
-        throw err.cause
+        throw err.cause;
       }
-      const elapsed = Date.now() - start
+      const elapsed = Date.now() - start;
       if (elapsed > maxElapsedTime) {
         if (err instanceof TemporaryError) {
-          return err.response
+          return err.response;
         }
 
-        throw err
+        throw err;
       }
 
-      let retryInterval = 0
+      let retryInterval = 0;
       if (err instanceof TemporaryError) {
-        retryInterval = retryIntervalFromResponse(err.response)
+        retryInterval = retryIntervalFromResponse(err.response);
       }
 
       if (retryInterval <= 0) {
-        retryInterval = initialInterval * Math.pow(x, exponent) + Math.random() * 1000
+        retryInterval =
+          initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
       }
 
-      const d = Math.min(retryInterval, maxInterval)
+      const d = Math.min(retryInterval, maxInterval);
 
-      await delay(d)
-      x++
+      await delay(d);
+      x++;
     }
   }
 }
 
 function retryIntervalFromResponse(res: Response): number {
-  const retryVal = res.headers.get("retry-after") || ""
+  const retryVal = res.headers.get("retry-after") || "";
   if (!retryVal) {
-    return 0
+    return 0;
   }
 
-  const parsedNumber = Number(retryVal)
+  const parsedNumber = Number(retryVal);
   if (Number.isInteger(parsedNumber)) {
-    return parsedNumber * 1000
+    return parsedNumber * 1000;
   }
 
-  const parsedDate = Date.parse(retryVal)
+  const parsedDate = Date.parse(retryVal);
   if (Number.isInteger(parsedDate)) {
-    const deltaMS = parsedDate - Date.now()
-    return deltaMS > 0 ? Math.ceil(deltaMS) : 0
+    const deltaMS = parsedDate - Date.now();
+    return deltaMS > 0 ? Math.ceil(deltaMS) : 0;
   }
 
-  return 0
+  return 0;
 }
 
 async function delay(delay: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, delay))
+  return new Promise((resolve) => setTimeout(resolve, delay));
 }

package/src/lib/schemas.ts

@@ -2,23 +2,27 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import * as z from "zod/v4"
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js"
-import { ERR, OK, type Result } from "../types/fp.js"
+import * as z from "zod/v4";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 
 /**
  * Utility function that executes some code which may throw a ZodError. It
  * intercepts this error and converts it to an SDKValidationError so as to not
  * leak Zod implementation details to user code.
  */
-export function parse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMessage: string): Out {
+export function parse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+): Out {
   try {
-    return fn(rawValue)
+    return fn(rawValue);
   } catch (err) {
     if (err instanceof z.ZodError) {
-      throw new SDKValidationError(errorMessage, err, rawValue)
+      throw new SDKValidationError(errorMessage, err, rawValue);
     }
-    throw err
+    throw err;
   }
 }
 
@@ -33,9 +37,9 @@ export function safeParse<Inp, Out>(
   errorMessage: string,
 ): Result<Out, SDKValidationError> {
   try {
-    return OK(fn(rawValue))
+    return OK(fn(rawValue));
   } catch (err) {
-    return ERR(new SDKValidationError(errorMessage, err, rawValue))
+    return ERR(new SDKValidationError(errorMessage, err, rawValue));
   }
 }
 
@@ -51,38 +55,37 @@ export function collectExtraKeys<
 ): z.ZodPipe<
   z.ZodObject<Shape, z.core.$catchall<Catchall>>,
   z.ZodTransform<
-    z.output<z.ZodObject<Shape, z.core.$strip>> &
-      (Optional extends false
-        ? {
-            [k in K]: Record<string, z.output<Catchall>>
-          }
-        : {
-            [k in K]?: Record<string, z.output<Catchall>> | undefined
-          }),
+    & z.output<z.ZodObject<Shape, z.core.$strip>>
+    & (Optional extends false ? {
+        [k in K]: Record<string, z.output<Catchall>>;
+      }
+      : {
+        [k in K]?: Record<string, z.output<Catchall>> | undefined;
+      }),
     z.output<z.ZodObject<Shape, z.core.$catchall<Catchall>>>
   >
 > {
   return obj.transform((val: any) => {
-    const extras: Record<string, z.output<Catchall>> = {}
-    const { shape } = obj
+    const extras: Record<string, z.output<Catchall>> = {};
+    const { shape } = obj;
     for (const [key] of Object.entries(val)) {
       if (key in shape) {
-        continue
+        continue;
       }
 
-      const v = val[key]
+      const v = val[key];
       if (typeof v === "undefined") {
-        continue
+        continue;
       }
 
-      extras[key] = v
-      delete val[key]
+      extras[key] = v;
+      delete val[key];
     }
 
     if (optional && Object.keys(extras).length === 0) {
-      return val
+      return val;
     }
 
-    return { ...val, [extrasKey]: extras }
-  })
+    return { ...val, [extrasKey]: extras };
+  });
 }