@mixedbread/sdk 0.2.2 → 0.4.0

package/src/internal/headers.ts

@@ -0,0 +1,96 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+type HeaderValue = string | undefined | null;
+export type HeadersLike =
+  | Headers
+  | readonly [string, HeaderValue][]
+  | Record<string, HeaderValue | readonly HeaderValue[]>
+  | undefined
+  | null
+  | NullableHeaders;
+
+const brand_privateNullableHeaders = Symbol('brand.privateNullableHeaders');
+
+/**
+ * @internal
+ * Users can pass explicit nulls to unset default headers. When we parse them
+ * into a standard headers type we need to preserve that information.
+ */
+export type NullableHeaders = {
+  /** Brand check, prevent users from creating a NullableHeaders. */
+  [brand_privateNullableHeaders]: true;
+  /** Parsed headers. */
+  values: Headers;
+  /** Set of lowercase header names explicitly set to null. */
+  nulls: Set<string>;
+};
+
+const isArray = Array.isArray as (val: unknown) => val is readonly unknown[];
+
+function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [string, string | null]> {
+  if (!headers) return;
+
+  if (brand_privateNullableHeaders in headers) {
+    const { values, nulls } = headers;
+    yield* values.entries();
+    for (const name of nulls) {
+      yield [name, null];
+    }
+    return;
+  }
+
+  let shouldClear = false;
+  let iter: Iterable<readonly [string, HeaderValue | readonly HeaderValue[]]>;
+  if (headers instanceof Headers) {
+    iter = headers.entries();
+  } else if (isArray(headers)) {
+    iter = headers;
+  } else {
+    shouldClear = true;
+    iter = Object.entries(headers ?? {});
+  }
+  for (let row of iter) {
+    const name = row[0];
+    const values = isArray(row[1]) ? row[1] : [row[1]];
+    let didClear = false;
+    for (const value of values) {
+      if (value === undefined) continue;
+
+      // Objects keys always overwrite older headers, they never append.
+      // Yield a null to clear the header before adding the new values.
+      if (shouldClear && !didClear) {
+        didClear = true;
+        yield [name, null];
+      }
+      yield [name, value];
+    }
+  }
+}
+
+export const buildHeaders = (newHeaders: HeadersLike[]): NullableHeaders => {
+  const targetHeaders = new Headers();
+  const nullHeaders = new Set<string>();
+  const seenHeaders = new Set<string>();
+  for (const headers of newHeaders) {
+    for (const [name, value] of iterateHeaders(headers)) {
+      const lowerName = name.toLowerCase();
+      if (!seenHeaders.has(lowerName)) {
+        targetHeaders.delete(name);
+        seenHeaders.add(lowerName);
+      }
+      if (value === null) {
+        targetHeaders.delete(name);
+        nullHeaders.add(lowerName);
+      } else {
+        targetHeaders.append(name, value);
+        nullHeaders.delete(lowerName);
+      }
+    }
+  }
+  return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+
+export const isEmptyHeaders = (headers: HeadersLike) => {
+  for (const _ of iterateHeaders(headers)) return false;
+  return true;
+};

package/src/internal/parse.ts

@@ -0,0 +1,50 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { FinalRequestOptions } from './request-options';
+import { type Mixedbread } from '../client';
+import { formatRequestDetails, loggerFor } from './utils/log';
+
+export type APIResponseProps = {
+  response: Response;
+  options: FinalRequestOptions;
+  controller: AbortController;
+  requestLogID: string;
+  retryOfRequestLogID: string | undefined;
+  startTime: number;
+};
+
+export async function defaultParseResponse<T>(client: Mixedbread, props: APIResponseProps): Promise<T> {
+  const { response, requestLogID, retryOfRequestLogID, startTime } = props;
+  const body = await (async () => {
+    // fetch refuses to read the body when the status code is 204.
+    if (response.status === 204) {
+      return null as T;
+    }
+
+    if (props.options.__binaryResponse) {
+      return response as unknown as T;
+    }
+
+    const contentType = response.headers.get('content-type');
+    const mediaType = contentType?.split(';')[0]?.trim();
+    const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
+    if (isJSON) {
+      const json = await response.json();
+      return json as T;
+    }
+
+    const text = await response.text();
+    return text as unknown as T;
+  })();
+  loggerFor(client).debug(
+    `[${requestLogID}] response parsed`,
+    formatRequestDetails({
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      body,
+      durationMs: Date.now() - startTime,
+    }),
+  );
+  return body;
+}

package/src/internal/request-options.ts

@@ -0,0 +1,37 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { NullableHeaders } from './headers';
+
+import type { BodyInit } from './builtin-types';
+import type { HTTPMethod, MergedRequestInit } from './types';
+import { type HeadersLike } from './headers';
+
+export type FinalRequestOptions = RequestOptions & { method: HTTPMethod; path: string };
+
+export type RequestOptions = {
+  method?: HTTPMethod;
+  path?: string;
+  query?: object | undefined | null;
+  body?: unknown;
+  headers?: HeadersLike;
+  maxRetries?: number;
+  stream?: boolean | undefined;
+  timeout?: number;
+  fetchOptions?: MergedRequestInit;
+  signal?: AbortSignal | undefined | null;
+  idempotencyKey?: string;
+
+  __binaryResponse?: boolean | undefined;
+};
+
+export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };
+export type RequestEncoder = (request: { headers: NullableHeaders; body: unknown }) => EncodedContent;
+
+export const FallbackEncoder: RequestEncoder = ({ headers, body }) => {
+  return {
+    bodyHeaders: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  };
+};

package/src/internal/shim-types.d.ts

@@ -0,0 +1,28 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * Shims for types that we can't always rely on being available globally.
+ *
+ * Note: these only exist at the type-level, there is no corresponding runtime
+ * version for any of these symbols.
+ */
+
+/**
+ * In order to properly access the global `NodeJS` type, if it's available, we
+ * need to make use of declaration shadowing. Without this, any checks for the
+ * presence of `NodeJS.ReadableStream` will fail.
+ */
+declare namespace NodeJS {
+  interface ReadableStream {}
+}
+
+type HasProperties<T> = keyof T extends never ? false : true;
+
+// @ts-ignore
+type _ReadableStream<R = any> =
+  // @ts-ignore
+  HasProperties<NodeJS.ReadableStream> extends true ? NodeJS.ReadableStream<R> : ReadableStream<R>;
+
+// @ts-ignore
+declare const _ReadableStream: unknown extends typeof ReadableStream ? never : typeof ReadableStream;
+export { _ReadableStream as ReadableStream };

package/src/internal/shims/crypto.ts

@@ -0,0 +1,18 @@
+import { getBuiltinModule } from './getBuiltinModule';
+
+type Crypto = {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
+  getRandomValues<T extends ArrayBufferView | null>(array: T): T;
+  /**
+   * Available only in secure contexts.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
+   */
+  randomUUID?: () => string;
+};
+export let getCrypto: () => Crypto | undefined = function lazyGetCrypto() {
+  if (getCrypto !== lazyGetCrypto) return getCrypto();
+  const crypto: Crypto = (globalThis as any).crypto || (getBuiltinModule?.('node:crypto') as any)?.webcrypto;
+  getCrypto = () => crypto;
+  return crypto;
+};

package/src/internal/shims/file.ts

@@ -0,0 +1,32 @@
+import { getBuiltinModule } from './getBuiltinModule';
+
+export let getFile = function lazyGetFile(): FileConstructor {
+  if (getFile !== lazyGetFile) return getFile();
+  // We can drop getBuiltinModule once we no longer support Node < 20.0.0
+  const File = (globalThis as any).File ?? (getBuiltinModule?.('node:buffer') as any)?.File;
+  if (!File) throw new Error('`File` is not defined as a global, which is required for file uploads.');
+  getFile = () => File;
+  return File;
+};
+
+type FileConstructor =
+  typeof globalThis extends { File: infer fileConstructor } ? fileConstructor : typeof FallbackFile;
+export type File = InstanceType<FileConstructor>;
+
+// The infer is to make TS show it as a nice union type,
+// instead of literally `ConstructorParameters<typeof Blob>[0]`
+type FallbackBlobSource = ConstructorParameters<typeof Blob>[0] extends infer T ? T : never;
+/**
+ * A [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) provides information about files.
+ */
+declare class FallbackFile extends Blob {
+  constructor(sources: FallbackBlobSource, fileName: string, options?: any);
+  /**
+   * The name of the `File`.
+   */
+  readonly name: string;
+  /**
+   * The last modified date of the `File`.
+   */
+  readonly lastModified: number;
+}

package/src/internal/shims/getBuiltinModule.ts

@@ -0,0 +1,64 @@
+/**
+ * Load a Node built-in module. ID may or may not be prefixed by `node:` and
+ * will be normalized. If we used static imports then our bundle size would be bloated by
+ * injected polyfills, and if we used dynamic require then in addition to bundlers logging warnings,
+ * our code would not work when bundled to ESM and run in Node 18.
+ * @param {string} id ID of the built-in to be loaded.
+ * @returns {object|undefined} exports of the built-in. Undefined if the built-in
+ * does not exist.
+ */
+export let getBuiltinModule: null | ((id: string) => object | undefined) = function getBuiltinModuleLazy(
+  id: string,
+): object | undefined {
+  try {
+    if (getBuiltinModule !== getBuiltinModuleLazy) return getBuiltinModule!(id);
+    if ((process as any).getBuiltinModule) {
+      getBuiltinModule = (process as any).getBuiltinModule;
+    } else {
+      /* Fallback implementation for Node 18 */
+      function createFallbackGetBuiltinModule(BuiltinModule: any) {
+        return function getBuiltinModule(id: string): object | undefined {
+          id = BuiltinModule.normalizeRequirableId(String(id));
+          if (!BuiltinModule.canBeRequiredByUsers(id)) {
+            return;
+          }
+          const mod = BuiltinModule.map.get(id);
+          mod.compileForPublicLoader();
+          return mod.exports;
+        };
+      }
+      const magicKey = Math.random() + '';
+      let module: { BuiltinModule: any } | undefined;
+      try {
+        const kClone = Object.getOwnPropertySymbols(Blob.prototype).find(
+          (e) => e.description?.includes('clone'),
+        )!;
+        Object.defineProperty(Object.prototype, magicKey, {
+          get() {
+            module = this;
+            throw null;
+          },
+          configurable: true,
+        });
+        structuredClone(
+          new (class extends Blob {
+            [kClone]() {
+              return {
+                deserializeInfo: 'internal/bootstrap/realm:' + magicKey,
+              };
+            }
+          })([]),
+        );
+      } catch {}
+      delete (Object.prototype as any)[magicKey];
+      if (module) {
+        getBuiltinModule = createFallbackGetBuiltinModule(module.BuiltinModule);
+      } else {
+        getBuiltinModule = () => undefined;
+      }
+    }
+    return getBuiltinModule!(id);
+  } catch {
+    return undefined;
+  }
+};

package/src/internal/shims/nullGetBuiltinModule.ts

@@ -0,0 +1 @@
+export const getBuiltinModule = null;

package/src/internal/shims.ts

@@ -0,0 +1,107 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * This module provides internal shims and utility functions for environments where certain Node.js or global types may not be available.
+ *
+ * These are used to ensure we can provide a consistent behaviour between different JavaScript environments and good error
+ * messages in cases where an environment isn't fully supported.
+ */
+
+import { type Fetch } from './builtin-types';
+import { type ReadableStream } from './shim-types';
+
+export function getDefaultFetch(): Fetch {
+  if (typeof fetch !== 'undefined') {
+    return fetch as any;
+  }
+
+  throw new Error(
+    '`fetch` is not defined as a global; Either pass `fetch` to the client, `new Mixedbread({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
+  );
+}
+
+type ReadableStreamArgs = ConstructorParameters<typeof ReadableStream>;
+
+export function makeReadableStream(...args: ReadableStreamArgs): ReadableStream {
+  const ReadableStream = (globalThis as any).ReadableStream;
+  if (typeof ReadableStream === 'undefined') {
+    // Note: All of the platforms / runtimes we officially support already define
+    // `ReadableStream` as a global, so this should only ever be hit on unsupported runtimes.
+    throw new Error(
+      '`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`',
+    );
+  }
+
+  return new ReadableStream(...args);
+}
+
+export function ReadableStreamFrom<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T> {
+  let iter: AsyncIterator<T> | Iterator<T> =
+    Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+
+  return makeReadableStream({
+    start() {},
+    async pull(controller: any) {
+      const { done, value } = await iter.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    async cancel() {
+      await iter.return?.();
+    },
+  });
+}
+
+/**
+ * Most browsers don't yet have async iterable support for ReadableStream,
+ * and Node has a very different way of reading bytes from its "ReadableStream".
+ *
+ * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
+ */
+export function ReadableStreamToAsyncIterable<T>(stream: any): AsyncIterableIterator<T> {
+  if (stream[Symbol.asyncIterator]) return stream;
+
+  const reader = stream.getReader();
+  return {
+    async next() {
+      try {
+        const result = await reader.read();
+        if (result?.done) reader.releaseLock(); // release lock when stream becomes closed
+        return result;
+      } catch (e) {
+        reader.releaseLock(); // release lock when stream becomes errored
+        throw e;
+      }
+    },
+    async return() {
+      const cancelPromise = reader.cancel();
+      reader.releaseLock();
+      await cancelPromise;
+      return { done: true, value: undefined };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+}
+
+/**
+ * Cancels a ReadableStream we don't need to consume.
+ * See https://undici.nodejs.org/#/?id=garbage-collection
+ */
+export async function CancelReadableStream(stream: any): Promise<void> {
+  if (stream === null || typeof stream !== 'object') return;
+
+  if (stream[Symbol.asyncIterator]) {
+    await stream[Symbol.asyncIterator]().return?.();
+    return;
+  }
+
+  const reader = stream.getReader();
+  const cancelPromise = reader.cancel();
+  reader.releaseLock();
+  await cancelPromise;
+}

package/src/internal/to-file.ts

@@ -0,0 +1,152 @@
+import { type File, getFile } from './shims/file';
+import { BlobPart, getName, makeFile, isAsyncIterable } from './uploads';
+import type { FilePropertyBag } from './builtin-types';
+
+type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView;
+
+/**
+ * Intended to match DOM Blob, node-fetch Blob, node:buffer Blob, etc.
+ * Don't add arrayBuffer here, node-fetch doesn't have it
+ */
+interface BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+  readonly size: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+  readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+  text(): Promise<string>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+  slice(start?: number, end?: number): BlobLike;
+}
+
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isBlobLike = (value: any): value is BlobLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.size === 'number' &&
+  typeof value.type === 'string' &&
+  typeof value.text === 'function' &&
+  typeof value.slice === 'function' &&
+  typeof value.arrayBuffer === 'function';
+
+/**
+ * Intended to match DOM File, node:buffer File, undici File, etc.
+ */
+interface FileLike extends BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+  readonly lastModified: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+  readonly name?: string | undefined;
+}
+
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isFileLike = (value: any): value is FileLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.name === 'string' &&
+  typeof value.lastModified === 'number' &&
+  isBlobLike(value);
+
+/**
+ * Intended to match DOM Response, node-fetch Response, undici Response, etc.
+ */
+export interface ResponseLike {
+  url: string;
+  blob(): Promise<BlobLike>;
+}
+
+const isResponseLike = (value: any): value is ResponseLike =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.url === 'string' &&
+  typeof value.blob === 'function';
+
+export type ToFileInput =
+  | FileLike
+  | ResponseLike
+  | Exclude<BlobLikePart, string>
+  | AsyncIterable<BlobLikePart>;
+
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param value the raw content of the file.  Can be an {@link Uploadable}, {@link BlobLikePart}, or {@link AsyncIterable} of {@link BlobLikePart}s
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+export async function toFile(
+  value: ToFileInput | PromiseLike<ToFileInput>,
+  name?: string | null | undefined,
+  options?: FilePropertyBag | undefined,
+): Promise<File> {
+  // If it's a promise, resolve it.
+  value = await value;
+
+  // If we've been given a `File` we don't need to do anything
+  if (isFileLike(value)) {
+    if (value instanceof getFile()) {
+      return value;
+    }
+    return makeFile([await value.arrayBuffer()], value.name);
+  }
+
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop();
+
+    return makeFile(await getBytes(blob), name, options);
+  }
+
+  const parts = await getBytes(value);
+
+  name ||= getName(value);
+
+  if (!options?.type) {
+    const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type);
+    if (typeof type === 'string') {
+      options = { ...options, type };
+    }
+  }
+
+  return makeFile(parts, name, options);
+}
+
+async function getBytes(value: BlobLikePart | AsyncIterable<BlobLikePart>): Promise<Array<BlobPart>> {
+  let parts: Array<BlobPart> = [];
+  if (
+    typeof value === 'string' ||
+    ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+    value instanceof ArrayBuffer
+  ) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(value instanceof Blob ? value : await value.arrayBuffer());
+  } else if (
+    isAsyncIterable(value) // includes Readable, ReadableStream, etc.
+  ) {
+    for await (const chunk of value) {
+      parts.push(...(await getBytes(chunk as BlobLikePart))); // TODO, consider validating?
+    }
+  } else {
+    const constructor = value?.constructor?.name;
+    throw new Error(
+      `Unexpected data type: ${typeof value}${
+        constructor ? `; constructor: ${constructor}` : ''
+      }${propsForError(value)}`,
+    );
+  }
+
+  return parts;
+}
+
+function propsForError(value: unknown): string {
+  if (typeof value !== 'object' || value === null) return '';
+  const props = Object.getOwnPropertyNames(value);
+  return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`;
+}