@alienplatform/platform-api 1.0.68 → 1.3.4

package/src/lib/matchers.ts

@@ -2,13 +2,21 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { AlienDefaultError } from "../models/errors/aliendefaulterror.js"
-import { ResponseValidationError } from "../models/errors/responsevalidationerror.js"
-import { ERR, OK, type Result } from "../types/fp.js"
-import { type StatusCodePredicate, matchResponse, matchStatusCode } from "./http.js"
-import { isPlainObject } from "./is-plain-object.js"
+import { AlienDefaultError } from "../models/errors/aliendefaulterror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
+import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
+import { isPlainObject } from "./is-plain-object.js";
 
-export type Encoding = "jsonl" | "json" | "text" | "bytes" | "stream" | "sse" | "nil" | "fail"
+export type Encoding =
+  | "jsonl"
+  | "json"
+  | "text"
+  | "bytes"
+  | "stream"
+  | "sse"
+  | "nil"
+  | "fail";
 
 const DEFAULT_CONTENT_TYPES: Record<Encoding, string> = {
   jsonl: "application/jsonl",
@@ -19,50 +27,50 @@ const DEFAULT_CONTENT_TYPES: Record<Encoding, string> = {
   sse: "text/event-stream",
   nil: "*",
   fail: "*",
-}
+};
 
-type Schema<T> = { parse(raw: unknown): T }
+type Schema<T> = { parse(raw: unknown): T };
 
 type MatchOptions = {
-  ctype?: string
-  hdrs?: boolean
-  key?: string
-  sseSentinel?: string
-}
+  ctype?: string;
+  hdrs?: boolean;
+  key?: string;
+  sseSentinel?: string;
+};
 
 export type ValueMatcher<V> = MatchOptions & {
-  enc: Encoding
-  codes: StatusCodePredicate
-  schema: Schema<V>
-}
+  enc: Encoding;
+  codes: StatusCodePredicate;
+  schema: Schema<V>;
+};
 
 export type ErrorMatcher<E> = MatchOptions & {
-  enc: Encoding
-  codes: StatusCodePredicate
-  schema: Schema<E>
-  err: true
-}
+  enc: Encoding;
+  codes: StatusCodePredicate;
+  schema: Schema<E>;
+  err: true;
+};
 
 export type FailMatcher = {
-  enc: "fail"
-  codes: StatusCodePredicate
-}
+  enc: "fail";
+  codes: StatusCodePredicate;
+};
 
-export type Matcher<T, E> = ValueMatcher<T> | ErrorMatcher<E> | FailMatcher
+export type Matcher<T, E> = ValueMatcher<T> | ErrorMatcher<E> | FailMatcher;
 
 export function jsonErr<E>(
   codes: StatusCodePredicate,
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "json", codes, schema }
+  return { ...options, err: true, enc: "json", codes, schema };
 }
 export function json<T>(
   codes: StatusCodePredicate,
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "json", codes, schema }
+  return { ...options, enc: "json", codes, schema };
 }
 
 export function jsonl<T>(
@@ -70,7 +78,7 @@ export function jsonl<T>(
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "jsonl", codes, schema }
+  return { ...options, enc: "jsonl", codes, schema };
 }
 
 export function jsonlErr<E>(
@@ -78,21 +86,21 @@ export function jsonlErr<E>(
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "jsonl", codes, schema }
+  return { ...options, err: true, enc: "jsonl", codes, schema };
 }
 export function textErr<E>(
   codes: StatusCodePredicate,
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "text", codes, schema }
+  return { ...options, err: true, enc: "text", codes, schema };
 }
 export function text<T>(
   codes: StatusCodePredicate,
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "text", codes, schema }
+  return { ...options, enc: "text", codes, schema };
 }
 
 export function bytesErr<E>(
@@ -100,14 +108,14 @@ export function bytesErr<E>(
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "bytes", codes, schema }
+  return { ...options, err: true, enc: "bytes", codes, schema };
 }
 export function bytes<T>(
   codes: StatusCodePredicate,
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "bytes", codes, schema }
+  return { ...options, enc: "bytes", codes, schema };
 }
 
 export function streamErr<E>(
@@ -115,14 +123,14 @@ export function streamErr<E>(
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "stream", codes, schema }
+  return { ...options, err: true, enc: "stream", codes, schema };
 }
 export function stream<T>(
   codes: StatusCodePredicate,
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "stream", codes, schema }
+  return { ...options, enc: "stream", codes, schema };
 }
 
 export function sseErr<E>(
@@ -130,14 +138,14 @@ export function sseErr<E>(
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "sse", codes, schema }
+  return { ...options, err: true, enc: "sse", codes, schema };
 }
 export function sse<T>(
   codes: StatusCodePredicate,
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "sse", codes, schema }
+  return { ...options, enc: "sse", codes, schema };
 }
 
 export function nilErr<E>(
@@ -145,27 +153,31 @@ export function nilErr<E>(
   schema: Schema<E>,
   options?: MatchOptions,
 ): ErrorMatcher<E> {
-  return { ...options, err: true, enc: "nil", codes, schema }
+  return { ...options, err: true, enc: "nil", codes, schema };
 }
 export function nil<T>(
   codes: StatusCodePredicate,
   schema: Schema<T>,
   options?: MatchOptions,
 ): ValueMatcher<T> {
-  return { ...options, enc: "nil", codes, schema }
+  return { ...options, enc: "nil", codes, schema };
 }
 
 export function fail(codes: StatusCodePredicate): FailMatcher {
-  return { enc: "fail", codes }
+  return { enc: "fail", codes };
 }
 
-export type MatchedValue<Matchers> = Matchers extends Matcher<infer T, any>[] ? T : never
-export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[] ? E : never
+export type MatchedValue<Matchers> = Matchers extends Matcher<infer T, any>[]
+  ? T
+  : never;
+export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
+  ? E
+  : never;
 export type MatchFunc<T, E> = (
   response: Response,
   request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
-) => Promise<[result: Result<T, E>, raw: unknown]>
+) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
@@ -174,87 +186,88 @@ export function match<T, E>(
     response: Response,
     request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
-  ): Promise<[result: Result<T, E | AlienDefaultError | ResponseValidationError>, raw: unknown]> {
-    let raw: unknown
-    let matcher: Matcher<T, E> | undefined
+  ): Promise<
+    [
+      result: Result<T, E | AlienDefaultError | ResponseValidationError>,
+      raw: unknown,
+    ]
+  > {
+    let raw: unknown;
+    let matcher: Matcher<T, E> | undefined;
     for (const match of matchers) {
-      const { codes } = match
-      const ctpattern = "ctype" in match ? match.ctype : DEFAULT_CONTENT_TYPES[match.enc]
+      const { codes } = match;
+      const ctpattern = "ctype" in match
+        ? match.ctype
+        : DEFAULT_CONTENT_TYPES[match.enc];
       if (ctpattern && matchResponse(response, codes, ctpattern)) {
-        matcher = match
-        break
+        matcher = match;
+        break;
       } else if (!ctpattern && matchStatusCode(response, codes)) {
-        matcher = match
-        break
+        matcher = match;
+        break;
       }
     }
 
     if (!matcher) {
-      return [
-        {
-          ok: false,
-          error: new AlienDefaultError("Unexpected Status or Content-Type", {
-            response,
-            request,
-            body: await response.text().catch(() => ""),
-          }),
-        },
-        raw,
-      ]
+      return [{
+        ok: false,
+        error: new AlienDefaultError("Unexpected Status or Content-Type", {
+          response,
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
-    const encoding = matcher.enc
-    let body = ""
+    const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        body = await response.text()
-        raw = JSON.parse(body)
-        break
+        body = await response.text();
+        raw = JSON.parse(body);
+        break;
       case "jsonl":
-        raw = response.body
-        break
+        raw = response.body;
+        break;
       case "bytes":
-        raw = new Uint8Array(await response.arrayBuffer())
-        break
+        raw = new Uint8Array(await response.arrayBuffer());
+        break;
       case "stream":
-        raw = response.body
-        break
+        raw = response.body;
+        break;
       case "text":
-        body = await response.text()
-        raw = body
-        break
+        body = await response.text();
+        raw = body;
+        break;
       case "sse":
-        raw = response.body
-        break
+        raw = response.body;
+        break;
       case "nil":
-        body = await response.text()
-        raw = undefined
-        break
+        body = await response.text();
+        raw = undefined;
+        break;
       case "fail":
-        body = await response.text()
-        raw = body
-        break
+        body = await response.text();
+        raw = body;
+        break;
       default:
-        encoding satisfies never
-        throw new Error(`Unsupported response type: ${encoding}`)
+        encoding satisfies never;
+        throw new Error(`Unsupported response type: ${encoding}`);
     }
 
     if (matcher.enc === "fail") {
-      return [
-        {
-          ok: false,
-          error: new AlienDefaultError("API error occurred", {
-            request,
-            response,
-            body,
-          }),
-        },
-        raw,
-      ]
+      return [{
+        ok: false,
+        error: new AlienDefaultError("API error occurred", {
+          request,
+          response,
+          body,
+        }),
+      }, raw];
     }
 
-    const resultKey = matcher.key || options?.resultKey
-    let data: unknown
+    const resultKey = matcher.key || options?.resultKey;
+    let data: unknown;
 
     if ("err" in matcher) {
       data = {
@@ -264,21 +277,21 @@ export function match<T, E>(
         request$: request,
         response$: response,
         body$: body,
-      }
+      };
     } else if (resultKey) {
       data = {
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         [resultKey]: raw,
-      }
+      };
     } else if (matcher.hdrs) {
       data = {
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
-      }
+      };
     } else {
-      data = raw
+      data = raw;
     }
 
     if ("err" in matcher) {
@@ -287,8 +300,8 @@ export function match<T, E>(
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
         { request, response, body },
-      )
-      return [result.ok ? { ok: false, error: result.value } : result, raw]
+      );
+      return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
         safeParseResponse(
@@ -298,24 +311,24 @@ export function match<T, E>(
           { request, response, body },
         ),
         raw,
-      ]
+      ];
     }
-  }
+  };
 }
 
-const headerValRE = /, */
+const headerValRE = /, */;
 /**
  * Iterates over a Headers object and returns an object with all the header
  * entries. Values are represented as an array to account for repeated headers.
  */
 export function unpackHeaders(headers: Headers): Record<string, string[]> {
-  const out: Record<string, string[]> = {}
+  const out: Record<string, string[]> = {};
 
   for (const [k, v] of headers.entries()) {
-    out[k] = v.split(headerValRE)
+    out[k] = v.split(headerValRE);
   }
 
-  return out
+  return out;
 }
 
 function safeParseResponse<Inp, Out>(
@@ -325,7 +338,7 @@ function safeParseResponse<Inp, Out>(
   httpMeta: { response: Response; request: Request; body: string },
 ): Result<Out, ResponseValidationError> {
   try {
-    return OK(fn(rawValue))
+    return OK(fn(rawValue));
   } catch (err) {
     return ERR(
       new ResponseValidationError(errorMessage, {
@@ -334,6 +347,6 @@ function safeParseResponse<Inp, Out>(
         rawMessage: errorMessage,
         ...httpMeta,
       }),
-    )
+    );
   }
 }

package/src/lib/primitives.ts

@@ -4,28 +4,31 @@
 
 class InvariantError extends Error {
   constructor(message: string) {
-    super(message)
-    this.name = "InvariantError"
+    super(message);
+    this.name = "InvariantError";
   }
 }
 
-export function invariant(condition: unknown, message: string): asserts condition {
+export function invariant(
+  condition: unknown,
+  message: string,
+): asserts condition {
   if (!condition) {
-    throw new InvariantError(message)
+    throw new InvariantError(message);
   }
 }
 
 export type ExactPartial<T> = {
-  [P in keyof T]?: T[P] | undefined
-}
+  [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]
-}
+    ? never
+    : k /* otherwise keep the key as-is */]: Inp[k];
+};
 
 /**
  * Converts or omits an object's keys according to a mapping.
@@ -38,108 +41,110 @@ 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 = {}
+  let out: any = {};
 
   if (!Object.keys(mappings).length) {
-    out = inp
-    return out
+    out = inp;
+    return out;
   }
 
   for (const [k, v] of Object.entries(inp)) {
-    const j = mappings[k]
+    const j = mappings[k];
     if (j === null) {
-      continue
+      continue;
     }
-    out[j ?? k] = v
+    out[j ?? k] = v;
   }
 
-  return out
+  return out;
 }
 
 export function combineSignals(
   ...signals: Array<AbortSignal | null | undefined>
 ): AbortSignal | null {
-  const filtered: AbortSignal[] = []
+  const filtered: AbortSignal[] = [];
   for (const signal of signals) {
     if (signal) {
-      filtered.push(signal)
+      filtered.push(signal);
     }
   }
 
   switch (filtered.length) {
     case 0:
     case 1:
-      return filtered[0] || null
+      return filtered[0] || null;
     default:
       if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
-        return AbortSignal.any(filtered)
+        return AbortSignal.any(filtered);
       }
-      return abortSignalAny(filtered)
+      return abortSignalAny(filtered);
   }
 }
 
 export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
-  const controller = new AbortController()
-  const result = controller.signal
+  const controller = new AbortController();
+  const result = controller.signal;
   if (!signals.length) {
-    return controller.signal
+    return controller.signal;
   }
 
   if (signals.length === 1) {
-    return signals[0] || controller.signal
+    return signals[0] || controller.signal;
   }
 
   for (const signal of signals) {
     if (signal.aborted) {
-      return signal
+      return signal;
     }
   }
 
   function abort(this: AbortSignal) {
-    controller.abort(this.reason)
-    clean()
+    controller.abort(this.reason);
+    clean();
   }
 
-  const signalRefs: WeakRef<AbortSignal>[] = []
+  const signalRefs: WeakRef<AbortSignal>[] = [];
   function clean() {
     for (const signalRef of signalRefs) {
-      const signal = signalRef.deref()
+      const signal = signalRef.deref();
       if (signal) {
-        signal.removeEventListener("abort", abort)
+        signal.removeEventListener("abort", abort);
       }
     }
   }
 
   for (const signal of signals) {
-    signalRefs.push(new WeakRef(signal))
-    signal.addEventListener("abort", abort)
+    signalRefs.push(new WeakRef(signal));
+    signal.addEventListener("abort", abort);
   }
 
-  return result
+  return result;
 }
 
-export function compactMap<T>(values: Record<string, T | undefined>): Record<string, T> {
-  const out: Record<string, T> = {}
+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
+      out[k] = v;
     }
   }
 
-  return out
+  return out;
 }
 
 export function allRequired<V extends Record<string, unknown>>(
   v: V,
 ):
   | {
-      [K in keyof V]: NonNullable<V[K]>
+      [K in keyof V]: NonNullable<V[K]>;
     }
   | undefined {
-  if (Object.values(v).every(x => x == null)) {
-    return void 0
+  if (Object.values(v).every((x) => x == null)) {
+    return void 0;
   }
 
-  return v as ReturnType<typeof allRequired<V>>
+  return v as ReturnType<typeof allRequired<V>>;
 }