increase 0.2.0 → 0.4.0

package/error.ts

@@ -0,0 +1,505 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { castToError, Headers } from '~/core';
+
+export class APIError extends Error {
+  readonly status: number | undefined;
+  readonly headers: Headers | undefined;
+  readonly error: Object | undefined;
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    super(message || (error as any)?.message || 'Unknown error occurred.');
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    if (!status) {
+      return new APIConnectionError({ cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    const type = error?.['type'];
+
+    if (type === 'invalid_parameters_error') {
+      return new InvalidParametersError(status, error, message, headers);
+    }
+
+    if (type === 'malformed_request_error') {
+      return new MalformedRequestError(status, error, message, headers);
+    }
+
+    if (type === 'invalid_api_key_error') {
+      return new InvalidAPIKeyError(status, error, message, headers);
+    }
+
+    if (type === 'environment_mismatch_error') {
+      return new EnvironmentMismatchError(status, error, message, headers);
+    }
+
+    if (type === 'insufficient_permissions_error') {
+      return new InsufficientPermissionsError(status, error, message, headers);
+    }
+
+    if (type === 'private_feature_error') {
+      return new PrivateFeatureError(status, error, message, headers);
+    }
+
+    if (type === 'api_method_not_found_error') {
+      return new APIMethodNotFoundError(status, error, message, headers);
+    }
+
+    if (type === 'object_not_found_error') {
+      return new ObjectNotFoundError(status, error, message, headers);
+    }
+
+    if (type === 'idempotency_conflict_error') {
+      return new IdempotencyConflictError(status, error, message, headers);
+    }
+
+    if (type === 'invalid_operation_error') {
+      return new InvalidOperationError(status, error, message, headers);
+    }
+
+    if (type === 'idempotency_unprocessable_error') {
+      return new IdempotencyUnprocessableError(status, error, message, headers);
+    }
+
+    if (type === 'rate_limited_error') {
+      return new RateLimitedError(status, error, message, headers);
+    }
+
+    if (type === 'internal_server_error') {
+      return new InternalServerError(status, error, message, headers);
+    }
+    if (status === 500) {
+      return new InternalServerError(
+        status,
+        { type: 'internal_server_error', title: '', detail: null, status: 500 },
+        message,
+        headers,
+      );
+    }
+
+    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);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIConnectionError extends APIError {
+  override readonly status: undefined = undefined;
+
+  constructor({ message, cause }: { message?: string; 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() {
+    super({ message: 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError {
+  override readonly status: 400 = 400;
+}
+
+export class AuthenticationError extends APIError {
+  override readonly status: 401 = 401;
+}
+
+export class PermissionDeniedError extends APIError {
+  override readonly status: 403 = 403;
+}
+
+export class NotFoundError extends APIError {
+  override readonly status: 404 = 404;
+}
+
+export class ConflictError extends APIError {
+  override readonly status: 409 = 409;
+}
+
+export class UnprocessableEntityError extends APIError {
+  override readonly status: 422 = 422;
+}
+
+export class RateLimitError extends APIError {
+  override readonly status: 429 = 429;
+}
+
+export class InvalidParametersError extends BadRequestError {
+  detail: string | null;
+
+  /**
+   * All errors related to parsing the request parameters.
+   */
+  errors: Array<unknown>;
+
+  override status: 400;
+
+  title: string;
+
+  type: 'invalid_parameters_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+    this.errors = data?.['errors'];
+  }
+}
+
+export class MalformedRequestError extends BadRequestError {
+  detail: string | null;
+
+  override status: 400;
+
+  title: string;
+
+  type: 'malformed_request_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class InvalidAPIKeyError extends AuthenticationError {
+  detail: string | null;
+
+  override status: 401;
+
+  title: string;
+
+  type: 'invalid_api_key_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class EnvironmentMismatchError extends PermissionDeniedError {
+  detail: string | null;
+
+  override status: 403;
+
+  title: string;
+
+  type: 'environment_mismatch_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class InsufficientPermissionsError extends PermissionDeniedError {
+  detail: string | null;
+
+  override status: 403;
+
+  title: string;
+
+  type: 'insufficient_permissions_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class PrivateFeatureError extends PermissionDeniedError {
+  detail: string | null;
+
+  override status: 403;
+
+  title: string;
+
+  type: 'private_feature_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class APIMethodNotFoundError extends NotFoundError {
+  detail: string | null;
+
+  override status: 404;
+
+  title: string;
+
+  type: 'api_method_not_found_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class ObjectNotFoundError extends NotFoundError {
+  detail: string | null;
+
+  override status: 404;
+
+  title: string;
+
+  type: 'object_not_found_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class IdempotencyConflictError extends ConflictError {
+  detail: string | null;
+
+  override status: 409;
+
+  title: string;
+
+  type: 'idempotency_conflict_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class InvalidOperationError extends ConflictError {
+  detail: string | null;
+
+  override status: 409;
+
+  title: string;
+
+  type: 'invalid_operation_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class IdempotencyUnprocessableError extends UnprocessableEntityError {
+  detail: string | null;
+
+  override status: 422;
+
+  title: string;
+
+  type: 'idempotency_unprocessable_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class RateLimitedError extends RateLimitError {
+  detail: string | null;
+
+  override status: 429;
+
+  title: string;
+
+  type: 'rate_limited_error';
+
+  retry_after?: number | null;
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+    this.retry_after = data?.['retry_after'];
+  }
+}
+
+export class InternalServerError extends APIError {
+  detail: string | null;
+
+  override status: 500;
+
+  title: string;
+
+  type: 'internal_server_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}

package/examples/api-error.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env yarn tsn -T
+
+import Increase, { InvalidAPIKeyError } from 'increase';
+
+const client = new Increase({ apiKey: 'invalid API key' });
+
+async function main() {
+  try {
+    await client.accounts.retrieve('<account id>');
+  } catch (err) {
+    if (err instanceof InvalidAPIKeyError) {
+      console.log(`Caught InvalidAPIKeyError`);
+    } else {
+      console.log(`Caught unknown error`);
+    }
+
+    console.log(err);
+  }
+}
+
+main().catch(console.error);

package/fetch-polyfill.ts

@@ -25,8 +25,8 @@ if (isProbablyNode) {
     const KeepAliveHttpAgent: typeof KeepAliveAgent = require('agentkeepalive');
     /* eslint-enable @typescript-eslint/no-var-requires */
 
-    defaultHttpAgent = new KeepAliveHttpAgent({ keepAlive: true });
-    defaultHttpsAgent = new KeepAliveHttpAgent.HttpsAgent({ keepAlive: true });
+    defaultHttpAgent = new KeepAliveHttpAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+    defaultHttpsAgent = new KeepAliveHttpAgent.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
   } catch (e) {
     // We can fall back to a built-in "fetch".
     nodeFetchImportError = e;