@roarkanalytics/sdk 2.21.0 → 2.21.1

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,41 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { FinalRequestOptions } from './request-options';
+import { type Roark } from '../client';
+import { logger } from './utils/log';
+
+export type APIResponseProps = {
+  response: Response;
+  options: FinalRequestOptions;
+  controller: AbortController;
+};
+
+export async function defaultParseResponse<T>(client: Roark, props: APIResponseProps): Promise<T> {
+  const { response } = props;
+
+  // 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 isJSON =
+    contentType?.includes('application/json') || contentType?.includes('application/vnd.api+json');
+  if (isJSON) {
+    const json = await response.json();
+
+    logger(client).debug('response', response.status, response.url, response.headers, json);
+
+    return json as T;
+  }
+
+  const text = await response.text();
+  logger(client).debug('response', response.status, response.url, response.headers, text);
+
+  // TODO handle blob, arraybuffer, other content types, etc.
+  return text as unknown as T;
+}

package/src/internal/polyfill/crypto.node.d.ts

@@ -0,0 +1,10 @@
+export declare const 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;
+};

package/src/internal/polyfill/crypto.node.js

@@ -0,0 +1,11 @@
+if (typeof require !== 'undefined') {
+  if (globalThis.crypto) {
+    exports.crypto = globalThis.crypto;
+  } else {
+    try {
+      // Use [require][0](...) and not require(...) so bundlers don't try to bundle the
+      // crypto module.
+      exports.crypto = [require][0]('node:crypto').webcrypto;
+    } catch (e) {}
+  }
+}

package/src/internal/polyfill/crypto.node.mjs

@@ -0,0 +1,2 @@
+import * as mod from './crypto.node.js';
+export const crypto = globalThis.crypto || mod.crypto;

package/src/internal/polyfill/file.node.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This file polyfills the global `File` object for you if it's not already defined
+ * when running on Node.js
+ *
+ * This is only needed on Node.js v18 & v19. Newer versions already define `File`
+ * as a global.
+ */
+
+export {};

package/src/internal/polyfill/file.node.js

@@ -0,0 +1,17 @@
+/**
+ * This file polyfills the global `File` object for you if it's not already defined
+ * when running on Node.js
+ *
+ * This is only needed on Node.js v18 & v19. Newer versions already define `File`
+ * as a global.
+ */
+
+if (typeof require !== 'undefined') {
+  if (!globalThis.File) {
+    try {
+      // Use [require][0](...) and not require(...) so bundlers don't try to bundle the
+      // buffer module.
+      globalThis.File = [require][0]('node:buffer').File;
+    } catch (e) {}
+  }
+}

package/src/internal/polyfill/file.node.mjs

@@ -0,0 +1,9 @@
+/**
+ * This file polyfills the global `File` object for you if it's not already defined
+ * when running on Node.js
+ *
+ * This is only needed on Node.js v18 & v19. Newer versions already define `File`
+ * as a global.
+ */
+
+import './file.node.js';

package/src/internal/request-options.ts

@@ -0,0 +1,67 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { NullableHeaders } from './headers';
+
+import type { BodyInit } from './builtin-types';
+import { isEmptyObj, hasOwn } from './utils/values';
+import type { HTTPMethod, KeysEnum, 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;
+};
+
+// This is required so that we can determine if a given object matches the RequestOptions
+// type at runtime. While this requires duplication, it is enforced by the TypeScript
+// compiler such that any missing / extraneous keys will cause an error.
+const requestOptionsKeys: KeysEnum<RequestOptions> = {
+  method: true,
+  path: true,
+  query: true,
+  body: true,
+  headers: true,
+
+  maxRetries: true,
+  stream: true,
+  timeout: true,
+  fetchOptions: true,
+  signal: true,
+  idempotencyKey: true,
+
+  __binaryResponse: true,
+};
+
+export const isRequestOptions = (obj: unknown): obj is RequestOptions => {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    !isEmptyObj(obj) &&
+    Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k))
+  );
+};
+
+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.ts

@@ -0,0 +1,145 @@
+// 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 Roark({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
+  );
+}
+
+/**
+ * A minimal copy of the NodeJS `stream.Readable` class so that we can
+ * accept the NodeJS types in certain places, e.g. file uploads
+ *
+ * https://nodejs.org/api/stream.html#class-streamreadable
+ */
+export interface ReadableLike {
+  readable: boolean;
+  readonly readableEnded: boolean;
+  readonly readableFlowing: boolean | null;
+  readonly readableHighWaterMark: number;
+  readonly readableLength: number;
+  readonly readableObjectMode: boolean;
+  destroyed: boolean;
+  read(size?: number): any;
+  pause(): this;
+  resume(): this;
+  isPaused(): boolean;
+  destroy(error?: Error): this;
+  [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}
+
+/**
+ * Determines if the given value looks like a NodeJS `stream.Readable`
+ * object and that it is readable, i.e. has not been consumed.
+ *
+ * https://nodejs.org/api/stream.html#class-streamreadable
+ */
+export function isReadableLike(value: any) {
+  // We declare our own class of Readable here, so it's not feasible to
+  // do an 'instanceof' check. Instead, check for Readable-like properties.
+  return !!value && value.readable === true && typeof value.read === 'function';
+}
+
+/**
+ * A minimal copy of the NodeJS `fs.ReadStream` class for usage within file uploads.
+ *
+ * https://nodejs.org/api/fs.html#class-fsreadstream
+ */
+export interface FsReadStreamLike extends ReadableLike {
+  path: {}; // real type is string | Buffer but we can't reference `Buffer` here
+}
+
+/**
+ * Determines if the given value looks like a NodeJS `fs.ReadStream`
+ * object.
+ *
+ * This just checks if the object matches our `Readable` interface
+ * and defines a `path` property, there may be false positives.
+ *
+ * https://nodejs.org/api/fs.html#class-fsreadstream
+ */
+export function isFsReadStreamLike(value: any): value is FsReadStreamLike {
+  return isReadableLike(value) && 'path' in value;
+}
+
+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;
+    },
+  };
+}

package/src/internal/types.ts

@@ -0,0 +1,98 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export type PromiseOrValue<T> = T | Promise<T>;
+export type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+
+export type KeysEnum<T> = { [P in keyof Required<T>]: true };
+
+type NotAny<T> = [unknown] extends [T] ? never : T;
+type Literal<T> = PropertyKey extends T ? never : T;
+type MappedLiteralKeys<T> = T extends any ? Literal<keyof T> : never;
+type MappedIndex<T, K> =
+  T extends any ?
+    K extends keyof T ?
+      T[K]
+    : never
+  : never;
+
+/**
+ * Some environments overload the global fetch function, and Parameters<T> only gets the last signature.
+ */
+type OverloadedParameters<T> =
+  T extends (
+    {
+      (...args: infer A): unknown;
+      (...args: infer B): unknown;
+      (...args: infer C): unknown;
+      (...args: infer D): unknown;
+    }
+  ) ?
+    A | B | C | D
+  : T extends (
+    {
+      (...args: infer A): unknown;
+      (...args: infer B): unknown;
+      (...args: infer C): unknown;
+    }
+  ) ?
+    A | B | C
+  : T extends (
+    {
+      (...args: infer A): unknown;
+      (...args: infer B): unknown;
+    }
+  ) ?
+    A | B
+  : T extends (...args: infer A) => unknown ? A
+  : never;
+
+/* eslint-disable */
+/**
+ * These imports attempt to get types from a parent package's dependencies.
+ * Unresolved bare specifiers can trigger [automatic type acquisition][1] in some projects, which
+ * would cause typescript to show types not present at runtime. To avoid this, we import
+ * directly from parent node_modules folders.
+ *
+ * We need to check multiple levels because we don't know what directory structure we'll be in.
+ * For example, pnpm generates directories like this:
+ * ```
+ * node_modules
+ * ├── .pnpm
+ * │   └── pkg@1.0.0
+ * │       └── node_modules
+ * │           └── pkg
+ * │               └── internal
+ * │                   └── types.d.ts
+ * ├── pkg -> .pnpm/pkg@1.0.0/node_modules/pkg
+ * └── undici
+ * ```
+ *
+ * [1]: https://www.typescriptlang.org/tsconfig/#typeAcquisition
+ */
+/** @ts-ignore For users with \@types/node */
+type UndiciTypesRequestInit = NotAny<import('../node_modules/undici-types').RequestInit> | NotAny<import('../../node_modules/undici-types').RequestInit> | NotAny<import('../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../../../node_modules/undici-types').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/undici-types').RequestInit>;
+/** @ts-ignore For users with undici */
+type UndiciRequestInit = NotAny<import('../node_modules/undici').RequestInit> | NotAny<import('../../node_modules/undici').RequestInit> | NotAny<import('../../../node_modules/undici').RequestInit> | NotAny<import('../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../../../node_modules/undici').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/undici').RequestInit>;
+/** @ts-ignore For users with \@types/bun */
+type BunRequestInit = globalThis.FetchRequestInit;
+/** @ts-ignore For users with node-fetch */
+type NodeFetchRequestInit = NotAny<import('../node_modules/node-fetch').RequestInit> | NotAny<import('../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/node-fetch').RequestInit>;
+/** @ts-ignore For users who use Deno */
+type FetchRequestInit = NonNullable<OverloadedParameters<typeof fetch>[1]>;
+/* eslint-enable */
+
+type RequestInits =
+  | NotAny<UndiciTypesRequestInit>
+  | NotAny<UndiciRequestInit>
+  | NotAny<BunRequestInit>
+  | NotAny<NodeFetchRequestInit>
+  | NotAny<RequestInit>
+  | NotAny<FetchRequestInit>;
+
+/**
+ * This type contains `RequestInit` options that may be available on the current runtime,
+ * including per-platform extensions like `dispatcher`, `agent`, `client`, etc.
+ */
+export type MergedRequestInit = {
+  [K in MappedLiteralKeys<RequestInits>]?: MappedIndex<RequestInits, K> | undefined;
+};