accessio 1.1.1 → 1.2.0

package/src/core/retry.ts

@@ -1,7 +1,6 @@
-import { ERR_CANCELED, ERR_NETWORK, ETIMEDOUT } from '../constants/errorCodes';
+import { ERR_CANCELED, ERR_NETWORK } from '../constants/errorCodes';
 import type {
   AccessioRequestConfig,
-  AccessioResponse,
   AccessioError,
   RetryConditionFunction,
   OnRetryFunction,
@@ -20,6 +19,10 @@ function defaultRetryCondition(error: any): boolean {
     return true;
   }
 
+  if (error.config?.retryOn429 && error.response && error.response.status === 429) {
+    return true;
+  }
+
   return false;
 }
 
@@ -62,7 +65,7 @@ async function retryRequest(
 ): Promise<any> {
   const maxRetries = config.retry ?? 0;
 
-  if (maxRetries <= 0) {
+  if (maxRetries <= 0 && !config.retryOn429) {
     return dispatchFn(config);
   }
 
@@ -70,22 +73,39 @@ async function retryRequest(
   const retryCondition: RetryConditionFunction = config.retryCondition ?? defaultRetryCondition;
 
   let lastError: any;
+  const actualMaxRetries = Math.max(maxRetries, config.retryOn429 ? 3 : 0);
 
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+  for (let attempt = 0; attempt <= actualMaxRetries; attempt++) {
     try {
       const response = await dispatchFn(config);
       return response;
     } catch (error) {
       lastError = error;
 
-      const isLastAttempt = attempt >= maxRetries;
+      const isLastAttempt = attempt >= actualMaxRetries;
       const shouldRetry = !isLastAttempt && retryCondition(error as AccessioError);
 
       if (!shouldRetry) {
         throw error;
       }
 
-      const delay = calculateDelay(attempt, retryDelay);
+      let delay = calculateDelay(attempt, retryDelay);
+
+      if (config.retryOn429 && (error as any).response?.status === 429) {
+        const headers = (error as any).response?.headers;
+        const retryAfterStr = headers?.['retry-after'] || headers?.['Retry-After'];
+        if (retryAfterStr) {
+          const parsed = parseInt(retryAfterStr, 10);
+          if (!isNaN(parsed)) {
+            delay = parsed * 1000;
+          } else {
+            const date = new Date(retryAfterStr);
+            if (!isNaN(date.getTime())) {
+              delay = Math.max(0, date.getTime() - Date.now());
+            }
+          }
+        }
+      }
 
       if (typeof config.onRetry === 'function') {
         (config.onRetry as OnRetryFunction)(attempt + 1, error as AccessioError, 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;
+}

package/src/helpers/memoryCache.ts

@@ -0,0 +1,30 @@
+import type { CacheProvider } from '../types';
+
+class MemoryCache implements CacheProvider {
+  private cache = new Map<string, { value: any; expiry: number | null }>();
+
+  get(key: string) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    if (item.expiry && Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item.value;
+  }
+
+  set(key: string, value: any, ttl?: number) {
+    const expiry = ttl ? Date.now() + ttl : null;
+    this.cache.set(key, { value, expiry });
+  }
+
+  delete(key: string) {
+    this.cache.delete(key);
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+}
+
+export const defaultMemoryCache = new MemoryCache();

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

package/src/helpers/toFormData.ts

@@ -0,0 +1,25 @@
+export function toFormData(obj: any, form?: FormData, namespace?: string): FormData {
+  const fd = form || new FormData();
+  let formKey: string;
+
+  if (obj === null || obj === undefined) {
+    return fd;
+  }
+
+  if (obj instanceof Date) {
+    fd.append(namespace || '', obj.toISOString());
+  } else if (typeof obj === 'object' && !(obj instanceof File) && !(obj instanceof Blob)) {
+    Object.keys(obj).forEach((key) => {
+      if (Array.isArray(obj)) {
+        formKey = namespace ? `${namespace}[${key}]` : key;
+      } else {
+        formKey = namespace ? `${namespace}.${key}` : key;
+      }
+      toFormData(obj[key], fd, formKey);
+    });
+  } else {
+    fd.append(namespace || '', obj);
+  }
+
+  return fd;
+}

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/index.ts

@@ -7,7 +7,7 @@ import InterceptorManager from './interceptors/interceptorManager';
 import { createRateLimiter } from './helpers/rateLimiter';
 import { logRequest, logResponse, logError } from './helpers/debug';
 import { ERR_CANCELED } from './constants/errorCodes';
-import type { AccessioRequestConfig, AccessioResponse } from './types';
+import type { AccessioRequestConfig } from './types';
 
 const PUBLIC_METHODS = [
   'request',
@@ -22,6 +22,9 @@ const PUBLIC_METHODS = [
   'postForm',
   'putForm',
   'patchForm',
+  'stream',
+  'autoPaginate',
+  'gql',
 ];
 
 function createInstance(defaultConfig: AccessioRequestConfig) {

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;
 
@@ -40,6 +43,24 @@ export interface Interceptors {
   response: InterceptorManager;
 }
 
+export interface AccessioHooks {
+  onBeforeRequest?: (config: AccessioRequestConfig) => void | Promise<void>;
+  onRequestResponse?: (response: AccessioResponse) => void | Promise<void>;
+  onRequestError?: (error: AccessioError) => void | Promise<void>;
+}
+
+export interface CacheProvider {
+  get: (key: string) => Promise<any> | any;
+  set: (key: string, value: any, ttl?: number) => Promise<void> | void;
+  delete: (key: string) => Promise<void> | void;
+  clear: () => Promise<void> | void;
+}
+
+export interface SchemaValidator<T = any> {
+  parse(data: unknown): T;
+  parseAsync?(data: unknown): Promise<T>;
+}
+
 export interface AccessioRequestConfig {
   url?: string;
   baseURL?: string;
@@ -47,7 +68,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;
@@ -66,13 +87,21 @@ export interface AccessioRequestConfig {
   maxContentLength?: number;
   dispatcher?: unknown;
   agent?: unknown;
+  dedupe?: boolean;
+  cache?: boolean | CacheProvider;
+  cacheTTL?: number;
+  onDownloadProgress?: (progressEvent: { loaded: number; total: number }) => void;
+  hooks?: AccessioHooks;
+  schema?: SchemaValidator;
+  fetch?: typeof fetch;
+  retryOn429?: boolean;
 }
 
 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;