accessio 1.1.0 → 1.1.2

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

package/src/helpers/parseHeaders.ts

@@ -1,11 +1,24 @@
-export default function parseHeaders(headers: any): Record<string, string> {
-  const parsed: Record<string, string> = {};
+export default function parseHeaders(headers: any): Record<string, string | string[]> {
+  const parsed: Record<string, string | string[]> = {};
 
   if (!headers) return parsed;
 
+  const addHeader = (key: string, value: string) => {
+    const k = key.toLowerCase();
+    if (parsed[k]) {
+      if (Array.isArray(parsed[k])) {
+        (parsed[k] as string[]).push(value);
+      } else {
+        parsed[k] = [parsed[k] as string, value];
+      }
+    } else {
+      parsed[k] = value;
+    }
+  };
+
   if (typeof headers.forEach === 'function') {
     headers.forEach((value: string, key: string) => {
-      parsed[key.toLowerCase()] = value;
+      addHeader(key, value);
     });
     return parsed;
   }
@@ -14,9 +27,9 @@ export default function parseHeaders(headers: any): Record<string, string> {
     headers.split('\n').forEach((line: string) => {
       const index = line.indexOf(':');
       if (index > 0) {
-        const key = line.substring(0, index).trim().toLowerCase();
+        const key = line.substring(0, index).trim();
         const value = line.substring(index + 1).trim();
-        parsed[key] = value;
+        addHeader(key, value);
       }
     });
     return parsed;
@@ -24,7 +37,7 @@ export default function parseHeaders(headers: any): Record<string, string> {
 
   if (typeof headers === 'object') {
     Object.keys(headers).forEach((key) => {
-      parsed[key.toLowerCase()] = headers[key];
+      addHeader(key, headers[key]);
     });
     return parsed;
   }

package/src/helpers/rateLimiter.ts

@@ -21,8 +21,9 @@ export function createRateLimiter(
   }
   let active = 0;
   let destroyed = false;
-  let headIndex = 0;
-  let tailIndex = 0;
+  let head = 0;
+  let tail = 0;
+  let pendingCount = 0;
   const queue: Record<number, QueueItem> = {};
 
   function acquire(): Promise<void> {
@@ -35,12 +36,15 @@ export function createRateLimiter(
       return Promise.resolve();
     }
 
-    if (tailIndex - headIndex >= maxQueueSize) {
-      return Promise.reject(new Error(`[Accessio] Rate limiter queue size exceeded maxQueueSize (${maxQueueSize})`));
+    if (pendingCount >= maxQueueSize) {
+      return Promise.reject(
+        new Error(`[Accessio] Rate limiter queue size exceeded maxQueueSize (${maxQueueSize})`),
+      );
     }
 
     return new Promise((resolve, reject) => {
-      queue[tailIndex++] = { resolve, reject };
+      queue[tail++] = { resolve, reject };
+      pendingCount++;
     });
   }
 
@@ -51,10 +55,12 @@ export function createRateLimiter(
 
     active--;
 
-    if (tailIndex - headIndex > 0 && active < maxConcurrent) {
+    if (pendingCount > 0 && active < maxConcurrent) {
       active++;
-      const next = queue[headIndex];
-      delete queue[headIndex++];
+      const next = queue[head];
+      delete queue[head];
+      head++;
+      pendingCount--;
       next?.resolve();
     }
   }
@@ -62,9 +68,11 @@ export function createRateLimiter(
   function destroy(): void {
     destroyed = true;
     const reason = new Error('[Accessio] Rate limiter destroyed — pending request cancelled');
-    while (tailIndex - headIndex > 0) {
-      const next = queue[headIndex];
-      delete queue[headIndex++];
+    while (pendingCount > 0) {
+      const next = queue[head];
+      delete queue[head];
+      head++;
+      pendingCount--;
       next?.reject(reason);
     }
   }
@@ -74,7 +82,7 @@ export function createRateLimiter(
     release,
     destroy,
     get pending() {
-      return tailIndex - headIndex;
+      return pendingCount;
     },
     get active() {
       return active;

package/src/helpers/transformData.ts

@@ -1,12 +1,12 @@
 import AccessioError from '../core/accessioError';
 import type { TransformFunction, AccessioRequestConfig } from '../types';
 
-export default function transformData(
+export default async function transformData(
   transforms: TransformFunction | TransformFunction[] | undefined,
   data: unknown,
-  headers: Record<string, string>,
+  headers: Record<string, string | string[]>,
   config?: AccessioRequestConfig,
-): unknown {
+): Promise<unknown> {
   if (!transforms || !Array.isArray(transforms)) {
     return data;
   }
@@ -16,7 +16,7 @@ export default function transformData(
   for (const transform of transforms) {
     if (typeof transform === 'function') {
       try {
-        result = transform(result, headers);
+        result = await transform(result, headers);
       } catch (err) {
         throw AccessioError.from(
           err instanceof Error ? err : new Error(String(err)),

package/src/types.ts

@@ -11,7 +11,10 @@ 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 | string[]>,
+) => unknown | Promise<unknown>;
 
 export type RetryConditionFunction = (error: AccessioError) => boolean;
 
@@ -47,7 +50,7 @@ export interface AccessioRequestConfig {
   params?: Record<string, unknown>;
   paramsSerializer?: ParamsSerializer;
   data?: unknown;
-  headers?: Record<string, string> | Record<string, Record<string, string>>;
+  headers?: Record<string, string | string[]> | Record<string, Record<string, string | string[]>>;
   auth?: AuthConfig;
   timeout?: number;
   withCredentials?: boolean;
@@ -63,13 +66,16 @@ export interface AccessioRequestConfig {
   debug?: boolean;
   rateLimiter?: RateLimiter;
   _builtUrl?: string;
+  maxContentLength?: number;
+  dispatcher?: unknown;
+  agent?: unknown;
 }
 
 export interface AccessioResponse<T = unknown> {
   data: T;
   status: number;
   statusText: string;
-  headers: Record<string, string>;
+  headers: Record<string, string | string[]>;
   config: AccessioRequestConfig;
   request: Response;
   duration: number;
@@ -86,8 +92,6 @@ export interface AccessioError extends Error {
   toJSON(): Record<string, unknown>;
 }
 
-
-
 export interface RateLimiter {
   acquire: () => Promise<void>;
   release: () => void;