accessio 1.1.1 → 1.2.0

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(
@@ -75,7 +75,22 @@ export default function buildURL(
 ): string {
   let fullURL = baseURL && !isAbsoluteURL(url) ? combineURLs(baseURL, url) : url || '';
 
-  const serialized = serializeParams(params as Record<string, unknown>, paramsSerializer);
+  let finalParams = params;
+  if (params && typeof params === 'object') {
+    const unusedParams = { ...params };
+    fullURL = fullURL.replace(/(?::([a-zA-Z0-9_]+))|(?:{([a-zA-Z0-9_]+)})/g, (match, p1, p2) => {
+      const key = p1 || p2;
+      if (key && unusedParams[key] !== undefined) {
+        const val = unusedParams[key];
+        delete unusedParams[key];
+        return encodeURIComponent(String(val));
+      }
+      return match;
+    });
+    finalParams = unusedParams;
+  }
+
+  const serialized = serializeParams(finalParams as Record<string, unknown>, paramsSerializer);
   if (serialized) {
     const hashIndex = fullURL.indexOf('#');
     if (hashIndex !== -1) {

package/src/core/fetchAdapter.ts

@@ -0,0 +1,227 @@
+import AccessioError from './accessioError';
+import parseHeaders from '../helpers/parseHeaders';
+import type { AccessioRequestConfig, AccessioResponse } from '../types';
+
+async function readResponseData(
+  fetchResponse: Response,
+  config: AccessioRequestConfig,
+): Promise<unknown> {
+  const responseType = config.responseType || 'json';
+  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 fetchImpl = config.fetch || fetch;
+    let fetchResponse = await fetchImpl(fullURL, fetchOptions);
+
+    if (config.onDownloadProgress && fetchResponse.body && config.responseType !== 'stream') {
+      const contentLength = fetchResponse.headers.get('content-length');
+      const total = contentLength ? parseInt(contentLength, 10) : 0;
+      let loaded = 0;
+
+      const reader = fetchResponse.body.getReader();
+      const stream = new ReadableStream({
+        async start(controller) {
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                controller.close();
+                break;
+              }
+              loaded += value.byteLength;
+              config.onDownloadProgress!({ loaded, total });
+              controller.enqueue(value);
+            }
+          } catch (e) {
+            controller.error(e);
+          }
+        },
+      });
+
+      fetchResponse = new Response(stream, {
+        headers: fetchResponse.headers,
+        status: fetchResponse.status,
+        statusText: fetchResponse.statusText,
+      });
+    }
+
+    let responseData: unknown;
+
+    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, config);
+      if (config.schema) {
+        if (typeof config.schema.parseAsync === 'function') {
+          responseData = await config.schema.parseAsync(responseData);
+        } else {
+          responseData = config.schema.parse(responseData);
+        }
+      }
+    } 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,14 @@
 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 { defaultMemoryCache } from '../helpers/memoryCache';
 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 +18,11 @@ 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}`;
+const activeRequests = new Map<string, Promise<AccessioResponse>>();
 
-  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(
@@ -104,197 +32,119 @@ export default function dispatchRequest(config: AccessioRequestConfig): Promise<
       config.paramsSerializer,
     );
 
-  const flatHeaders = flattenHeaders(config.headers as HeadersConfig | undefined, config.method);
-
-  const requestTransforms = buildTransformArray(config.transformRequest);
-
-  const requestData = transformData(requestTransforms, config.data, flatHeaders, config);
-
-  if (
-    requestData === null ||
-    requestData === undefined ||
-    (typeof FormData !== 'undefined' && requestData instanceof FormData)
-  ) {
-    removeContentType(flatHeaders);
+  if (config.hooks?.onBeforeRequest) {
+    await config.hooks.onBeforeRequest(config);
   }
 
-  setBasicAuth(config, flatHeaders);
-
-  const fetchOptions: RequestInit = {
-    method: (config.method || 'GET').toUpperCase(),
-    headers: flatHeaders,
-  };
+  const isGet = (config.method || 'GET').toUpperCase() === 'GET';
+  const cacheKey = isGet ? `GET:${fullURL}` : '';
 
-  const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
-  if (
-    methodsWithBody.includes(fetchOptions.method!) &&
-    requestData !== undefined &&
-    requestData !== null
-  ) {
-    fetchOptions.body = requestData as BodyInit;
+  if (isGet && config.cache) {
+    const cacheProvider = typeof config.cache === 'object' ? config.cache : defaultMemoryCache;
+    const cached = await cacheProvider.get(cacheKey);
+    if (cached) {
+      if (config.hooks?.onRequestResponse) {
+        await config.hooks.onRequestResponse(cached);
+      }
+      return cached;
+    }
   }
 
-  if (config.withCredentials) {
-    fetchOptions.credentials = 'include';
+  if (isGet && config.dedupe) {
+    if (activeRequests.has(cacheKey)) {
+      return activeRequests.get(cacheKey)!;
+    }
   }
 
-  if (config.dispatcher) {
-    (fetchOptions as any).dispatcher = config.dispatcher;
-  }
-  if (config.agent) {
-    (fetchOptions as any).agent = config.agent;
-  }
+  const performRequest = async () => {
+    const flatHeaders = flattenHeaders(config.headers as HeadersConfig | undefined, config.method);
+    const requestTransforms = buildTransformArray(config.transformRequest);
+    const requestData = await transformData(requestTransforms, config.data, flatHeaders, config);
+
+    if (
+      requestData === null ||
+      requestData === undefined ||
+      (typeof FormData !== 'undefined' && requestData instanceof FormData)
+    ) {
+      removeContentType(flatHeaders);
+    }
 
-  let abortController: AbortController | null = null;
-  let timeoutId: ReturnType<typeof setTimeout> | null = null;
-  let isTimedOut = false;
-  let onUserAbort: (() => void) | null = null;
+    setBasicAuth(config, flatHeaders);
 
-  const timeoutValue = Number(config.timeout);
-  if (!isNaN(timeoutValue) && timeoutValue > 0) {
-    abortController = new AbortController();
+    const fetchOptions: RequestInit = {
+      method: (config.method || 'GET').toUpperCase(),
+      headers: buildFetchHeaders(flatHeaders),
+    };
 
-    timeoutId = setTimeout(() => {
-      isTimedOut = true;
-      abortController!.abort(
-        new AccessioError(
-          `timeout of ${timeoutValue}ms exceeded`,
-          AccessioError.ETIMEDOUT,
-          config,
-          null,
-          null,
-        ),
-      );
-    }, timeoutValue);
+    const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
+    if (
+      methodsWithBody.includes(fetchOptions.method!) &&
+      requestData !== undefined &&
+      requestData !== null
+    ) {
+      fetchOptions.body = requestData as BodyInit;
+    }
 
-    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;
+    if (config.withCredentials) {
+      fetchOptions.credentials = 'include';
     }
-  } else if (config.signal) {
-    fetchOptions.signal = config.signal;
-  }
 
-  const requestStartTime = Date.now();
+    if (config.dispatcher) {
+      (fetchOptions as any).dispatcher = config.dispatcher;
+    }
+    if (config.agent) {
+      (fetchOptions as any).agent = config.agent;
+    }
 
-  return fetch(fullURL, fetchOptions)
-    .then(async (fetchResponse) => {
-      let responseData: unknown;
-      const responseType = config.responseType || 'json';
+    const requestStartTime = Date.now();
 
-      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 response = await fetchAdapter(config, fullURL, fetchOptions, requestStartTime);
 
-      try {
-        responseData = await readResponseData(fetchResponse, responseType);
-      } catch (readError) {
-        throw AccessioError.from(
-          readError as Error,
-          AccessioError.ERR_BAD_RESPONSE,
-          config,
-          fetchResponse,
-          null,
-        );
-      }
+    const responseTransforms = buildTransformArray(config.transformResponse);
 
-      const responseHeaders = parseHeaders(fetchResponse.headers);
+    response.data = await transformData(
+      responseTransforms,
+      response.data,
+      response.headers,
+      config,
+    );
 
-      const responseTransforms = buildTransformArray(config.transformResponse);
+    return new Promise<AccessioResponse>((resolve, reject) => {
+      settle(
+        resolve as (value: AccessioResponse) => void,
+        reject as (reason: AccessioError) => void,
+        response,
+        config,
+      );
+    });
+  };
 
-      responseData = transformData(responseTransforms, responseData, responseHeaders, config);
+  const promise = performRequest();
 
-      const response: AccessioResponse = {
-        data: responseData,
-        status: fetchResponse.status,
-        statusText: fetchResponse.statusText,
-        headers: responseHeaders,
-        config: config,
-        request: fetchResponse,
-        duration: Date.now() - requestStartTime,
-      };
+  if (isGet && config.dedupe) {
+    activeRequests.set(cacheKey, promise);
+    promise.finally(() => {
+      activeRequests.delete(cacheKey);
+    });
+  }
 
-      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;
-      }
+  try {
+    const response = await promise;
 
-      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 (isGet && config.cache) {
+      const cacheProvider = typeof config.cache === 'object' ? config.cache : defaultMemoryCache;
+      await cacheProvider.set(cacheKey, response, config.cacheTTL);
+    }
 
-      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,
-        );
-      }
+    if (config.hooks?.onRequestResponse) {
+      await config.hooks.onRequestResponse(response);
+    }
 
-      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 response;
+  } catch (error) {
+    if (config.hooks?.onRequestError && error instanceof AccessioError) {
+      await config.hooks.onRequestError(error);
+    }
+    throw error;
+  }
 }