accessio 1.1.1 → 1.1.2

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

@@ -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) || /^([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 keys = Object.keys(headers).filter((k) => k.toLowerCase() === 'content-type');
-  for (const key of keys) {
-    delete headers[key];
-  }
-}
+type HeadersConfig = Record<string, Record<string, string | string[]>>;
 
 function buildTransformArray(
   transform: TransformFunction | TransformFunction[] | undefined,
@@ -59,42 +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 {
-    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> {
+export default async function dispatchRequest(
+  config: AccessioRequestConfig,
+): Promise<AccessioResponse> {
   const fullURL =
     config._builtUrl ||
     buildURL(
@@ -108,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 ||
@@ -122,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'];
@@ -145,156 +70,20 @@ export default function dispatchRequest(config: AccessioRequestConfig): Promise<
     (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;
-
-  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;
-  }
-
   const requestStartTime = Date.now();
 
-  return fetch(fullURL, fetchOptions)
-    .then(async (fetchResponse) => {
-      let responseData: unknown;
-      const responseType = config.responseType || 'json';
+  const response = await fetchAdapter(config, fullURL, fetchOptions, requestStartTime);
 
-      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,
-        );
-      }
+  const responseTransforms = buildTransformArray(config.transformResponse);
 
-      try {
-        responseData = await readResponseData(fetchResponse, responseType);
-      } catch (readError) {
-        throw AccessioError.from(
-          readError as Error,
-          AccessioError.ERR_BAD_RESPONSE,
-          config,
-          fetchResponse,
-          null,
-        );
-      }
+  response.data = await transformData(responseTransforms, response.data, response.headers, config);
 
-      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);
-      }
-
-      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);
-      }
-    });
+  return new Promise<AccessioResponse>((resolve, reject) => {
+    settle(
+      resolve as (value: AccessioResponse) => void,
+      reject as (reason: AccessioError) => void,
+      response,
+      config,
+    );
+  });
 }

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;
   }

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}`;
+}

package/src/helpers/flattenHeaders.ts

@@ -0,0 +1,59 @@
+const METHOD_KEYS = new Set<string>([
+  'common',
+  'delete',
+  'get',
+  'head',
+  'options',
+  'post',
+  'put',
+  'patch',
+]);
+
+type HeadersConfig = Record<string, Record<string, string | string[]>>;
+
+export function flattenHeaders(
+  headers: HeadersConfig | undefined,
+  method?: string,
+): Record<string, string | string[]> {
+  if (!headers) return {};
+
+  const merged: Record<string, 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 | string[];
+    }
+  }
+
+  return merged;
+}
+
+export function removeContentType(headers: Record<string, string | string[]>): void {
+  const keys = Object.keys(headers).filter((k) => k.toLowerCase() === 'content-type');
+  for (const key of keys) {
+    delete headers[key];
+  }
+}
+
+export function buildFetchHeaders(headers: Record<string, string | string[]>): Headers {
+  const fetchHeaders = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        fetchHeaders.append(key, v);
+      }
+    } else {
+      fetchHeaders.set(key, value);
+    }
+  }
+  return fetchHeaders;
+}