accessio 1.5.0 → 1.7.0

package/src/core/request.ts

@@ -12,28 +12,35 @@ import type { AccessioRequestConfig, AccessioResponse, TransformFunction } from
 type HeadersConfig = Record<string, Record<string, string | string[]>>;
 type FlatHeaders = Record<string, string | string[]>;
 
-function lookupHeader(headers: FlatHeaders, name: string): string {
-  const target = name.toLowerCase();
-  for (const k of Object.keys(headers)) {
-    if (k.toLowerCase() === target) {
-      const v = headers[k];
-      return Array.isArray(v) ? v.join(',') : (v ?? '');
-    }
-  }
-  return '';
-}
-
 function buildCacheKey(
   config: AccessioRequestConfig,
   fullURL: string,
   flatHeaders: FlatHeaders,
 ): string {
+  if (typeof config.cacheKeySerializer === 'function') {
+    return config.cacheKeySerializer(config, fullURL, flatHeaders);
+  }
   const method = (config.method || 'GET').toUpperCase();
-  const auth = lookupHeader(flatHeaders, 'authorization');
-  const accept = lookupHeader(flatHeaders, 'accept');
   const withCreds = config.withCredentials ? '1' : '0';
   const respType = config.responseType || 'json';
-  return `${method}:${fullURL}|a=${auth}|x=${accept}|c=${withCreds}|t=${respType}`;
+
+  // Sort and serialize headers dynamically to prevent collisions,
+  // excluding environment-specific transient headers.
+  const serializedHeaders = Object.keys(flatHeaders)
+    .sort()
+    .filter(
+      (k) =>
+        !['user-agent', 'connection', 'host', 'content-length', 'accept-encoding'].includes(
+          k.toLowerCase(),
+        ),
+    )
+    .map((k) => {
+      const val = flatHeaders[k];
+      return `${k.toLowerCase()}=${Array.isArray(val) ? val.join(',') : val}`;
+    })
+    .join('&');
+
+  return `${method}:${fullURL}|h:${serializedHeaders}|c=${withCreds}|t=${respType}`;
 }
 
 function buildTransformArray(
@@ -126,8 +133,39 @@ export default async function dispatchRequest(
   if (isGet && config.dedupe) {
     const inflight = activeRequests.get(cacheKey);
     if (inflight) {
-      const shared = await inflight;
-      return finalizeResponse(shared, config);
+      try {
+        const shared = await inflight;
+        const response = finalizeResponse(shared, config);
+        const settled = await new Promise<AccessioResponse>((resolve, reject) => {
+          settle(
+            resolve as (value: AccessioResponse) => void,
+            reject as (reason: AccessioError) => void,
+            response,
+            config,
+          );
+        });
+
+        if (config.hooks?.onRequestResponse) {
+          await config.hooks.onRequestResponse(settled);
+        }
+
+        return settled;
+      } catch (error) {
+        let finalError = error;
+        if (error instanceof AccessioError) {
+          finalError = AccessioError.from(
+            error,
+            error.code || 'ERR_DEDUPE',
+            config,
+            error.request,
+            error.response,
+          );
+        }
+        if (config.hooks?.onRequestError && finalError instanceof AccessioError) {
+          await config.hooks.onRequestError(finalError);
+        }
+        throw finalError;
+      }
     }
   }
 

package/src/defaults/transforms.ts

@@ -39,7 +39,10 @@ export function defaultTransformRequest(
   return data;
 }
 
-export function defaultTransformResponse(data: unknown): unknown {
+export function defaultTransformResponse(data: unknown, headers?: any, config?: any): unknown {
+  if (config && config.responseType === 'text') {
+    return data;
+  }
   if (typeof data === 'string') {
     try {
       return JSON.parse(data);

package/src/helpers/flattenHeaders.ts

@@ -49,17 +49,31 @@ export function flattenHeaders(
   const merged: Record<string, string | string[]> = {};
   const methodLower = (method || 'get').toLowerCase();
 
+  const setHeader = (target: Record<string, string | string[]>, key: string, value: any) => {
+    const keyLower = key.toLowerCase();
+    for (const existingKey of Object.keys(target)) {
+      if (existingKey.toLowerCase() === keyLower) {
+        delete target[existingKey];
+      }
+    }
+    target[key] = value;
+  };
+
   if (headers['common']) {
-    Object.assign(merged, headers['common']);
+    Object.entries(headers['common']).forEach(([k, v]) => {
+      setHeader(merged, k, v);
+    });
   }
 
   if (headers[methodLower]) {
-    Object.assign(merged, headers[methodLower]);
+    Object.entries(headers[methodLower]).forEach(([k, v]) => {
+      setHeader(merged, k, v);
+    });
   }
 
   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[];
+      setHeader(merged, key, headers[key]);
     }
   }
 

package/src/helpers/memoryCache.ts

@@ -2,6 +2,11 @@ import type { CacheProvider } from '../types';
 
 class MemoryCache implements CacheProvider {
   private cache = new Map<string, { value: any; expiry: number | null }>();
+  private maxItems: number;
+
+  constructor(maxItems: number = 1000) {
+    this.maxItems = maxItems;
+  }
 
   get(key: string) {
     const item = this.cache.get(key);
@@ -14,7 +19,33 @@ class MemoryCache implements CacheProvider {
   }
 
   set(key: string, value: any, ttl?: number) {
-    const expiry = ttl ? Date.now() + ttl : null;
+    const now = Date.now();
+
+    if (this.cache.has(key)) {
+      const expiry = ttl ? now + ttl : null;
+      this.cache.set(key, { value, expiry });
+      return;
+    }
+
+    // Proactively evict up to 5 of the oldest items to prevent memory build-up without O(N) cost.
+    // Map entries are ordered by insertion, so the oldest are checked first.
+    let count = 0;
+    for (const [k, item] of this.cache.entries()) {
+      if (count++ >= 5) break;
+      if (item.expiry && now > item.expiry) {
+        this.cache.delete(k);
+      }
+    }
+
+    // Evict the oldest item if we are still at limit
+    if (this.cache.size >= this.maxItems) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== undefined) {
+        this.cache.delete(oldest);
+      }
+    }
+
+    const expiry = ttl ? now + ttl : null;
     this.cache.set(key, { value, expiry });
   }
 
@@ -28,3 +59,4 @@ class MemoryCache implements CacheProvider {
 }
 
 export const defaultMemoryCache = new MemoryCache();
+export { MemoryCache };

package/src/helpers/parseHeaders.ts

@@ -3,16 +3,19 @@ export default function parseHeaders(headers: any): Record<string, string | stri
 
   if (!headers) return parsed;
 
-  const addHeader = (key: string, value: string) => {
+  const addHeader = (key: string, value: string | string[]) => {
     const k = key.toLowerCase();
-    if (parsed[k]) {
-      if (Array.isArray(parsed[k])) {
-        (parsed[k] as string[]).push(value);
+    const values = Array.isArray(value) ? value : [value];
+    for (const val of values) {
+      if (parsed[k]) {
+        if (Array.isArray(parsed[k])) {
+          (parsed[k] as string[]).push(val);
+        } else {
+          parsed[k] = [parsed[k] as string, val];
+        }
       } else {
-        parsed[k] = [parsed[k] as string, value];
+        parsed[k] = val;
       }
-    } else {
-      parsed[k] = value;
     }
   };
 

package/src/helpers/transformData.ts

@@ -17,7 +17,7 @@ export default async function transformData(
   for (const transform of transforms) {
     if (typeof transform === 'function') {
       try {
-        result = await transform(result, headers);
+        result = await transform(result, headers, config);
       } catch (err) {
         throw AccessioError.from(
           err instanceof Error ? err : new Error(String(err)),

package/src/types.ts

@@ -14,6 +14,7 @@ export type ParamsSerializer = (params: Record<string, unknown>) => string;
 export type TransformFunction = (
   data: unknown,
   headers: Record<string, string | string[]>,
+  config?: any,
 ) => unknown | Promise<unknown>;
 
 export type RetryConditionFunction = (error: AccessioError) => boolean;
@@ -91,6 +92,11 @@ export interface AccessioRequestConfig {
   dedupe?: boolean;
   cache?: boolean | CacheProvider;
   cacheTTL?: number;
+  cacheKeySerializer?: (
+    config: AccessioRequestConfig,
+    fullURL: string,
+    headers: Record<string, string | string[]>,
+  ) => string;
   onDownloadProgress?: (progressEvent: { loaded: number; total: number }) => void;
   hooks?: AccessioHooks;
   schema?: SchemaValidator;