@alienplatform/platform-api 1.0.68

package/src/lib/primitives.ts

@@ -0,0 +1,145 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+class InvariantError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "InvariantError"
+  }
+}
+
+export function invariant(condition: unknown, message: string): asserts condition {
+  if (!condition) {
+    throw new InvariantError(message)
+  }
+}
+
+export type ExactPartial<T> = {
+  [P in keyof T]?: T[P] | undefined
+}
+
+export type Remap<Inp, Mapping extends { [k in keyof Inp]?: string | null }> = {
+  [k in keyof Inp as Mapping[k] extends string /* if we have a string mapping for this key then use it */
+    ? Mapping[k]
+    : Mapping[k] extends null /* if the mapping is to `null` then drop the key */
+      ? never
+      : k /* otherwise keep the key as-is */]: Inp[k]
+}
+
+/**
+ * Converts or omits an object's keys according to a mapping.
+ *
+ * @param inp An object whose keys will be remapped
+ * @param mappings A mapping of original keys to new keys. If a key is not present in the mapping, it will be left as is. If a key is mapped to `null`, it will be removed in the resulting object.
+ * @returns A new object with keys remapped or omitted according to the mappings
+ */
+export function remap<
+  Inp extends Record<string, unknown>,
+  const Mapping extends { [k in keyof Inp]?: string | null },
+>(inp: Inp, mappings: Mapping): Remap<Inp, Mapping> {
+  let out: any = {}
+
+  if (!Object.keys(mappings).length) {
+    out = inp
+    return out
+  }
+
+  for (const [k, v] of Object.entries(inp)) {
+    const j = mappings[k]
+    if (j === null) {
+      continue
+    }
+    out[j ?? k] = v
+  }
+
+  return out
+}
+
+export function combineSignals(
+  ...signals: Array<AbortSignal | null | undefined>
+): AbortSignal | null {
+  const filtered: AbortSignal[] = []
+  for (const signal of signals) {
+    if (signal) {
+      filtered.push(signal)
+    }
+  }
+
+  switch (filtered.length) {
+    case 0:
+    case 1:
+      return filtered[0] || null
+    default:
+      if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
+        return AbortSignal.any(filtered)
+      }
+      return abortSignalAny(filtered)
+  }
+}
+
+export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController()
+  const result = controller.signal
+  if (!signals.length) {
+    return controller.signal
+  }
+
+  if (signals.length === 1) {
+    return signals[0] || controller.signal
+  }
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal
+    }
+  }
+
+  function abort(this: AbortSignal) {
+    controller.abort(this.reason)
+    clean()
+  }
+
+  const signalRefs: WeakRef<AbortSignal>[] = []
+  function clean() {
+    for (const signalRef of signalRefs) {
+      const signal = signalRef.deref()
+      if (signal) {
+        signal.removeEventListener("abort", abort)
+      }
+    }
+  }
+
+  for (const signal of signals) {
+    signalRefs.push(new WeakRef(signal))
+    signal.addEventListener("abort", abort)
+  }
+
+  return result
+}
+
+export function compactMap<T>(values: Record<string, T | undefined>): Record<string, T> {
+  const out: Record<string, T> = {}
+
+  for (const [k, v] of Object.entries(values)) {
+    if (typeof v !== "undefined") {
+      out[k] = v
+    }
+  }
+
+  return out
+}
+
+export function allRequired<V extends Record<string, unknown>>(
+  v: V,
+):
+  | {
+      [K in keyof V]: NonNullable<V[K]>
+    }
+  | undefined {
+  if (Object.values(v).every(x => x == null)) {
+    return void 0
+  }
+
+  return v as ReturnType<typeof allRequired<V>>
+}

package/src/lib/retries.ts

@@ -0,0 +1,211 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { isConnectionError, isTimeoutError } from "./http.js"
+
+export type BackoffStrategy = {
+  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
+    }
+
+/**
+ * PermanentError is an error that is not recoverable. Throwing this error will
+ * cause a retry loop to terminate.
+ */
+export class PermanentError extends Error {
+  /** The underlying cause of the error. */
+  override readonly cause: unknown
+
+  constructor(message: string, options?: { cause?: unknown }) {
+    let msg = message
+    if (options?.cause) {
+      msg += `: ${options.cause}`
+    }
+
+    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
+    }
+
+    Object.setPrototypeOf(this, PermanentError.prototype)
+  }
+}
+
+/**
+ * TemporaryError is an error is used to signal that an HTTP request can be
+ * retried as part of a retry loop. If retry attempts are exhausted and this
+ * error is thrown, the response will be returned to the caller.
+ */
+export class TemporaryError extends Error {
+  response: Response
+
+  constructor(message: string, response: Response) {
+    super(message)
+    this.response = response
+    this.name = "TemporaryError"
+
+    Object.setPrototypeOf(this, TemporaryError.prototype)
+  }
+}
+
+export async function retry(
+  fetchFn: () => Promise<Response>,
+  options: {
+    config: RetryConfig
+    statusCodes: string[]
+  },
+): Promise<Response> {
+  switch (options.config.strategy) {
+    case "backoff":
+      return retryBackoff(
+        wrapFetcher(fetchFn, {
+          statusCodes: options.statusCodes,
+          retryConnectionErrors: !!options.config.retryConnectionErrors,
+        }),
+        options.config.backoff ?? defaultBackoff,
+      )
+    default:
+      return await fetchFn()
+  }
+}
+
+function wrapFetcher(
+  fn: () => Promise<Response>,
+  options: {
+    statusCodes: string[]
+    retryConnectionErrors: boolean
+  },
+): () => Promise<Response> {
+  return async () => {
+    try {
+      const res = await fn()
+      if (isRetryableResponse(res, options.statusCodes)) {
+        throw new TemporaryError("Response failed with retryable status code", res)
+      }
+
+      return res
+    } catch (err: unknown) {
+      if (err instanceof TemporaryError) {
+        throw err
+      }
+
+      if (options.retryConnectionErrors && (isTimeoutError(err) || isConnectionError(err))) {
+        throw err
+      }
+
+      throw new PermanentError("Permanent error", { cause: err })
+    }
+  }
+}
+
+const codeRangeRE = /^[0-9]xx$/i
+
+function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
+  const actual = `${res.status}`
+
+  return statusCodes.some(code => {
+    if (!codeRangeRE.test(code)) {
+      return code === actual
+    }
+
+    const expectFamily = code.charAt(0)
+    if (!expectFamily) {
+      throw new Error("Invalid status code range")
+    }
+
+    const actualFamily = actual.charAt(0)
+    if (!actualFamily) {
+      throw new Error(`Invalid response status code: ${actual}`)
+    }
+
+    return actualFamily === expectFamily
+  })
+}
+
+async function retryBackoff(
+  fn: () => Promise<Response>,
+  strategy: BackoffStrategy,
+): Promise<Response> {
+  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy
+
+  const start = Date.now()
+  let x = 0
+
+  while (true) {
+    try {
+      const res = await fn()
+      return res
+    } catch (err: unknown) {
+      if (err instanceof PermanentError) {
+        throw err.cause
+      }
+      const elapsed = Date.now() - start
+      if (elapsed > maxElapsedTime) {
+        if (err instanceof TemporaryError) {
+          return err.response
+        }
+
+        throw err
+      }
+
+      let retryInterval = 0
+      if (err instanceof TemporaryError) {
+        retryInterval = retryIntervalFromResponse(err.response)
+      }
+
+      if (retryInterval <= 0) {
+        retryInterval = initialInterval * Math.pow(x, exponent) + Math.random() * 1000
+      }
+
+      const d = Math.min(retryInterval, maxInterval)
+
+      await delay(d)
+      x++
+    }
+  }
+}
+
+function retryIntervalFromResponse(res: Response): number {
+  const retryVal = res.headers.get("retry-after") || ""
+  if (!retryVal) {
+    return 0
+  }
+
+  const parsedNumber = Number(retryVal)
+  if (Number.isInteger(parsedNumber)) {
+    return parsedNumber * 1000
+  }
+
+  const parsedDate = Date.parse(retryVal)
+  if (Number.isInteger(parsedDate)) {
+    const deltaMS = parsedDate - Date.now()
+    return deltaMS > 0 ? Math.ceil(deltaMS) : 0
+  }
+
+  return 0
+}
+
+async function delay(delay: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, delay))
+}

package/src/lib/schemas.ts

@@ -0,0 +1,88 @@
+/*
+ * 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"
+
+/**
+ * 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 {
+  try {
+    return fn(rawValue)
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      throw new SDKValidationError(errorMessage, err, rawValue)
+    }
+    throw err
+  }
+}
+
+/**
+ * Utility function that executes some code which may result in 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 safeParse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+): Result<Out, SDKValidationError> {
+  try {
+    return OK(fn(rawValue))
+  } catch (err) {
+    return ERR(new SDKValidationError(errorMessage, err, rawValue))
+  }
+}
+
+export function collectExtraKeys<
+  Shape extends z.ZodRawShape,
+  Catchall extends z.ZodType,
+  K extends string,
+  Optional extends boolean,
+>(
+  obj: z.ZodObject<Shape, z.core.$catchall<Catchall>>,
+  extrasKey: K,
+  optional: Optional,
+): 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.$catchall<Catchall>>>
+  >
+> {
+  return obj.transform((val: any) => {
+    const extras: Record<string, z.output<Catchall>> = {}
+    const { shape } = obj
+    for (const [key] of Object.entries(val)) {
+      if (key in shape) {
+        continue
+      }
+
+      const v = val[key]
+      if (typeof v === "undefined") {
+        continue
+      }
+
+      extras[key] = v
+      delete val[key]
+    }
+
+    if (optional && Object.keys(extras).length === 0) {
+      return val
+    }
+
+    return { ...val, [extrasKey]: extras }
+  })
+}