accessio 1.0.0

package/src/helpers/settle.ts

@@ -0,0 +1,26 @@
+import AccessioError from '../core/accessioError';
+import type { AccessioResponse, AccessioRequestConfig } from '../types';
+
+export default function settle(
+  resolve: (value: AccessioResponse) => void,
+  reject: (reason: AccessioError) => void,
+  response: AccessioResponse,
+  config: AccessioRequestConfig,
+): void {
+  const validateStatus = config.validateStatus;
+
+  if (!response.status || !validateStatus || validateStatus(response.status)) {
+    resolve(response);
+  } else {
+    const error = new AccessioError(
+      `Request failed with status code ${response.status}`,
+      response.status >= 400 && response.status < 500
+        ? AccessioError.ERR_BAD_REQUEST
+        : AccessioError.ERR_BAD_RESPONSE,
+      config,
+      response.request,
+      response,
+    );
+    reject(error);
+  }
+}

package/src/helpers/transformData.ts

@@ -0,0 +1,36 @@
+import AccessioError from '../core/accessioError';
+import type {
+  TransformFunction,
+  AccessioRequestConfig,
+} from '../types';
+
+export default function transformData(
+  transforms: TransformFunction | TransformFunction[] | undefined,
+  data: unknown,
+  headers: Record<string, string>,
+  config?: AccessioRequestConfig,
+): unknown {
+  if (!transforms || !Array.isArray(transforms)) {
+    return data;
+  }
+
+  let result = data;
+
+  for (const transform of transforms) {
+    if (typeof transform === 'function') {
+      try {
+        result = transform(result, headers);
+      } catch (err) {
+        throw AccessioError.from(
+          err instanceof Error ? err : new Error(String(err)),
+          AccessioError.ERR_BAD_REQUEST,
+          config ?? null,
+          null,
+          null,
+        );
+      }
+    }
+  }
+
+  return result;
+}

package/src/index.ts

@@ -0,0 +1,102 @@
+import Accessio from './accessio';
+import defaults from './defaults';
+import AccessioError from './core/accessioError';
+import mergeConfig from './core/mergeConfig';
+import buildURL from './core/buildURL';
+import InterceptorManager from './interceptors/interceptorManager';
+import { createRateLimiter } from './helpers/rateLimiter';
+import { logRequest, logResponse, logError } from './helpers/debug';
+import { ERR_CANCELED } from './constants/errorCodes';
+import type { AccessioRequestConfig, AccessioResponse } from './types';
+
+const PUBLIC_METHODS = [
+  'request',
+  'getUri',
+  'get',
+  'delete',
+  'head',
+  'options',
+  'post',
+  'put',
+  'patch',
+  'postForm',
+  'putForm',
+  'patchForm',
+];
+
+function createInstance(defaultConfig: AccessioRequestConfig) {
+  const context = new Accessio(defaultConfig);
+
+  const instance: any = function accessio(
+    configOrUrl: string | AccessioRequestConfig,
+    config?: AccessioRequestConfig,
+  ) {
+    return context.request(configOrUrl, config);
+  };
+
+  for (const key of PUBLIC_METHODS) {
+    const method: any = (context as any)[key];
+    if (typeof method === 'function') {
+      instance[key] = method.bind(context);
+    }
+  }
+
+  instance.defaults = context.defaults;
+  instance.interceptors = context.interceptors;
+  instance.all = function all(promises: any[]): Promise<any[]> {
+    return Promise.all(promises);
+  };
+  instance.spread = function spread<T>(
+    callback: (...args: any[]) => T,
+  ): (arr: any[]) => T {
+    return function wrap(arr: any[]): T {
+      return callback(...arr);
+    };
+  };
+  instance.isCancel = function isCancel(value: any): boolean {
+    return !!(
+      value &&
+      value.isAccessioError &&
+      value.code === ERR_CANCELED
+    );
+  };
+  instance.isAccessioError = function isAccessioError(
+    value: any,
+  ): boolean {
+    return (
+      value instanceof AccessioError ||
+      !!(value && typeof value === 'object' && value.isAccessioError === true)
+    );
+  };
+  instance.AccessioError = AccessioError;
+  instance.Accessio = Accessio;
+  instance.mergeConfig = mergeConfig;
+  instance.buildURL = buildURL;
+  instance.InterceptorManager = InterceptorManager;
+  instance.createRateLimiter = createRateLimiter;
+
+  return instance;
+}
+
+const accessio = createInstance(defaults);
+
+function create(instanceConfig?: AccessioRequestConfig) {
+  return createInstance(mergeConfig(defaults, instanceConfig));
+}
+
+accessio.create = create;
+
+export default accessio;
+
+export {
+  Accessio,
+  AccessioError,
+  mergeConfig,
+  buildURL,
+  InterceptorManager,
+  createInstance,
+  createRateLimiter,
+  logRequest,
+  logResponse,
+  logError,
+};

package/src/interceptors/interceptorManager.ts

@@ -0,0 +1,5 @@
+import { InterceptorManager } from '../types';
+
+export { InterceptorManager };
+
+export default InterceptorManager;

package/src/types.ts

@@ -0,0 +1,159 @@
+export type Method =
+  | 'get'
+  | 'delete'
+  | 'head'
+  | 'options'
+  | 'post'
+  | 'put'
+  | 'patch';
+
+export type ResponseType =
+  | 'json'
+  | 'text'
+  | 'blob'
+  | 'arraybuffer'
+  | 'stream';
+
+export interface AuthConfig {
+  username: string;
+  password: string;
+}
+
+export type ParamsSerializer = (params: Record<string, unknown>) => string;
+
+export type TransformFunction = (
+  data: unknown,
+  headers: Record<string, string>,
+) => unknown;
+
+export type RetryConditionFunction = (error: AccessioError) => boolean;
+
+export type OnRetryFunction = (
+  attempt: number,
+  error: AccessioError,
+  config: AccessioRequestConfig,
+) => void;
+
+export type RunWhenFunction = (config: AccessioRequestConfig) => boolean;
+
+export interface InterceptorOptions {
+  synchronous?: boolean;
+  runWhen?: RunWhenFunction;
+}
+
+export interface InterceptorHandler {
+  fulfilled: TransformFunction | null;
+  rejected: ((error: unknown) => unknown) | null;
+  synchronous: boolean;
+  runWhen: RunWhenFunction | null;
+}
+
+export interface Interceptors {
+  request: InterceptorManager;
+  response: InterceptorManager;
+}
+
+export interface AccessioRequestConfig {
+  url?: string;
+  baseURL?: string;
+  method?: Method | string;
+  params?: Record<string, unknown>;
+  paramsSerializer?: ParamsSerializer;
+  data?: unknown;
+  headers?: Record<string, string> | Record<string, Record<string, string>>;
+  auth?: AuthConfig;
+  timeout?: number;
+  withCredentials?: boolean;
+  responseType?: ResponseType;
+  transformRequest?: TransformFunction | TransformFunction[];
+  transformResponse?: TransformFunction | TransformFunction[];
+  validateStatus?: ((status: number) => boolean) | null;
+  retry?: number;
+  retryDelay?: number;
+  retryCondition?: RetryConditionFunction;
+  onRetry?: OnRetryFunction;
+  signal?: AbortSignal;
+  debug?: boolean;
+  rateLimiter?: RateLimiter;
+  _builtUrl?: string;
+}
+
+export interface AccessioResponse<T = unknown> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  config: AccessioRequestConfig;
+  request: Response;
+  duration: number;
+}
+
+export interface AccessioError extends Error {
+  name: 'AccessioError';
+  code: string | null;
+  config: AccessioRequestConfig | null;
+  request: unknown;
+  response: AccessioResponse | null;
+  isAccessioError: true;
+  cause?: Error;
+  toJSON(): Record<string, unknown>;
+}
+
+export class InterceptorManager {
+  handlers: Array<InterceptorHandler | null>;
+  private _activeCount: number;
+
+  constructor() {
+    this.handlers = [];
+    this._activeCount = 0;
+  }
+
+  use(
+    fulfilled: TransformFunction,
+    rejected?: (error: unknown) => unknown,
+    options: InterceptorOptions = {},
+  ): number {
+    this.handlers.push({
+      fulfilled: fulfilled || null,
+      rejected: rejected || null,
+      synchronous: options.synchronous || false,
+      runWhen: options.runWhen || null,
+    });
+
+    this._activeCount++;
+    return this.handlers.length - 1;
+  }
+
+  eject(id: number): void {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+      this._activeCount--;
+    }
+  }
+
+  clear(): void {
+    this.handlers = [];
+    this._activeCount = 0;
+  }
+
+  forEach(fn: (handler: InterceptorHandler) => void): void {
+    for (const handler of this.handlers) {
+      if (handler !== null) {
+        fn(handler);
+      }
+    }
+  }
+
+  get size(): number {
+    return this._activeCount;
+  }
+}
+
+export interface RateLimiter {
+  acquire: () => Promise<void>;
+  release: () => void;
+  destroy: () => void;
+  pending: number;
+  active: number;
+  destroyed: boolean;
+}