accessio 1.1.0 → 1.1.2

package/cjs/helpers/transformData.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/helpers/transformData.ts"],"sourcesContent":["import AccessioError from '../core/accessioError';\nimport type { TransformFunction, AccessioRequestConfig } from '../types';\n\nexport default function transformData(\n  transforms: TransformFunction | TransformFunction[] | undefined,\n  data: unknown,\n  headers: Record<string, string>,\n  config?: AccessioRequestConfig,\n): unknown {\n  if (!transforms || !Array.isArray(transforms)) {\n    return data;\n  }\n\n  let result = data;\n\n  for (const transform of transforms) {\n    if (typeof transform === 'function') {\n      try {\n        result = transform(result, headers);\n      } catch (err) {\n        throw AccessioError.from(\n          err instanceof Error ? err : new Error(String(err)),\n          AccessioError.ERR_BAD_REQUEST,\n          config ?? null,\n          null,\n          null,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAA0B;AAGX,SAAR,cACL,YACA,MACA,SACA,QACS;AACT,MAAI,CAAC,cAAc,CAAC,MAAM,QAAQ,UAAU,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,SAAS;AAEb,aAAW,aAAa,YAAY;AAClC,QAAI,OAAO,cAAc,YAAY;AACnC,UAAI;AACF,iBAAS,UAAU,QAAQ,OAAO;AAAA,MACpC,SAAS,KAAK;AACZ,cAAM,qBAAAA,QAAc;AAAA,UAClB,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC;AAAA,UAClD,qBAAAA,QAAc;AAAA,UACd,UAAU;AAAA,UACV;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":["AccessioError"]}
+{"version":3,"sources":["../../src/helpers/transformData.ts"],"sourcesContent":["import AccessioError from '../core/accessioError';\nimport type { TransformFunction, AccessioRequestConfig } from '../types';\n\nexport default async function transformData(\n  transforms: TransformFunction | TransformFunction[] | undefined,\n  data: unknown,\n  headers: Record<string, string | string[]>,\n  config?: AccessioRequestConfig,\n): Promise<unknown> {\n  if (!transforms || !Array.isArray(transforms)) {\n    return data;\n  }\n\n  let result = data;\n\n  for (const transform of transforms) {\n    if (typeof transform === 'function') {\n      try {\n        result = await transform(result, headers);\n      } catch (err) {\n        throw AccessioError.from(\n          err instanceof Error ? err : new Error(String(err)),\n          AccessioError.ERR_BAD_REQUEST,\n          config ?? null,\n          null,\n          null,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAA0B;AAG1B,eAAO,cACL,YACA,MACA,SACA,QACkB;AAClB,MAAI,CAAC,cAAc,CAAC,MAAM,QAAQ,UAAU,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,SAAS;AAEb,aAAW,aAAa,YAAY;AAClC,QAAI,OAAO,cAAc,YAAY;AACnC,UAAI;AACF,iBAAS,MAAM,UAAU,QAAQ,OAAO;AAAA,MAC1C,SAAS,KAAK;AACZ,cAAM,qBAAAA,QAAc;AAAA,UAClB,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC;AAAA,UAClD,qBAAAA,QAAc;AAAA,UACd,UAAU;AAAA,UACV;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":["AccessioError"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "accessio",
-  "version": "1.1.0",
-  "description": "Fast, flexible HTTP client for Node.js and browsers — simple, modular, and dependency-free",
+  "version": "1.1.2",
+  "description": "Fast, flexible HTTP client — simple, modular, and dependency-free",
   "type": "module",
   "main": "./cjs/index.cjs",
   "module": "./src/index.ts",
@@ -77,7 +77,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "test:browser": "vitest run --config vitest.browser.config.js",
+    "test:browser": "vitest run --config vitest.browser.config.ts",
     "release:npm": "gh workflow run publish-npm.yml -f publish_tag=$(git describe --tags --abbrev=0)",
     "typecheck": "tsc --noEmit"
   },

package/src/accessio.ts

@@ -52,11 +52,13 @@ export class Accessio {
 
     const requestInterceptors: any[] = [];
     const responseInterceptors: any[] = [];
+    let synchronousRequestInterceptors = true;
 
     this.interceptors.request.forEach((interceptor: InterceptorHandler) => {
       if (interceptor.runWhen && !interceptor.runWhen(mergedConfig)) {
         return;
       }
+      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
       requestInterceptors.unshift(interceptor);
     });
 
@@ -64,15 +66,51 @@ export class Accessio {
       responseInterceptors.push(interceptor);
     });
 
-    let promise: Promise<any> = Promise.resolve(mergedConfig);
-
-    for (const interceptor of requestInterceptors) {
-      promise = promise.then((value: any) => {
-        if (interceptor.fulfilled) {
-          return interceptor.fulfilled(value);
+    let promise: Promise<any>;
+
+    if (synchronousRequestInterceptors) {
+      let newConfig = mergedConfig;
+      let rejectReason: any = null;
+      let isRejected = false;
+
+      for (const interceptor of requestInterceptors) {
+        if (!isRejected) {
+          try {
+            if (interceptor.fulfilled) {
+              newConfig = interceptor.fulfilled(newConfig);
+            }
+          } catch (err) {
+            rejectReason = err;
+            isRejected = true;
+          }
+        } else {
+          if (interceptor.rejected) {
+            try {
+              newConfig = interceptor.rejected(rejectReason);
+              isRejected = false;
+            } catch (err) {
+              rejectReason = err;
+              isRejected = true;
+            }
+          }
         }
-        return value;
-      }, interceptor.rejected);
+      }
+
+      if (isRejected) {
+        promise = Promise.reject(rejectReason);
+      } else {
+        promise = Promise.resolve(newConfig);
+      }
+    } else {
+      promise = Promise.resolve(mergedConfig);
+      for (const interceptor of requestInterceptors) {
+        promise = promise.then((value: any) => {
+          if (interceptor.fulfilled) {
+            return interceptor.fulfilled(value);
+          }
+          return value;
+        }, interceptor.rejected);
+      }
     }
 
     promise = promise.then((cfg: any) => {

package/src/core/buildURL.ts

@@ -26,7 +26,7 @@ function serializeParams(
         if (typeof item === 'object' && item !== null) {
           encode(`${prefix}[${index}]`, item);
         } else {
-          encode(`${prefix}[]`, item);
+          encode(prefix, item);
         }
       });
     } else if (typeof value === 'object' && !(value instanceof Date)) {
@@ -64,7 +64,7 @@ function combineURLs(baseURL: string, relativeURL: string): string {
 }
 
 function isAbsoluteURL(url: string): boolean {
-  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+  return /^([a-z][a-z\d+\-.]*:)/i.test(url);
 }
 
 export default function buildURL(

package/src/core/fetchAdapter.ts

@@ -0,0 +1,184 @@
+import AccessioError from './accessioError';
+import parseHeaders from '../helpers/parseHeaders';
+import type { AccessioRequestConfig, AccessioResponse } from '../types';
+
+async function readResponseData(fetchResponse: Response, responseType: string): Promise<unknown> {
+  switch (responseType) {
+    case 'arraybuffer':
+      return await fetchResponse.arrayBuffer();
+    case 'blob':
+      return await fetchResponse.blob();
+    case 'stream':
+      return fetchResponse.body;
+    case 'json':
+    default: {
+      const contentType = fetchResponse.headers.get('content-type') || '';
+      if (contentType.includes('application/json')) {
+        if (typeof fetchResponse.clone === 'function') {
+          const text = await fetchResponse.clone().text();
+          return text ? await fetchResponse.json() : '';
+        } else {
+          const text = await fetchResponse.text();
+          return text ? JSON.parse(text) : '';
+        }
+      }
+      return await fetchResponse.text();
+    }
+  }
+}
+
+export default async function fetchAdapter(
+  config: AccessioRequestConfig,
+  fullURL: string,
+  fetchOptions: RequestInit,
+  requestStartTime: number,
+): Promise<AccessioResponse> {
+  let abortController: AbortController | null = null;
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+  let isTimedOut = false;
+  let onUserAbort: (() => void) | null = null;
+
+  if (
+    config.timeout !== undefined &&
+    (typeof config.timeout !== 'number' || isNaN(config.timeout) || config.timeout < 0)
+  ) {
+    throw new AccessioError(
+      `Invalid timeout value: ${config.timeout}`,
+      AccessioError.ERR_BAD_OPTION_VALUE,
+      config,
+      null,
+      null,
+    );
+  }
+
+  const timeoutValue = Number(config.timeout);
+  if (!isNaN(timeoutValue) && timeoutValue > 0) {
+    abortController = new AbortController();
+
+    timeoutId = setTimeout(() => {
+      isTimedOut = true;
+      abortController!.abort(
+        new AccessioError(
+          `timeout of ${timeoutValue}ms exceeded`,
+          AccessioError.ETIMEDOUT,
+          config,
+          null,
+          null,
+        ),
+      );
+    }, timeoutValue);
+
+    if (config.signal) {
+      if (typeof AbortSignal.any === 'function') {
+        fetchOptions.signal = AbortSignal.any([config.signal, abortController.signal]);
+      } else {
+        if (config.signal.aborted) {
+          abortController.abort(config.signal.reason);
+        } else {
+          onUserAbort = () => {
+            if (!isTimedOut && abortController) {
+              abortController.abort(config.signal!.reason);
+            }
+          };
+          config.signal.addEventListener('abort', onUserAbort, {
+            once: true,
+          });
+        }
+        fetchOptions.signal = abortController.signal;
+      }
+    } else {
+      fetchOptions.signal = abortController.signal;
+    }
+  } else if (config.signal) {
+    fetchOptions.signal = config.signal;
+  }
+
+  try {
+    const fetchResponse = await fetch(fullURL, fetchOptions);
+
+    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 {
+      responseData = await readResponseData(fetchResponse, responseType);
+    } catch (readError) {
+      throw AccessioError.from(
+        readError as Error,
+        AccessioError.ERR_BAD_RESPONSE,
+        config,
+        fetchResponse,
+        null,
+      );
+    }
+
+    const responseHeaders = parseHeaders(fetchResponse.headers);
+
+    return {
+      data: responseData,
+      status: fetchResponse.status,
+      statusText: fetchResponse.statusText,
+      headers: responseHeaders,
+      config: config,
+      request: fetchResponse,
+      duration: Date.now() - requestStartTime,
+    };
+  } catch (error) {
+    if (error instanceof AccessioError) {
+      throw error;
+    }
+
+    if (error instanceof Error && error.name === 'AbortError') {
+      if (isTimedOut) {
+        throw new AccessioError(
+          `timeout of ${config.timeout}ms exceeded`,
+          AccessioError.ETIMEDOUT,
+          config,
+          null,
+          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(
+        `Invalid URL: ${fullURL}`,
+        AccessioError.ERR_INVALID_URL,
+        config,
+        null,
+        null,
+      );
+    }
+
+    throw AccessioError.from(
+      error instanceof Error ? error : new Error(String(error)),
+      AccessioError.ERR_NETWORK,
+      config,
+      null,
+      null,
+    );
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+    if (config.signal && onUserAbort) {
+      config.signal.removeEventListener('abort', onUserAbort);
+    }
+  }
+}

package/src/core/mergeConfig.ts

@@ -1,7 +1,7 @@
 import type { AccessioRequestConfig } from '../types';
 
 function deepMerge(...sources: any[]): Record<string, any> {
-  const result: Record<string, any> = {};
+  const result: Record<string, any> = Object.create(null);
 
   for (const source of sources) {
     if (!source || typeof source !== 'object') continue;
@@ -43,7 +43,7 @@ export default function mergeConfig(
   config1: AccessioRequestConfig = {},
   config2: AccessioRequestConfig = {},
 ): AccessioRequestConfig {
-  const merged: any = {};
+  const merged: any = Object.create(null);
 
   const allKeys = new Set<string>([...Object.keys(config1), ...Object.keys(config2)]);
 

package/src/core/request.ts

@@ -1,55 +1,13 @@
 import buildURL from './buildURL';
 import AccessioError from './accessioError';
-import parseHeaders from '../helpers/parseHeaders';
 import transformData from '../helpers/transformData';
 import settle from '../helpers/settle';
+import { flattenHeaders, removeContentType, buildFetchHeaders } from '../helpers/flattenHeaders';
+import { setBasicAuth } from '../helpers/auth';
+import fetchAdapter from './fetchAdapter';
 import type { AccessioRequestConfig, AccessioResponse, TransformFunction } from '../types';
 
-const METHOD_KEYS = new Set<string>([
-  'common',
-  'delete',
-  'get',
-  'head',
-  'options',
-  'post',
-  'put',
-  'patch',
-]);
-
-type HeadersConfig = Record<string, Record<string, string>>;
-
-function flattenHeaders(
-  headers: HeadersConfig | undefined,
-  method?: string,
-): Record<string, string> {
-  if (!headers) return {};
-
-  const merged: Record<string, string> = {};
-  const methodLower = (method || 'get').toLowerCase();
-
-  if (headers['common']) {
-    Object.assign(merged, headers['common']);
-  }
-
-  if (headers[methodLower]) {
-    Object.assign(merged, headers[methodLower]);
-  }
-
-  for (const key in headers) {
-    if (Object.prototype.hasOwnProperty.call(headers, key) && !METHOD_KEYS.has(key)) {
-      merged[key] = headers[key] as unknown as string;
-    }
-  }
-
-  return merged;
-}
-
-function removeContentType(headers: Record<string, string>): void {
-  const key = Object.keys(headers).find((k) => k.toLowerCase() === 'content-type');
-  if (key) {
-    delete headers[key];
-  }
-}
+type HeadersConfig = Record<string, Record<string, string | string[]>>;
 
 function buildTransformArray(
   transform: TransformFunction | TransformFunction[] | undefined,
@@ -59,35 +17,9 @@ function buildTransformArray(
   return [transform];
 }
 
-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 {
-    const bytes = new TextEncoder().encode(credentials);
-    const binString = Array.from(bytes, (x) => String.fromCodePoint(x)).join('');
-    encoded = btoa(binString);
-  }
-  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> {
+export default async function dispatchRequest(
+  config: AccessioRequestConfig,
+): Promise<AccessioResponse> {
   const fullURL =
     config._builtUrl ||
     buildURL(
@@ -101,7 +33,7 @@ export default function dispatchRequest(config: AccessioRequestConfig): Promise<
 
   const requestTransforms = buildTransformArray(config.transformRequest);
 
-  const requestData = transformData(requestTransforms, config.data, flatHeaders, config);
+  const requestData = await transformData(requestTransforms, config.data, flatHeaders, config);
 
   if (
     requestData === null ||
@@ -115,7 +47,7 @@ export default function dispatchRequest(config: AccessioRequestConfig): Promise<
 
   const fetchOptions: RequestInit = {
     method: (config.method || 'GET').toUpperCase(),
-    headers: flatHeaders,
+    headers: buildFetchHeaders(flatHeaders),
   };
 
   const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
@@ -131,124 +63,27 @@ export default function dispatchRequest(config: AccessioRequestConfig): Promise<
     fetchOptions.credentials = 'include';
   }
 
-  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) {
-    abortController = new AbortController();
-
-    timeoutId = setTimeout(() => {
-      isTimedOut = true;
-      abortController!.abort(
-        new AccessioError(
-          `timeout of ${config.timeout}ms exceeded`,
-          AccessioError.ETIMEDOUT,
-          config,
-          null,
-          null,
-        ),
-      );
-    }, config.timeout);
-
-    if (config.signal) {
-      if (typeof AbortSignal.any === 'function') {
-        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);
-          };
-          config.signal.addEventListener('abort', onUserAbort, {
-            once: true,
-          });
-        }
-        fetchOptions.signal = abortController.signal;
-      }
-    } else {
-      fetchOptions.signal = abortController.signal;
-    }
-  } else if (config.signal) {
-    fetchOptions.signal = config.signal;
+  if (config.dispatcher) {
+    (fetchOptions as any).dispatcher = config.dispatcher;
+  }
+  if (config.agent) {
+    (fetchOptions as any).agent = config.agent;
   }
 
   const requestStartTime = Date.now();
 
-  return fetch(fullURL, fetchOptions)
-    .then(async (fetchResponse) => {
-      let responseData: unknown;
-      const responseType = config.responseType || 'json';
-
-      try {
-        responseData = await readResponseData(fetchResponse, responseType);
-      } catch (readError) {
-        throw AccessioError.from(
-          readError as Error,
-          AccessioError.ERR_BAD_RESPONSE,
-          config,
-          fetchResponse,
-          null,
-        );
-      }
-
-      const responseHeaders = parseHeaders(fetchResponse.headers);
-
-      const responseTransforms = buildTransformArray(config.transformResponse);
-
-      responseData = transformData(responseTransforms, responseData, responseHeaders, config);
-
-      const response: AccessioResponse = {
-        data: responseData,
-        status: fetchResponse.status,
-        statusText: fetchResponse.statusText,
-        headers: responseHeaders,
-        config: config,
-        request: fetchResponse,
-        duration: Date.now() - requestStartTime,
-      };
-
-      return new Promise<AccessioResponse>((resolve, reject) => {
-        settle(
-          resolve as (value: AccessioResponse) => void,
-          reject as (reason: AccessioError) => void,
-          response,
-          config,
-        );
-      });
-    })
-    .catch((error) => {
-      if (error instanceof AccessioError) {
-        throw error;
-      }
-
-      if (error instanceof Error && error.name === 'AbortError') {
-        if (isTimedOut) {
-          throw new AccessioError(
-            `timeout of ${config.timeout}ms exceeded`,
-            AccessioError.ETIMEDOUT,
-            config,
-            null,
-            null,
-          );
-        }
-        throw new AccessioError('Request aborted', AccessioError.ERR_CANCELED, config, null, null);
-      }
-
-      throw AccessioError.from(
-        error instanceof Error ? error : new Error(String(error)),
-        AccessioError.ERR_NETWORK,
-        config,
-        null,
-        null,
-      );
-    })
-    .finally(() => {
-      if (timeoutId) clearTimeout(timeoutId);
-      if (config.signal && onUserAbort) {
-        config.signal.removeEventListener('abort', onUserAbort);
-      }
-    });
+  const response = await fetchAdapter(config, fullURL, fetchOptions, requestStartTime);
+
+  const responseTransforms = buildTransformArray(config.transformResponse);
+
+  response.data = await transformData(responseTransforms, response.data, response.headers, config);
+
+  return new Promise<AccessioResponse>((resolve, reject) => {
+    settle(
+      resolve as (value: AccessioResponse) => void,
+      reject as (reason: AccessioError) => void,
+      response,
+      config,
+    );
+  });
 }

package/src/core/retry.ts

@@ -16,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;
   }

package/src/defaults/transforms.ts

@@ -1,4 +1,7 @@
-export function defaultTransformRequest(data: unknown, headers: Record<string, string>): unknown {
+export function defaultTransformRequest(
+  data: unknown,
+  headers: Record<string, string | string[]>,
+): unknown {
   if (data === null || data === undefined) {
     return data;
   }
@@ -23,7 +26,14 @@ export function defaultTransformRequest(data: unknown, headers: Record<string, s
         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/auth.ts

@@ -0,0 +1,26 @@
+import type { AccessioRequestConfig } from '../types';
+
+export function setBasicAuth(
+  config: AccessioRequestConfig,
+  headers: Record<string, 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 {
+    // Cryptic but effective UTF-8 to Base64 conversion for browsers lacking Buffer.
+    // encodeURIComponent converts non-ASCII to %XX, then we replace %XX with raw bytes
+    // before applying btoa.
+    encoded = btoa(
+      encodeURIComponent(credentials).replace(/%([0-9A-F]{2})/g, (match, p1) => {
+        return String.fromCharCode(parseInt(p1, 16));
+      }),
+    );
+  }
+  headers['Authorization'] = `Basic ${encoded}`;
+}