@compose-market/sdk 0.7.11 → 0.8.0

package/generated/channels/src/lib/matchers.ts

@@ -0,0 +1,356 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { DefaultError } from "../models/errors/compose-market-default-error.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { ERR, OK, Result } from "../types/fp.js";
+import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
+import { isPlainObject } from "./primitives.js";
+
+export type Encoding =
+  | "jsonl"
+  | "json"
+  | "text"
+  | "bytes"
+  | "stream"
+  | "sse"
+  | "nil"
+  | "fail";
+
+const DEFAULT_CONTENT_TYPES: Record<Encoding, string> = {
+  jsonl: "application/jsonl",
+  json: "application/json",
+  text: "text/plain",
+  bytes: "application/octet-stream",
+  stream: "application/octet-stream",
+  sse: "text/event-stream",
+  nil: "*",
+  fail: "*",
+};
+
+type Schema<T> = { parse(raw: unknown): T };
+
+type MatchOptions = {
+  ctype?: string;
+  hdrs?: boolean;
+  key?: string;
+  sseSentinel?: string;
+};
+
+export type ValueMatcher<V> = MatchOptions & {
+  enc: Encoding;
+  codes: StatusCodePredicate;
+  schema: Schema<V>;
+};
+
+export type ErrorMatcher<E> = MatchOptions & {
+  enc: Encoding;
+  codes: StatusCodePredicate;
+  schema: Schema<E>;
+  err: true;
+};
+
+export type FailMatcher = {
+  enc: "fail";
+  codes: StatusCodePredicate;
+};
+
+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 };
+}
+export function json<T>(
+  codes: StatusCodePredicate,
+  schema: Schema<T>,
+  options?: MatchOptions,
+): ValueMatcher<T> {
+  return { ...options, enc: "json", codes, schema };
+}
+
+export function jsonl<T>(
+  codes: StatusCodePredicate,
+  schema: Schema<T>,
+  options?: MatchOptions,
+): ValueMatcher<T> {
+  return { ...options, enc: "jsonl", codes, schema };
+}
+
+export function jsonlErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  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 };
+}
+export function text<T>(
+  codes: StatusCodePredicate,
+  schema: Schema<T>,
+  options?: MatchOptions,
+): ValueMatcher<T> {
+  return { ...options, enc: "text", codes, schema };
+}
+
+export function bytesErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  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 };
+}
+
+export function streamErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  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 };
+}
+
+export function sseErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  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 };
+}
+
+export function nilErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  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 };
+}
+
+export function fail(codes: StatusCodePredicate): FailMatcher {
+  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 MatchFunc<T, E> = (
+  response: Response,
+  request: Request,
+  options?: { resultKey?: string; extraFields?: Record<string, unknown> },
+) => Promise<[result: Result<T, E>, raw: unknown]>;
+
+export function match<T, E>(
+  ...matchers: Array<Matcher<T, E>>
+): MatchFunc<T, E | DefaultError | ResponseValidationError> {
+  return async function matchFunc(
+    response: Response,
+    request: Request,
+    options?: { resultKey?: string; extraFields?: Record<string, unknown> },
+  ): Promise<
+    [
+      result: Result<
+        T,
+        E | DefaultError | 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];
+      if (ctpattern && matchResponse(response, codes, ctpattern)) {
+        matcher = match;
+        break;
+      } else if (!ctpattern && matchStatusCode(response, codes)) {
+        matcher = match;
+        break;
+      }
+    }
+
+    if (!matcher) {
+      return [{
+        ok: false,
+        error: new DefaultError(
+          "Unexpected Status or Content-Type",
+          {
+            response,
+            request,
+            body: await response.text().catch(() => ""),
+          },
+        ),
+      }, raw];
+    }
+
+    const encoding = matcher.enc;
+    let body = "";
+    switch (encoding) {
+      case "json":
+        body = await response.text();
+        raw = JSON.parse(body);
+        break;
+      case "jsonl":
+        raw = response.body;
+        break;
+      case "bytes":
+        raw = new Uint8Array(await response.arrayBuffer());
+        break;
+      case "stream":
+        raw = response.body;
+        break;
+      case "text":
+        body = await response.text();
+        raw = body;
+        break;
+      case "sse":
+        raw = response.body;
+        break;
+      case "nil":
+        body = await response.text();
+        raw = undefined;
+        break;
+      case "fail":
+        body = await response.text();
+        raw = body;
+        break;
+      default:
+        throw new Error(
+          `Unsupported response type: ${encoding satisfies never}`,
+        );
+    }
+
+    if (matcher.enc === "fail") {
+      return [{
+        ok: false,
+        error: new DefaultError("API error occurred", {
+          request,
+          response,
+          body,
+        }),
+      }, raw];
+    }
+
+    const resultKey = matcher.key || options?.resultKey;
+    let data: unknown;
+
+    if ("err" in matcher) {
+      data = {
+        ...options?.extraFields,
+        ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+        ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
+      };
+    } else if (resultKey) {
+      data = {
+        ...options?.extraFields,
+        ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+        [resultKey]: raw,
+      };
+    } else {
+      data = {
+        ...options?.extraFields,
+        ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+      };
+    }
+
+    if ("err" in matcher) {
+      const result = safeParseResponse(
+        data,
+        (v: unknown) => matcher.schema.parse(v),
+        "Response validation failed",
+        { request, response, body },
+      );
+      return [result.ok ? { ok: false, error: result.value } : result, raw];
+    } else {
+      return [
+        safeParseResponse(
+          data,
+          (v: unknown) => matcher.schema.parse(v),
+          "Response validation failed",
+          { request, response, body },
+        ),
+        raw,
+      ];
+    }
+  };
+}
+
+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[]> = {};
+
+  for (const [k, v] of headers.entries()) {
+    out[k] = v.split(headerValRE);
+  }
+
+  return out;
+}
+
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
+  try {
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
+  }
+}

package/generated/channels/src/lib/primitives.ts

@@ -0,0 +1,166 @@
+/*
+ * 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>>;
+}
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype) return true;
+  // cross-realm plain objects (vm contexts, iframes) inherit from a
+  // different realm's Object.prototype, which itself has a null prototype
+  try {
+    return Object.getPrototypeOf(proto) === null;
+  } catch {
+    return false;
+  }
+}