accessio 1.0.0 → 1.1.1

package/src/core/request.ts

@@ -36,10 +36,7 @@ function flattenHeaders(
   }
 
   for (const key in headers) {
-    if (
-      Object.prototype.hasOwnProperty.call(headers, key) &&
-      !METHOD_KEYS.has(key)
-    ) {
+    if (Object.prototype.hasOwnProperty.call(headers, key) && !METHOD_KEYS.has(key)) {
       merged[key] = headers[key] as unknown as string;
     }
   }
@@ -48,10 +45,8 @@ function flattenHeaders(
 }
 
 function removeContentType(headers: Record<string, string>): void {
-  const key = Object.keys(headers).find(
-    (k) => k.toLowerCase() === 'content-type',
-  );
-  if (key) {
+  const keys = Object.keys(headers).filter((k) => k.toLowerCase() === 'content-type');
+  for (const key of keys) {
     delete headers[key];
   }
 }
@@ -64,9 +59,42 @@ function buildTransformArray(
   return [transform];
 }
 
-export default function dispatchRequest(
-  config: AccessioRequestConfig,
-): Promise<AccessioResponse> {
+function setBasicAuth(config: AccessioRequestConfig, headers: Record<string, string>): void {
+  if (!config.auth) return;
+  const username = config.auth.username || '';
+  const password = config.auth.password || '';
+  const credentials = `${username}:${password}`;
+
+  let encoded: string;
+  if (typeof Buffer !== 'undefined') {
+    encoded = Buffer.from(credentials).toString('base64');
+  } else {
+    encoded = btoa(
+      encodeURIComponent(credentials).replace(/%([0-9A-F]{2})/g, (match, p1) => {
+        return String.fromCharCode(parseInt(p1, 16));
+      }),
+    );
+  }
+  headers['Authorization'] = `Basic ${encoded}`;
+}
+
+async function readResponseData(fetchResponse: Response, responseType: string): Promise<unknown> {
+  switch (responseType) {
+    case 'arraybuffer':
+      return await fetchResponse.arrayBuffer();
+    case 'blob':
+      return await fetchResponse.blob();
+    case 'text':
+      return await fetchResponse.text();
+    case 'stream':
+      return fetchResponse.body;
+    case 'json':
+    default:
+      return await fetchResponse.text();
+  }
+}
+
+export default function dispatchRequest(config: AccessioRequestConfig): Promise<AccessioResponse> {
   const fullURL =
     config._builtUrl ||
     buildURL(
@@ -76,19 +104,11 @@ export default function dispatchRequest(
       config.paramsSerializer,
     );
 
-  const flatHeaders = flattenHeaders(
-    config.headers as HeadersConfig | undefined,
-    config.method,
-  );
+  const flatHeaders = flattenHeaders(config.headers as HeadersConfig | undefined, config.method);
 
   const requestTransforms = buildTransformArray(config.transformRequest);
 
-  const requestData = transformData(
-    requestTransforms,
-    config.data,
-    flatHeaders,
-    config,
-  );
+  const requestData = transformData(requestTransforms, config.data, flatHeaders, config);
 
   if (
     requestData === null ||
@@ -98,24 +118,7 @@ export default function dispatchRequest(
     removeContentType(flatHeaders);
   }
 
-  if (config.auth) {
-    const username = config.auth.username || '';
-    const password = config.auth.password || '';
-    const credentials = `${username}:${password}`;
-
-    let encoded: string;
-    if (typeof Buffer !== 'undefined') {
-      encoded = Buffer.from(credentials).toString('base64');
-    } else {
-      const bytes = new TextEncoder().encode(credentials);
-      const binString = Array.from(bytes, (x) =>
-        String.fromCodePoint(x),
-      ).join('');
-      encoded = btoa(binString);
-    }
-
-    flatHeaders['Authorization'] = `Basic ${encoded}`;
-  }
+  setBasicAuth(config, flatHeaders);
 
   const fetchOptions: RequestInit = {
     method: (config.method || 'GET').toUpperCase(),
@@ -135,39 +138,46 @@ export default function dispatchRequest(
     fetchOptions.credentials = 'include';
   }
 
+  if (config.dispatcher) {
+    (fetchOptions as any).dispatcher = config.dispatcher;
+  }
+  if (config.agent) {
+    (fetchOptions as any).agent = config.agent;
+  }
+
   let abortController: AbortController | null = null;
   let timeoutId: ReturnType<typeof setTimeout> | null = null;
   let isTimedOut = false;
   let onUserAbort: (() => void) | null = null;
 
-  if (config.timeout && config.timeout > 0) {
+  const timeoutValue = Number(config.timeout);
+  if (!isNaN(timeoutValue) && timeoutValue > 0) {
     abortController = new AbortController();
 
     timeoutId = setTimeout(() => {
       isTimedOut = true;
       abortController!.abort(
         new AccessioError(
-          `timeout of ${config.timeout}ms exceeded`,
+          `timeout of ${timeoutValue}ms exceeded`,
           AccessioError.ETIMEDOUT,
           config,
           null,
           null,
         ),
       );
-    }, config.timeout);
+    }, timeoutValue);
 
     if (config.signal) {
       if (typeof AbortSignal.any === 'function') {
-        fetchOptions.signal = AbortSignal.any([
-          config.signal,
-          abortController.signal,
-        ]);
+        fetchOptions.signal = AbortSignal.any([config.signal, abortController.signal]);
       } else {
         if (config.signal.aborted) {
           abortController.abort(config.signal.reason);
         } else {
           onUserAbort = () => {
-            abortController!.abort(config.signal!.reason);
+            if (!isTimedOut && abortController) {
+              abortController.abort(config.signal!.reason);
+            }
           };
           config.signal.addEventListener('abort', onUserAbort, {
             once: true,
@@ -189,25 +199,23 @@ export default function dispatchRequest(
       let responseData: unknown;
       const responseType = config.responseType || 'json';
 
+      const contentLength = fetchResponse.headers.get('content-length');
+      if (
+        contentLength &&
+        config.maxContentLength &&
+        parseInt(contentLength, 10) > config.maxContentLength
+      ) {
+        throw new AccessioError(
+          `maxContentLength size of ${config.maxContentLength} exceeded`,
+          AccessioError.ERR_BAD_RESPONSE,
+          config,
+          fetchResponse,
+          null,
+        );
+      }
+
       try {
-        switch (responseType) {
-          case 'arraybuffer':
-            responseData = await fetchResponse.arrayBuffer();
-            break;
-          case 'blob':
-            responseData = await fetchResponse.blob();
-            break;
-          case 'text':
-            responseData = await fetchResponse.text();
-            break;
-          case 'stream':
-            responseData = fetchResponse.body;
-            break;
-          case 'json':
-          default:
-            responseData = await fetchResponse.text();
-            break;
-        }
+        responseData = await readResponseData(fetchResponse, responseType);
       } catch (readError) {
         throw AccessioError.from(
           readError as Error,
@@ -222,12 +230,7 @@ export default function dispatchRequest(
 
       const responseTransforms = buildTransformArray(config.transformResponse);
 
-      responseData = transformData(
-        responseTransforms,
-        responseData,
-        responseHeaders,
-        config,
-      );
+      responseData = transformData(responseTransforms, responseData, responseHeaders, config);
 
       const response: AccessioResponse = {
         data: responseData,
@@ -240,7 +243,12 @@ export default function dispatchRequest(
       };
 
       return new Promise<AccessioResponse>((resolve, reject) => {
-        settle(resolve as (value: AccessioResponse) => void, reject as (reason: AccessioError) => void, response, config);
+        settle(
+          resolve as (value: AccessioResponse) => void,
+          reject as (reason: AccessioError) => void,
+          response,
+          config,
+        );
       });
     })
     .catch((error) => {
@@ -258,9 +266,17 @@ export default function dispatchRequest(
             null,
           );
         }
+        throw new AccessioError('Request aborted', AccessioError.ERR_CANCELED, config, null, null);
+      }
+
+      if (
+        error instanceof TypeError &&
+        (error.message.toLowerCase().includes('url') ||
+          error.message.toLowerCase().includes('fetch'))
+      ) {
         throw new AccessioError(
-          'Request aborted',
-          AccessioError.ERR_CANCELED,
+          `Invalid URL: ${fullURL}`,
+          AccessioError.ERR_INVALID_URL,
           config,
           null,
           null,

package/src/core/retry.ts

@@ -1,8 +1,4 @@
-import {
-  ERR_CANCELED,
-  ERR_NETWORK,
-  ETIMEDOUT,
-} from '../constants/errorCodes';
+import { ERR_CANCELED, ERR_NETWORK, ETIMEDOUT } from '../constants/errorCodes';
 import type {
   AccessioRequestConfig,
   AccessioResponse,
@@ -20,10 +16,6 @@ function defaultRetryCondition(error: any): boolean {
     return true;
   }
 
-  if (error.code === ETIMEDOUT) {
-    return true;
-  }
-
   if (error.response && error.response.status >= 500) {
     return true;
   }
@@ -51,9 +43,7 @@ function sleep(ms: number, options?: { signal?: AbortSignal }): Promise<void> {
     if (options?.signal) {
       if (options.signal.aborted) {
         clearTimeout(timeoutId);
-        return reject(
-          options.signal.reason || new Error('Sleep aborted'),
-        );
+        return reject(options.signal.reason || new Error('Sleep aborted'));
       }
 
       onAbort = () => {
@@ -77,8 +67,7 @@ async function retryRequest(
   }
 
   const retryDelay = config.retryDelay ?? 1000;
-  const retryCondition: RetryConditionFunction =
-    config.retryCondition ?? defaultRetryCondition;
+  const retryCondition: RetryConditionFunction = config.retryCondition ?? defaultRetryCondition;
 
   let lastError: any;
 
@@ -99,11 +88,7 @@ async function retryRequest(
       const delay = calculateDelay(attempt, retryDelay);
 
       if (typeof config.onRetry === 'function') {
-        (config.onRetry as OnRetryFunction)(
-          attempt + 1,
-          error as AccessioError,
-          config,
-        );
+        (config.onRetry as OnRetryFunction)(attempt + 1, error as AccessioError, config);
       }
 
       await sleep(delay, { signal: config.signal });

package/src/defaults/index.ts

@@ -24,9 +24,7 @@ const defaults: AccessioRequestConfig = {
   },
   transformRequest: [defaultTransformRequest],
   transformResponse: [defaultTransformResponse],
-  validateStatus: function defaultValidateStatus(
-    status: number,
-  ): boolean {
+  validateStatus: function defaultValidateStatus(status: number): boolean {
     return status >= 200 && status < 300;
   },
   responseType: 'json',

package/src/defaults/transforms.ts

@@ -1,7 +1,4 @@
-export function defaultTransformRequest(
-  data: unknown,
-  headers: Record<string, string>,
-): unknown {
+export function defaultTransformRequest(data: unknown, headers: Record<string, string>): unknown {
   if (data === null || data === undefined) {
     return data;
   }
@@ -26,7 +23,14 @@ export function defaultTransformRequest(
         headers['Content-Type'] = 'application/json';
       }
     }
-    return JSON.stringify(data);
+    try {
+      return JSON.stringify(data);
+    } catch (e: any) {
+      if (e instanceof TypeError && e.message.toLowerCase().includes('circular')) {
+        throw new Error('Accessio: Cannot stringify circular structure in request data');
+      }
+      throw e;
+    }
   }
 
   return data;

package/src/helpers/debug.ts

@@ -8,9 +8,11 @@ function formatBytes(bytes: number): string {
   return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${sizes[i]}`;
 }
 
-function sanitizeConfigForLog(
-  config: AccessioRequestConfig,
-): { params: Record<string, unknown> | undefined; timeout: number | undefined; retry: number | undefined } {
+function sanitizeConfigForLog(config: AccessioRequestConfig): {
+  params: Record<string, unknown> | undefined;
+  timeout: number | undefined;
+  retry: number | undefined;
+} {
   return {
     params: config.params,
     timeout: config.timeout,
@@ -18,10 +20,7 @@ function sanitizeConfigForLog(
   };
 }
 
-export function logRequest(
-  config: AccessioRequestConfig,
-  fullUrl: string,
-): void {
+export function logRequest(config: AccessioRequestConfig, fullUrl: string): void {
   if (!config.debug) return;
 
   const safe = sanitizeConfigForLog(config);
@@ -37,8 +36,7 @@ export function logRequest(
 
   if (config.data && typeof config.data === 'object') {
     const preview = JSON.stringify(config.data);
-    const truncated =
-      preview.length > 200 ? `${preview.substring(0, 200)}...` : preview;
+    const truncated = preview.length > 200 ? `${preview.substring(0, 200)}...` : preview;
     parts.push(`   Body: ${truncated}`);
   }
 
@@ -57,19 +55,11 @@ export function logResponse(response: AccessioResponse): void {
   if (!response.config || !response.config.debug) return;
   const status = response.status;
   const statusText = response.statusText || '';
-  const duration =
-    response.duration != null ? `${response.duration}ms` : '??';
-
-  const statusIcon =
-    status >= 200 && status < 300
-      ? '✅'
-      : status >= 400
-        ? '❌'
-        : '⚠️';
-
-  const parts: string[] = [
-    `🐦‍⬛ [Accessio] ← ${statusIcon} ${status} ${statusText} (${duration})`,
-  ];
+  const duration = response.duration != null ? `${response.duration}ms` : '??';
+
+  const statusIcon = status >= 200 && status < 300 ? '✅' : status >= 400 ? '❌' : '⚠️';
+
+  const parts: string[] = [`🐦‍⬛ [Accessio] ← ${statusIcon} ${status} ${statusText} (${duration})`];
 
   if (response.data) {
     try {

package/src/helpers/parseHeaders.ts

@@ -1,6 +1,4 @@
-export default function parseHeaders(
-  headers: any,
-): Record<string, string> {
+export default function parseHeaders(headers: any): Record<string, string> {
   const parsed: Record<string, string> = {};
 
   if (!headers) return parsed;

package/src/helpers/rateLimiter.ts

@@ -1,32 +1,31 @@
-import type {
-  RateLimiter,
-  AccessioRequestConfig,
-  AccessioResponse,
-} from '../types';
+import type { RateLimiter, AccessioRequestConfig, AccessioResponse } from '../types';
 
 interface QueueItem {
   resolve: () => void;
   reject: (reason: Error) => void;
 }
 
-export function createRateLimiter(maxConcurrent: number = Infinity): RateLimiter {
-  if (
-    maxConcurrent !== Infinity &&
-    (!Number.isInteger(maxConcurrent) || maxConcurrent < 1)
-  ) {
+export function createRateLimiter(
+  maxConcurrent: number = Infinity,
+  maxQueueSize: number = Infinity,
+): RateLimiter {
+  if (maxConcurrent !== Infinity && (!Number.isInteger(maxConcurrent) || maxConcurrent < 1)) {
     throw new RangeError(
       `[Accessio] maxConcurrent must be a positive integer or Infinity, got: ${maxConcurrent}`,
     );
   }
+  if (maxQueueSize !== Infinity && (!Number.isInteger(maxQueueSize) || maxQueueSize < 1)) {
+    throw new RangeError(
+      `[Accessio] maxQueueSize must be a positive integer or Infinity, got: ${maxQueueSize}`,
+    );
+  }
   let active = 0;
   let destroyed = false;
   const queue: QueueItem[] = [];
 
   function acquire(): Promise<void> {
     if (destroyed) {
-      return Promise.reject(
-        new Error('[Accessio] Rate limiter has been destroyed'),
-      );
+      return Promise.reject(new Error('[Accessio] Rate limiter has been destroyed'));
     }
 
     if (active < maxConcurrent) {
@@ -34,6 +33,12 @@ export function createRateLimiter(maxConcurrent: number = Infinity): RateLimiter
       return Promise.resolve();
     }
 
+    if (queue.length >= maxQueueSize) {
+      return Promise.reject(
+        new Error(`[Accessio] Rate limiter queue size exceeded maxQueueSize (${maxQueueSize})`),
+      );
+    }
+
     return new Promise((resolve, reject) => {
       queue.push({ resolve, reject });
     });
@@ -55,9 +60,7 @@ export function createRateLimiter(maxConcurrent: number = Infinity): RateLimiter
 
   function destroy(): void {
     destroyed = true;
-    const reason = new Error(
-      '[Accessio] Rate limiter destroyed — pending request cancelled',
-    );
+    const reason = new Error('[Accessio] Rate limiter destroyed — pending request cancelled');
     while (queue.length > 0) {
       const next = queue.shift();
       next?.reject(reason);

package/src/helpers/transformData.ts

@@ -1,8 +1,5 @@
 import AccessioError from '../core/accessioError';
-import type {
-  TransformFunction,
-  AccessioRequestConfig,
-} from '../types';
+import type { TransformFunction, AccessioRequestConfig } from '../types';
 
 export default function transformData(
   transforms: TransformFunction | TransformFunction[] | undefined,

package/src/index.ts

@@ -46,23 +46,15 @@ function createInstance(defaultConfig: AccessioRequestConfig) {
   instance.all = function all(promises: any[]): Promise<any[]> {
     return Promise.all(promises);
   };
-  instance.spread = function spread<T>(
-    callback: (...args: any[]) => T,
-  ): (arr: any[]) => T {
+  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
-    );
+    return !!(value && value.isAccessioError && value.code === ERR_CANCELED);
   };
-  instance.isAccessioError = function isAccessioError(
-    value: any,
-  ): boolean {
+  instance.isAccessioError = function isAccessioError(value: any): boolean {
     return (
       value instanceof AccessioError ||
       !!(value && typeof value === 'object' && value.isAccessioError === true)

package/src/interceptors/interceptorManager.ts

@@ -1,5 +1,53 @@
-import { InterceptorManager } from '../types';
+import type { TransformFunction, InterceptorHandler, InterceptorOptions } from '../types';
 
-export { InterceptorManager };
+export class InterceptorManager {
+  handlers: Array<InterceptorHandler | null>;
+  private _activeCount: number;
+
+  constructor() {
+    this.handlers = [];
+    this._activeCount = 0;
+  }
+
+  use(
+    fulfilled: TransformFunction | null,
+    rejected?: ((error: unknown) => unknown) | null,
+    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 default InterceptorManager;

package/src/types.ts

@@ -1,18 +1,8 @@
-export type Method =
-  | 'get'
-  | 'delete'
-  | 'head'
-  | 'options'
-  | 'post'
-  | 'put'
-  | 'patch';
+import type InterceptorManager from './interceptors/interceptorManager';
 
-export type ResponseType =
-  | 'json'
-  | 'text'
-  | 'blob'
-  | 'arraybuffer'
-  | 'stream';
+export type Method = 'get' | 'delete' | 'head' | 'options' | 'post' | 'put' | 'patch';
+
+export type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
 
 export interface AuthConfig {
   username: string;
@@ -21,10 +11,7 @@ export interface AuthConfig {
 
 export type ParamsSerializer = (params: Record<string, unknown>) => string;
 
-export type TransformFunction = (
-  data: unknown,
-  headers: Record<string, string>,
-) => unknown;
+export type TransformFunction = (data: unknown, headers: Record<string, string>) => unknown;
 
 export type RetryConditionFunction = (error: AccessioError) => boolean;
 
@@ -76,6 +63,9 @@ export interface AccessioRequestConfig {
   debug?: boolean;
   rateLimiter?: RateLimiter;
   _builtUrl?: string;
+  maxContentLength?: number;
+  dispatcher?: unknown;
+  agent?: unknown;
 }
 
 export interface AccessioResponse<T = unknown> {
@@ -99,56 +89,6 @@ export interface AccessioError extends 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;