@roarkanalytics/sdk 2.21.1 → 2.22.0

package/src/core/error.ts

@@ -0,0 +1,130 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { castToError } from '../internal/errors';
+
+export class RoarkError extends Error {}
+
+export class APIError<
+  TStatus extends number | undefined = number | undefined,
+  THeaders extends Headers | undefined = Headers | undefined,
+  TError extends Object | undefined = Object | undefined,
+> extends RoarkError {
+  /** HTTP status for the response that caused the error */
+  readonly status: TStatus;
+  /** HTTP headers for the response that caused the error */
+  readonly headers: THeaders;
+  /** JSON body of the response that caused the error */
+  readonly error: TError;
+
+  constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
+      error?.message ?
+        typeof error.message === 'string' ?
+          error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError<undefined, undefined, undefined> {
+  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError<400, Headers> {}
+
+export class AuthenticationError extends APIError<401, Headers> {}
+
+export class PermissionDeniedError extends APIError<403, Headers> {}
+
+export class NotFoundError extends APIError<404, Headers> {}
+
+export class ConflictError extends APIError<409, Headers> {}
+
+export class UnprocessableEntityError extends APIError<422, Headers> {}
+
+export class RateLimitError extends APIError<429, Headers> {}
+
+export class InternalServerError extends APIError<number, Headers> {}

package/src/core/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { Roark } from '../client';
+
+export abstract class APIResource {
+  protected _client: Roark;
+
+  constructor(client: Roark) {
+    this._client = client;
+  }
+}

package/src/core/uploads.ts

@@ -0,0 +1,2 @@
+export { type Uploadable } from '../internal/uploads';
+export { toFile, type ToFileInput } from '../internal/to-file';

package/src/error.ts

@@ -1,130 +1,2 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-import { castToError } from './internal/errors';
-
-export class RoarkError extends Error {}
-
-export class APIError<
-  TStatus extends number | undefined = number | undefined,
-  THeaders extends Headers | undefined = Headers | undefined,
-  TError extends Object | undefined = Object | undefined,
-> extends RoarkError {
-  /** HTTP status for the response that caused the error */
-  readonly status: TStatus;
-  /** HTTP headers for the response that caused the error */
-  readonly headers: THeaders;
-  /** JSON body of the response that caused the error */
-  readonly error: TError;
-
-  constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
-    super(`${APIError.makeMessage(status, error, message)}`);
-    this.status = status;
-    this.headers = headers;
-    this.error = error;
-  }
-
-  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
-    const msg =
-      error?.message ?
-        typeof error.message === 'string' ?
-          error.message
-        : JSON.stringify(error.message)
-      : error ? JSON.stringify(error)
-      : message;
-
-    if (status && msg) {
-      return `${status} ${msg}`;
-    }
-    if (status) {
-      return `${status} status code (no body)`;
-    }
-    if (msg) {
-      return msg;
-    }
-    return '(no status code or body)';
-  }
-
-  static generate(
-    status: number | undefined,
-    errorResponse: Object | undefined,
-    message: string | undefined,
-    headers: Headers | undefined,
-  ): APIError {
-    if (!status || !headers) {
-      return new APIConnectionError({ message, cause: castToError(errorResponse) });
-    }
-
-    const error = errorResponse as Record<string, any>;
-
-    if (status === 400) {
-      return new BadRequestError(status, error, message, headers);
-    }
-
-    if (status === 401) {
-      return new AuthenticationError(status, error, message, headers);
-    }
-
-    if (status === 403) {
-      return new PermissionDeniedError(status, error, message, headers);
-    }
-
-    if (status === 404) {
-      return new NotFoundError(status, error, message, headers);
-    }
-
-    if (status === 409) {
-      return new ConflictError(status, error, message, headers);
-    }
-
-    if (status === 422) {
-      return new UnprocessableEntityError(status, error, message, headers);
-    }
-
-    if (status === 429) {
-      return new RateLimitError(status, error, message, headers);
-    }
-
-    if (status >= 500) {
-      return new InternalServerError(status, error, message, headers);
-    }
-
-    return new APIError(status, error, message, headers);
-  }
-}
-
-export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
-  constructor({ message }: { message?: string } = {}) {
-    super(undefined, undefined, message || 'Request was aborted.', undefined);
-  }
-}
-
-export class APIConnectionError extends APIError<undefined, undefined, undefined> {
-  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
-    super(undefined, undefined, message || 'Connection error.', undefined);
-    // in some environments the 'cause' property is already declared
-    // @ts-ignore
-    if (cause) this.cause = cause;
-  }
-}
-
-export class APIConnectionTimeoutError extends APIConnectionError {
-  constructor({ message }: { message?: string } = {}) {
-    super({ message: message ?? 'Request timed out.' });
-  }
-}
-
-export class BadRequestError extends APIError<400, Headers> {}
-
-export class AuthenticationError extends APIError<401, Headers> {}
-
-export class PermissionDeniedError extends APIError<403, Headers> {}
-
-export class NotFoundError extends APIError<404, Headers> {}
-
-export class ConflictError extends APIError<409, Headers> {}
-
-export class UnprocessableEntityError extends APIError<422, Headers> {}
-
-export class RateLimitError extends APIError<429, Headers> {}
-
-export class InternalServerError extends APIError<number, Headers> {}
+/** @deprecated Import from ./core/error instead */
+export * from './core/error';

package/src/index.ts

@@ -2,8 +2,8 @@
 
 export { Roark as default } from './client';
 
-export { type Uploadable, toFile } from './uploads';
-export { APIPromise } from './api-promise';
+export { type Uploadable, toFile } from './core/uploads';
+export { APIPromise } from './core/api-promise';
 export { Roark, type ClientOptions } from './client';
 export {
   RoarkError,
@@ -19,4 +19,4 @@ export {
   InternalServerError,
   PermissionDeniedError,
   UnprocessableEntityError,
-} from './error';
+} from './core/error';

package/src/internal/README.md

@@ -0,0 +1,3 @@
+# `internal`
+
+The modules in this directory are not importable outside this package and will change between releases.

package/src/internal/builtin-types.ts

@@ -39,9 +39,23 @@ type _HeadersInit = RequestInit['headers'];
  */
 type _BodyInit = RequestInit['body'];
 
+/**
+ * An alias to the builtin `Array<T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Array<T> = Array<T>;
+
+/**
+ * An alias to the builtin `Record<K, T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Record<K extends keyof any, T> = Record<K, T>;
+
 export type {
+  _Array as Array,
   _BodyInit as BodyInit,
   _HeadersInit as HeadersInit,
+  _Record as Record,
   _RequestInfo as RequestInfo,
   _RequestInit as RequestInit,
   _Response as Response,

package/src/internal/detect-platform.ts

@@ -85,10 +85,10 @@ const getPlatformProperties = (): PlatformProperties => {
     return {
       'X-Stainless-Lang': 'js',
       'X-Stainless-Package-Version': VERSION,
-      'X-Stainless-OS': normalizePlatform((globalThis as any).process.platform),
-      'X-Stainless-Arch': normalizeArch((globalThis as any).process.arch),
+      'X-Stainless-OS': normalizePlatform((globalThis as any).process.platform ?? 'unknown'),
+      'X-Stainless-Arch': normalizeArch((globalThis as any).process.arch ?? 'unknown'),
       'X-Stainless-Runtime': 'node',
-      'X-Stainless-Runtime-Version': (globalThis as any).process.version,
+      'X-Stainless-Runtime-Version': (globalThis as any).process.version ?? 'unknown',
     };
   }
 

package/src/internal/errors.ts

@@ -14,6 +14,17 @@ export function isAbortError(err: unknown) {
 export const castToError = (err: any): Error => {
   if (err instanceof Error) return err;
   if (typeof err === 'object' && err !== null) {
+    try {
+      if (Object.prototype.toString.call(err) === '[object Error]') {
+        // @ts-ignore - not all envs have native support for cause yet
+        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        if (err.stack) error.stack = err.stack;
+        // @ts-ignore - not all envs have native support for cause yet
+        if (err.cause && !error.cause) error.cause = err.cause;
+        if (err.name) error.name = err.name;
+        return error;
+      }
+    } catch {}
     try {
       return new Error(JSON.stringify(err));
     } catch {}

package/src/internal/headers.ts

@@ -1,15 +1,17 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+import { isReadonlyArray } from './utils/values';
+
 type HeaderValue = string | undefined | null;
 export type HeadersLike =
   | Headers
-  | readonly [string, HeaderValue][]
+  | readonly HeaderValue[][]
   | Record<string, HeaderValue | readonly HeaderValue[]>
   | undefined
   | null
   | NullableHeaders;
 
-const brand_privateNullableHeaders = Symbol('brand.privateNullableHeaders');
+const brand_privateNullableHeaders = /* @__PURE__ */ Symbol('brand.privateNullableHeaders');
 
 /**
  * @internal
@@ -25,8 +27,6 @@ export type NullableHeaders = {
   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;
 
@@ -40,10 +40,10 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
 
   let shouldClear = false;
-  let iter: Iterable<readonly [string, HeaderValue | readonly HeaderValue[]]>;
+  let iter: Iterable<readonly (HeaderValue | readonly HeaderValue[])[]>;
   if (headers instanceof Headers) {
     iter = headers.entries();
-  } else if (isArray(headers)) {
+  } else if (isReadonlyArray(headers)) {
     iter = headers;
   } else {
     shouldClear = true;
@@ -51,7 +51,8 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
   for (let row of iter) {
     const name = row[0];
-    const values = isArray(row[1]) ? row[1] : [row[1]];
+    if (typeof name !== 'string') throw new TypeError('expected header name to be a string');
+    const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
     let didClear = false;
     for (const value of values) {
       if (value === undefined) continue;
@@ -70,8 +71,8 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
 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) {
+    const seenHeaders = new Set<string>();
     for (const [name, value] of iterateHeaders(headers)) {
       const lowerName = name.toLowerCase();
       if (!seenHeaders.has(lowerName)) {

package/src/internal/parse.ts

@@ -2,40 +2,55 @@
 
 import type { FinalRequestOptions } from './request-options';
 import { type Roark } from '../client';
-import { logger } from './utils/log';
+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: 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;
+  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 contentLength = response.headers.get('content-length');
+      if (contentLength === '0') {
+        // if there is no content we can't do anything
+        return undefined as T;
+      }
+
+      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/qs/formats.ts

@@ -1,9 +1,10 @@
 import type { Format } from './types';
 
 export const default_format: Format = 'RFC3986';
+export const default_formatter = (v: PropertyKey) => String(v);
 export const formatters: Record<Format, (str: PropertyKey) => string> = {
   RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
-  RFC3986: (v: PropertyKey) => String(v),
+  RFC3986: default_formatter,
 };
 export const RFC1738 = 'RFC1738';
 export const RFC3986 = 'RFC3986';

package/src/internal/qs/stringify.ts

@@ -1,8 +1,7 @@
-import { encode, is_buffer, maybe_map } from './utils';
-import { default_format, formatters } from './formats';
+import { encode, is_buffer, maybe_map, has } from './utils';
+import { default_format, default_formatter, formatters } from './formats';
 import type { NonNullableProperties, StringifyOptions } from './types';
-
-const has = Object.prototype.hasOwnProperty;
+import { isArray } from '../utils/values';
 
 const array_prefix_generators = {
   brackets(prefix: PropertyKey) {
@@ -17,13 +16,11 @@ const array_prefix_generators = {
   },
 };
 
-const is_array = Array.isArray;
-const push = Array.prototype.push;
 const push_to_array = function (arr: any[], value_or_array: any) {
-  push.apply(arr, is_array(value_or_array) ? value_or_array : [value_or_array]);
+  Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]);
 };
 
-const to_ISO = Date.prototype.toISOString;
+let toISOString;
 
 const defaults = {
   addQueryPrefix: false,
@@ -38,11 +35,11 @@ const defaults = {
   encoder: encode,
   encodeValuesOnly: false,
   format: default_format,
-  formatter: formatters[default_format],
+  formatter: default_formatter,
   /** @deprecated */
   indices: false,
   serializeDate(date) {
-    return to_ISO.call(date);
+    return (toISOString ??= Function.prototype.call.bind(Date.prototype.toISOString))(date);
   },
   skipNulls: false,
   strictNullHandling: false,
@@ -105,7 +102,7 @@ function inner_stringify(
     obj = filter(prefix, obj);
   } else if (obj instanceof Date) {
     obj = serializeDate?.(obj);
-  } else if (generateArrayPrefix === 'comma' && is_array(obj)) {
+  } else if (generateArrayPrefix === 'comma' && isArray(obj)) {
     obj = maybe_map(obj, function (value) {
       if (value instanceof Date) {
         return serializeDate?.(value);
@@ -148,14 +145,14 @@ function inner_stringify(
   }
 
   let obj_keys;
-  if (generateArrayPrefix === 'comma' && is_array(obj)) {
+  if (generateArrayPrefix === 'comma' && isArray(obj)) {
     // we need to join elements in
     if (encodeValuesOnly && encoder) {
       // @ts-expect-error values only
       obj = maybe_map(obj, encoder);
     }
     obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
-  } else if (is_array(filter)) {
+  } else if (isArray(filter)) {
     obj_keys = filter;
   } else {
     const keys = Object.keys(obj);
@@ -165,9 +162,9 @@ function inner_stringify(
   const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
 
   const adjusted_prefix =
-    commaRoundTrip && is_array(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+    commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
 
-  if (allowEmptyArrays && is_array(obj) && obj.length === 0) {
+  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
     return adjusted_prefix + '[]';
   }
 
@@ -184,7 +181,7 @@ function inner_stringify(
     // @ts-ignore
     const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
     const key_prefix =
-      is_array(obj) ?
+      isArray(obj) ?
         typeof generateArrayPrefix === 'function' ?
           generateArrayPrefix(adjusted_prefix, encoded_key)
         : adjusted_prefix
@@ -205,7 +202,7 @@ function inner_stringify(
         skipNulls,
         encodeDotInKeys,
         // @ts-ignore
-        generateArrayPrefix === 'comma' && encodeValuesOnly && is_array(obj) ? null : encoder,
+        generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,
         filter,
         sort,
         allowDots,
@@ -244,7 +241,7 @@ function normalize_stringify_options(
 
   let format = default_format;
   if (typeof opts.format !== 'undefined') {
-    if (!has.call(formatters, opts.format)) {
+    if (!has(formatters, opts.format)) {
       throw new TypeError('Unknown format option provided.');
     }
     format = opts.format;
@@ -252,7 +249,7 @@ function normalize_stringify_options(
   const formatter = formatters[format];
 
   let filter = defaults.filter;
-  if (typeof opts.filter === 'function' || is_array(opts.filter)) {
+  if (typeof opts.filter === 'function' || isArray(opts.filter)) {
     filter = opts.filter;
   }
 
@@ -316,7 +313,7 @@ export function stringify(object: any, opts: StringifyOptions = {}) {
   if (typeof options.filter === 'function') {
     filter = options.filter;
     obj = filter('', obj);
-  } else if (is_array(options.filter)) {
+  } else if (isArray(options.filter)) {
     filter = options.filter;
     obj_keys = filter;
   }