accessio 1.1.2 → 1.2.0

package/src/core/request.ts

@@ -5,6 +5,7 @@ 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';
 
 type HeadersConfig = Record<string, Record<string, string | string[]>>;
@@ -17,6 +18,8 @@ function buildTransformArray(
   return [transform];
 }
 
+const activeRequests = new Map<string, Promise<AccessioResponse>>();
+
 export default async function dispatchRequest(
   config: AccessioRequestConfig,
 ): Promise<AccessioResponse> {
@@ -29,61 +32,119 @@ export default async function dispatchRequest(
       config.paramsSerializer,
     );
 
-  const flatHeaders = flattenHeaders(config.headers as HeadersConfig | undefined, config.method);
-
-  const requestTransforms = buildTransformArray(config.transformRequest);
+  if (config.hooks?.onBeforeRequest) {
+    await config.hooks.onBeforeRequest(config);
+  }
 
-  const requestData = await transformData(requestTransforms, config.data, flatHeaders, config);
+  const isGet = (config.method || 'GET').toUpperCase() === 'GET';
+  const cacheKey = isGet ? `GET:${fullURL}` : '';
+
+  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 (
-    requestData === null ||
-    requestData === undefined ||
-    (typeof FormData !== 'undefined' && requestData instanceof FormData)
-  ) {
-    removeContentType(flatHeaders);
+  if (isGet && config.dedupe) {
+    if (activeRequests.has(cacheKey)) {
+      return activeRequests.get(cacheKey)!;
+    }
   }
 
-  setBasicAuth(config, flatHeaders);
+  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);
+    }
+
+    setBasicAuth(config, flatHeaders);
+
+    const fetchOptions: RequestInit = {
+      method: (config.method || 'GET').toUpperCase(),
+      headers: buildFetchHeaders(flatHeaders),
+    };
+
+    const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
+    if (
+      methodsWithBody.includes(fetchOptions.method!) &&
+      requestData !== undefined &&
+      requestData !== null
+    ) {
+      fetchOptions.body = requestData as BodyInit;
+    }
+
+    if (config.withCredentials) {
+      fetchOptions.credentials = 'include';
+    }
+
+    if (config.dispatcher) {
+      (fetchOptions as any).dispatcher = config.dispatcher;
+    }
+    if (config.agent) {
+      (fetchOptions as any).agent = config.agent;
+    }
+
+    const requestStartTime = Date.now();
+
+    const response = await fetchAdapter(config, fullURL, fetchOptions, requestStartTime);
+
+    const responseTransforms = buildTransformArray(config.transformResponse);
+
+    response.data = await transformData(
+      responseTransforms,
+      response.data,
+      response.headers,
+      config,
+    );
 
-  const fetchOptions: RequestInit = {
-    method: (config.method || 'GET').toUpperCase(),
-    headers: buildFetchHeaders(flatHeaders),
+    return new Promise<AccessioResponse>((resolve, reject) => {
+      settle(
+        resolve as (value: AccessioResponse) => void,
+        reject as (reason: AccessioError) => void,
+        response,
+        config,
+      );
+    });
   };
 
-  const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
-  if (
-    methodsWithBody.includes(fetchOptions.method!) &&
-    requestData !== undefined &&
-    requestData !== null
-  ) {
-    fetchOptions.body = requestData as BodyInit;
-  }
-
-  if (config.withCredentials) {
-    fetchOptions.credentials = 'include';
-  }
+  const promise = performRequest();
 
-  if (config.dispatcher) {
-    (fetchOptions as any).dispatcher = config.dispatcher;
+  if (isGet && config.dedupe) {
+    activeRequests.set(cacheKey, promise);
+    promise.finally(() => {
+      activeRequests.delete(cacheKey);
+    });
   }
-  if (config.agent) {
-    (fetchOptions as any).agent = config.agent;
-  }
-
-  const requestStartTime = Date.now();
 
-  const response = await fetchAdapter(config, fullURL, fetchOptions, requestStartTime);
+  try {
+    const response = await promise;
 
-  const responseTransforms = buildTransformArray(config.transformResponse);
+    if (isGet && config.cache) {
+      const cacheProvider = typeof config.cache === 'object' ? config.cache : defaultMemoryCache;
+      await cacheProvider.set(cacheKey, response, config.cacheTTL);
+    }
 
-  response.data = await transformData(responseTransforms, response.data, response.headers, config);
+    if (config.hooks?.onRequestResponse) {
+      await config.hooks.onRequestResponse(response);
+    }
 
-  return new Promise<AccessioResponse>((resolve, reject) => {
-    settle(
-      resolve as (value: AccessioResponse) => void,
-      reject as (reason: AccessioError) => void,
-      response,
-      config,
-    );
-  });
+    return response;
+  } catch (error) {
+    if (config.hooks?.onRequestError && error instanceof AccessioError) {
+      await config.hooks.onRequestError(error);
+    }
+    throw error;
+  }
 }

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/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/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/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;
@@ -69,6 +87,14 @@ 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> {