accessio 1.1.2 → 1.3.0

package/src/core/retry.ts

@@ -1,12 +1,18 @@
-import { ERR_CANCELED, ERR_NETWORK, ETIMEDOUT } from '../constants/errorCodes';
+import { ERR_BAD_OPTION, ERR_CANCELED, ERR_NETWORK } from '../constants/errorCodes';
+import AccessioErrorClass from './accessioError';
 import type {
   AccessioRequestConfig,
-  AccessioResponse,
   AccessioError,
   RetryConditionFunction,
   OnRetryFunction,
 } from '../types';
 
+function isUnretriableBody(data: unknown): boolean {
+  if (data == null) return false;
+  if (typeof ReadableStream !== 'undefined' && data instanceof ReadableStream) return true;
+  return false;
+}
+
 function defaultRetryCondition(error: any): boolean {
   if (error.code === ERR_CANCELED) {
     return false;
@@ -20,6 +26,10 @@ function defaultRetryCondition(error: any): boolean {
     return true;
   }
 
+  if (error.config?.retryOn429 && error.response && error.response.status === 429) {
+    return true;
+  }
+
   return false;
 }
 
@@ -62,7 +72,7 @@ async function retryRequest(
 ): Promise<any> {
   const maxRetries = config.retry ?? 0;
 
-  if (maxRetries <= 0) {
+  if (maxRetries <= 0 && !config.retryOn429) {
     return dispatchFn(config);
   }
 
@@ -70,22 +80,50 @@ 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);
+      if (isUnretriableBody(config.data)) {
+        throw new AccessioErrorClass(
+          'Request body is a ReadableStream and cannot be retried after consumption. ' +
+            'Buffer the stream upstream or set retry: 0 for this call.',
+          ERR_BAD_OPTION,
+          config,
+          null,
+          (error as AccessioError).response ?? null,
+        );
+      }
+
+      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/helpers/flattenHeaders.ts

@@ -1,3 +1,32 @@
+import AccessioError from '../core/accessioError';
+import { ERR_BAD_OPTION } from '../constants/errorCodes';
+
+const HEADER_FORBIDDEN_CHAR = /[\r\n\0]/;
+
+function assertSafeHeader(name: string, value: string | string[]): void {
+  if (typeof name !== 'string' || HEADER_FORBIDDEN_CHAR.test(name)) {
+    throw new AccessioError(
+      `Invalid header name "${String(name)}": CR, LF and NUL are not allowed`,
+      ERR_BAD_OPTION,
+      null,
+      null,
+      null,
+    );
+  }
+  const values = Array.isArray(value) ? value : [value];
+  for (const v of values) {
+    if (typeof v === 'string' && HEADER_FORBIDDEN_CHAR.test(v)) {
+      throw new AccessioError(
+        `Invalid value for header "${name}": CR, LF and NUL are not allowed`,
+        ERR_BAD_OPTION,
+        null,
+        null,
+        null,
+      );
+    }
+  }
+}
+
 const METHOD_KEYS = new Set<string>([
   'common',
   'delete',
@@ -47,6 +76,7 @@ export function removeContentType(headers: Record<string, string | string[]>): v
 export function buildFetchHeaders(headers: Record<string, string | string[]>): Headers {
   const fetchHeaders = new Headers();
   for (const [key, value] of Object.entries(headers)) {
+    assertSafeHeader(key, value);
     if (Array.isArray(value)) {
       for (const v of value) {
         fetchHeaders.append(key, v);

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

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

@@ -6,6 +6,7 @@ export default async function transformData(
   data: unknown,
   headers: Record<string, string | string[]>,
   config?: AccessioRequestConfig,
+  direction: 'request' | 'response' = 'request',
 ): Promise<unknown> {
   if (!transforms || !Array.isArray(transforms)) {
     return data;
@@ -20,7 +21,7 @@ export default async function transformData(
       } catch (err) {
         throw AccessioError.from(
           err instanceof Error ? err : new Error(String(err)),
-          AccessioError.ERR_BAD_REQUEST,
+          direction === 'response' ? AccessioError.ERR_BAD_RESPONSE : AccessioError.ERR_BAD_REQUEST,
           config ?? null,
           null,
           null,

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

@@ -43,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;
@@ -67,8 +85,17 @@ export interface AccessioRequestConfig {
   rateLimiter?: RateLimiter;
   _builtUrl?: string;
   maxContentLength?: number;
+  allowedProtocols?: string[] | null;
   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> {