1000fetches 0.2.2 → 0.3.0

package/dist/request/abort/index.d.ts

@@ -0,0 +1 @@
+export * from './abort';

package/dist/request/fetchErrors/fetchErrors.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from '../../errors';
+import { CustomFetch, ResponseType } from '../../types';
+export declare function fetchWithNetworkError(fetchImplementation: CustomFetch, url: string, requestInit: RequestInit): Promise<Response>;
+export declare function createHttpError(response: ResponseType<unknown>, cause?: Error): HttpError;

package/dist/request/fetchErrors/index.d.ts

@@ -0,0 +1 @@
+export * from './fetchErrors';

package/dist/request/middleware/index.d.ts

@@ -0,0 +1 @@
+export * from './middleware';

package/dist/request/middleware/middleware.d.ts

@@ -0,0 +1,7 @@
+import { HttpMethod, ResponseType } from '../../types';
+export declare function applyResponseMiddleware<TResponse>({ onResponseMiddleware, response, url, method, }: {
+    onResponseMiddleware?: (response: ResponseType<unknown>) => ResponseType<unknown> | Promise<ResponseType<unknown>>;
+    response: ResponseType<TResponse>;
+    url: string;
+    method: HttpMethod;
+}): Promise<ResponseType<TResponse>>;

package/dist/request/request.d.ts

@@ -0,0 +1,16 @@
+import { CustomFetch, ExtendedRequestInit, HttpMethod, RequestOptions, ResponseType, RetryOptions } from '../types';
+interface ExecuteHttpRequestWithRetryOptions {
+    fetchImplementation: CustomFetch;
+    requestInit: ExtendedRequestInit;
+    requestRetry?: RetryOptions | boolean;
+    clientRetry?: RetryOptions | boolean;
+    url: string;
+    method: HttpMethod;
+    timeout: number;
+    signal?: AbortSignal;
+    responseType?: RequestOptions['responseType'];
+    onResponseMiddleware?: (response: ResponseType<unknown>) => ResponseType<unknown> | Promise<ResponseType<unknown>>;
+    isExpectedStatus: (status: number) => boolean;
+}
+export declare function executeHttpRequestWithRetry<TResponse>({ fetchImplementation, requestInit: baseRequestInit, requestRetry, clientRetry, url, method, timeout, signal, responseType, onResponseMiddleware, isExpectedStatus, }: ExecuteHttpRequestWithRetryOptions): Promise<ResponseType<TResponse>>;
+export {};

package/dist/request/retry/index.d.ts

@@ -0,0 +1 @@
+export * from './retry';

package/dist/request/retry/retry.d.ts

@@ -0,0 +1,20 @@
+import { HttpMethod, RetryContext, RetryEvent, RetryOptions } from '../../types';
+type RetryPolicy = {
+    maxRetries: number;
+    retryDelay: number;
+    backoffFactor: number;
+    retryStatusCodes: number[];
+    retryNetworkErrors: boolean;
+    maxRetryDelay: number;
+    retryMethods: readonly HttpMethod[];
+    retryUnsafeMethods: boolean;
+    jitter: NonNullable<RetryOptions['jitter']>;
+    respectRetryAfter: boolean;
+    shouldRetry?: RetryOptions['shouldRetry'];
+    onRetry?: RetryOptions['onRetry'];
+};
+export declare function createRetryPolicy(clientRetry?: RetryOptions | boolean, requestRetry?: RetryOptions | boolean): RetryPolicy | undefined;
+export declare function shouldRetry(error: Error, retryCount: number, retryConfig: RetryPolicy | undefined, context: Pick<RetryContext, 'bodyReplayable' | 'method' | 'url'>): Promise<boolean>;
+export declare function calculateRetryDelay(attempt: number, retryConfig: RetryPolicy | undefined, error: Error): number;
+export declare function notifyRetry(retryConfig: RetryPolicy | undefined, event: RetryEvent): Promise<void>;
+export {};

package/dist/request/serialization/index.d.ts

@@ -0,0 +1 @@
+export * from './serialization';

package/dist/request/serialization/serialization.d.ts

@@ -0,0 +1,9 @@
+import { FetchOptions, RequestParamsType } from '../../types';
+export declare function mergeFetchOptions(fetchOptions: FetchOptions | undefined, aliases: Pick<RequestInit, 'cache' | 'credentials' | 'mode' | 'redirect'>): FetchOptions;
+export declare function sanitizeFetchOptions(fetchOptions: FetchOptions | undefined): FetchOptions;
+export declare function serializeQueryParams(params: RequestParamsType): string;
+export declare function serializeRequestBody(body: unknown): {
+    body: BodyInit;
+    contentType?: string;
+};
+export declare function isReplayableBody(body: BodyInit | null | undefined): boolean;

package/dist/request/url.d.ts

@@ -0,0 +1,3 @@
+export declare function constructUrl(baseUrl: string, requestUrl: string): string;
+export declare function appendQueryString(url: string, queryString: string): string;
+export declare function assertRequestUrlSupported(url: string, usesNativeFetch: boolean): void;

package/dist/response.d.ts

@@ -0,0 +1,12 @@
+import { SerializationError } from './errors';
+import { HttpMethod, ResponseType } from './types';
+type ParsedResponse<T> = ResponseType<T> & {
+    parseError?: SerializationError;
+};
+export declare function processResponse<T = unknown>(response: Response, options: {
+    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
+    method: HttpMethod;
+    url: string;
+    tolerateParseError?: boolean;
+}): Promise<ParsedResponse<T>>;
+export {};

package/dist/retry-BWvlSmME.cjs

@@ -0,0 +1,2 @@
+var t={maxRetries:3,retryDelay:300,backoffFactor:2,retryStatusCodes:[408,429,500,502,503,504],retryNetworkErrors:!0,maxRetryDelay:3e4,retryMethods:["GET","HEAD","OPTIONS","PUT","DELETE"],retryUnsafeMethods:!1,jitter:"none",respectRetryAfter:!0};function e(t){const e=t;return"HttpError"===t.name&&"number"==typeof e.status&&function(t){const e=t;return null!==e&&"object"==typeof e&&"function"==typeof e.get}(e.response?.headers)}exports.calculateRetryDelay=function(t,r,o){if(!r)return 0;const n=r.respectRetryAfter?function(t){if(!e(t))return;const r=t.response.headers.get("retry-after");if(!r)return;const o=Number(r);if(Number.isFinite(o))return Math.max(0,1e3*o);const n=Date.parse(r);if(Number.isNaN(n))return;return Math.max(0,n-Date.now())}(o):void 0;if(void 0!==n)return Math.min(n,r.maxRetryDelay);const a=r.retryDelay*Math.pow(r.backoffFactor,t);return function(t,e,r){return"function"==typeof e?Math.max(0,e(t,r)):"full"===e?Math.floor(Math.random()*t):"equal"===e?Math.floor(t/2+Math.random()*(t/2)):t}(Math.min(a,r.maxRetryDelay),r.jitter,t)},exports.createRetryPolicy=function(e,r){if(!function(t,e){return!1!==e&&(!0===t||"object"==typeof t||!0===e||"object"==typeof e)}(e,r))return;const o={...t,..."object"==typeof e?e:void 0};return!0===r?o:"object"==typeof r?{...o,...r}:o},exports.notifyRetry=async function(t,e){await(t?.onRetry?.(e))},exports.shouldRetry=async function(t,r,o,n){if(!o)return!1;const a={...n,error:t,retryCount:r};return o.shouldRetry?await o.shouldRetry(t,r,a):!(!n.bodyReplayable||!function(t,e){if(e.retryUnsafeMethods)return!0;const r=t.toUpperCase();return e.retryMethods.some(t=>t.toUpperCase()===r)}(n.method,o))&&(e(t)?o.retryStatusCodes.includes(t.status):!(!function(t){return"NetworkError"===t.name}(t)&&("TypeError"!==t.name||function(t){return t.message.includes("Invalid URL")||t.message.includes("Failed to parse URL")}(t)))&&o.retryNetworkErrors)};
+//# sourceMappingURL=retry-BWvlSmME.cjs.map

package/dist/retry-BWvlSmME.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-BWvlSmME.cjs","names":[],"sources":["../src/request/retry/retry.ts"],"sourcesContent":["import type {\n  HttpMethod,\n  RetryContext,\n  RetryEvent,\n  RetryOptions,\n} from '../../types'\n\ntype RetryPolicy = {\n  maxRetries: number\n  retryDelay: number\n  backoffFactor: number\n  retryStatusCodes: number[]\n  retryNetworkErrors: boolean\n  maxRetryDelay: number\n  retryMethods: readonly HttpMethod[]\n  retryUnsafeMethods: boolean\n  jitter: NonNullable<RetryOptions['jitter']>\n  respectRetryAfter: boolean\n  shouldRetry?: RetryOptions['shouldRetry']\n  onRetry?: RetryOptions['onRetry']\n}\n\ntype HeaderReader = {\n  get(name: string): string | null\n}\n\ntype HttpErrorLike = Error & {\n  status: number\n  response: {\n    headers: HeaderReader\n  }\n}\n\ntype HttpErrorCandidate = Error & {\n  status?: unknown\n  response?: {\n    headers?: unknown\n  }\n}\n\nconst DEFAULT_RETRY_POLICY: Omit<RetryPolicy, 'shouldRetry' | 'onRetry'> = {\n  maxRetries: 3,\n  retryDelay: 300,\n  backoffFactor: 2,\n  retryStatusCodes: [408, 429, 500, 502, 503, 504],\n  retryNetworkErrors: true,\n  maxRetryDelay: 30_000,\n  retryMethods: ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE'],\n  retryUnsafeMethods: false,\n  jitter: 'none',\n  respectRetryAfter: true,\n}\n\nfunction shouldUseRetryPolicy(\n  clientRetry?: RetryOptions | boolean,\n  requestRetry?: RetryOptions | boolean\n): boolean {\n  return (\n    requestRetry !== false &&\n    (clientRetry === true ||\n      typeof clientRetry === 'object' ||\n      requestRetry === true ||\n      typeof requestRetry === 'object')\n  )\n}\n\nexport function createRetryPolicy(\n  clientRetry?: RetryOptions | boolean,\n  requestRetry?: RetryOptions | boolean\n): RetryPolicy | undefined {\n  if (!shouldUseRetryPolicy(clientRetry, requestRetry)) {\n    return undefined\n  }\n\n  const clientRetryOptions =\n    typeof clientRetry === 'object' ? clientRetry : undefined\n  const baseRetryOptions = {\n    ...DEFAULT_RETRY_POLICY,\n    ...clientRetryOptions,\n  }\n\n  if (requestRetry === true) {\n    return baseRetryOptions\n  }\n\n  if (typeof requestRetry === 'object') {\n    return {\n      ...baseRetryOptions,\n      ...requestRetry,\n    }\n  }\n\n  return baseRetryOptions\n}\n\nexport async function shouldRetry(\n  error: Error,\n  retryCount: number,\n  retryConfig: RetryPolicy | undefined,\n  context: Pick<RetryContext, 'bodyReplayable' | 'method' | 'url'>\n): Promise<boolean> {\n  if (!retryConfig) return false\n\n  const retryContext: RetryContext = {\n    ...context,\n    error,\n    retryCount,\n  }\n\n  if (retryConfig.shouldRetry) {\n    return await retryConfig.shouldRetry(error, retryCount, retryContext)\n  }\n\n  if (\n    !context.bodyReplayable ||\n    !isRetryMethodAllowed(context.method, retryConfig)\n  ) {\n    return false\n  }\n\n  if (isHttpError(error)) {\n    return retryConfig.retryStatusCodes.includes(error.status)\n  }\n\n  if (\n    isNetworkError(error) ||\n    (error.name === 'TypeError' && !isInvalidUrlError(error))\n  ) {\n    return retryConfig.retryNetworkErrors\n  }\n\n  return false\n}\n\nexport function calculateRetryDelay(\n  attempt: number,\n  retryConfig: RetryPolicy | undefined,\n  error: Error\n): number {\n  if (!retryConfig) return 0\n\n  const retryAfterDelay = retryConfig.respectRetryAfter\n    ? getRetryAfterDelay(error)\n    : undefined\n\n  if (retryAfterDelay !== undefined) {\n    return Math.min(retryAfterDelay, retryConfig.maxRetryDelay)\n  }\n\n  const delay =\n    retryConfig.retryDelay * Math.pow(retryConfig.backoffFactor, attempt)\n\n  return applyJitter(\n    Math.min(delay, retryConfig.maxRetryDelay),\n    retryConfig.jitter,\n    attempt\n  )\n}\n\nexport async function notifyRetry(\n  retryConfig: RetryPolicy | undefined,\n  event: RetryEvent\n): Promise<void> {\n  await retryConfig?.onRetry?.(event)\n}\n\nfunction isRetryMethodAllowed(\n  method: HttpMethod,\n  retryConfig: RetryPolicy\n): boolean {\n  if (retryConfig.retryUnsafeMethods) {\n    return true\n  }\n\n  const normalizedMethod = method.toUpperCase()\n  return retryConfig.retryMethods.some(\n    retryMethod => retryMethod.toUpperCase() === normalizedMethod\n  )\n}\n\nfunction getRetryAfterDelay(error: Error): number | undefined {\n  if (!isHttpError(error)) {\n    return undefined\n  }\n\n  const retryAfter = error.response.headers.get('retry-after')\n  if (!retryAfter) {\n    return undefined\n  }\n\n  const retryAfterSeconds = Number(retryAfter)\n  if (Number.isFinite(retryAfterSeconds)) {\n    return Math.max(0, retryAfterSeconds * 1000)\n  }\n\n  const retryAfterDate = Date.parse(retryAfter)\n  if (Number.isNaN(retryAfterDate)) {\n    return undefined\n  }\n\n  return Math.max(0, retryAfterDate - Date.now())\n}\n\nfunction applyJitter(\n  delay: number,\n  jitter: RetryPolicy['jitter'],\n  attempt: number\n): number {\n  if (typeof jitter === 'function') {\n    return Math.max(0, jitter(delay, attempt))\n  }\n\n  if (jitter === 'full') {\n    return Math.floor(Math.random() * delay)\n  }\n\n  if (jitter === 'equal') {\n    return Math.floor(delay / 2 + Math.random() * (delay / 2))\n  }\n\n  return delay\n}\n\nfunction isInvalidUrlError(error: Error): boolean {\n  return (\n    error.message.includes('Invalid URL') ||\n    error.message.includes('Failed to parse URL')\n  )\n}\n\nfunction isHttpError(error: Error): error is HttpErrorLike {\n  const candidate = error as HttpErrorCandidate\n\n  return (\n    error.name === 'HttpError' &&\n    typeof candidate.status === 'number' &&\n    isHeaderReader(candidate.response?.headers)\n  )\n}\n\nfunction isNetworkError(error: Error): boolean {\n  return error.name === 'NetworkError'\n}\n\nfunction isHeaderReader(value: unknown): value is HeaderReader {\n  const candidate = value as { get?: unknown }\n\n  return (\n    candidate !== null &&\n    typeof candidate === 'object' &&\n    typeof candidate.get === 'function'\n  )\n}\n"],"mappings":"AAwCA,IAAM,EAAqE,CACzE,WAAY,EACZ,WAAY,IACZ,cAAe,EACf,iBAAkB,CAAC,IAAK,IAAK,IAAK,IAAK,IAAK,KAC5C,oBAAoB,EACpB,cAAe,IACf,aAAc,CAAC,MAAO,OAAQ,UAAW,MAAO,UAChD,oBAAoB,EACpB,OAAQ,OACR,mBAAmB,GAoLrB,SAAS,EAAY,GACnB,MAAM,EAAY,EAElB,MACiB,cAAf,EAAM,MACsB,iBAArB,EAAU,QASrB,SAAwB,GACtB,MAAM,EAAY,EAElB,OACgB,OAAd,GACqB,iBAAd,GACkB,mBAAlB,EAAU,GAErB,CAhBI,CAAe,EAAU,UAAU,QAEvC,6BAxGA,SACE,EACA,EACA,GAEA,IAAK,EAAa,OAAO,EAEzB,MAAM,EAAkB,EAAY,kBAuCtC,SAA4B,GAC1B,IAAK,EAAY,GACf,OAGF,MAAM,EAAa,EAAM,SAAS,QAAQ,IAAI,eAC9C,IAAK,EACH,OAGF,MAAM,EAAoB,OAAO,GACjC,GAAI,OAAO,SAAS,GAClB,OAAO,KAAK,IAAI,EAAuB,IAApB,GAGrB,MAAM,EAAiB,KAAK,MAAM,GAClC,GAAI,OAAO,MAAM,GACf,OAGF,OAAO,KAAK,IAAI,EAAG,EAAiB,KAAK,MAC3C,CA3DM,CAAmB,QACnB,EAEJ,QAAwB,IAApB,EACF,OAAO,KAAK,IAAI,EAAiB,EAAY,eAG/C,MAAM,EACJ,EAAY,WAAa,KAAK,IAAI,EAAY,cAAe,GAE/D,OAmDF,SACE,EACA,EACA,GAEA,MAAsB,mBAAX,EACF,KAAK,IAAI,EAAG,EAAO,EAAO,IAGpB,SAAX,EACK,KAAK,MAAM,KAAK,SAAW,GAGrB,UAAX,EACK,KAAK,MAAM,EAAQ,EAAI,KAAK,UAAY,EAAQ,IAGlD,CACT,CArES,CACL,KAAK,IAAI,EAAO,EAAY,eAC5B,EAAY,OACZ,EAEJ,4BA3FA,SACE,EACA,GAEA,IAjBF,SACE,EACA,GAEA,OACmB,IAAjB,KACiB,IAAhB,GACwB,iBAAhB,IACU,IAAjB,GACwB,iBAAjB,EAEb,CAMO,CAAqB,EAAa,GACrC,OAGF,MAEM,EAAmB,IACpB,KAFoB,iBAAhB,EAA2B,OAAc,GAMlD,OAAqB,IAAjB,EACK,EAGmB,iBAAjB,EACF,IACF,KACA,GAIA,CACT,sBAkEA,eACE,EACA,SAEM,GAAa,UAAU,GAC/B,sBArEA,eACE,EACA,EACA,EACA,GAEA,IAAK,EAAa,OAAO,EAEzB,MAAM,EAA6B,IAC9B,EACH,QACA,cAGF,OAAI,EAAY,kBACD,EAAY,YAAY,EAAO,EAAY,MAIvD,EAAQ,iBAoDb,SACE,EACA,GAEA,GAAI,EAAY,mBACd,OAAO,EAGT,MAAM,EAAmB,EAAO,cAChC,OAAO,EAAY,aAAa,KAC9B,GAAe,EAAY,gBAAkB,EAEjD,CA/DK,CAAqB,EAAQ,OAAQ,MAKpC,EAAY,GACP,EAAY,iBAAiB,SAAS,EAAM,WAuHvD,SAAwB,GACtB,MAAsB,iBAAf,EAAM,IACf,CArHI,CAAe,KACC,cAAf,EAAM,MAiGX,SAA2B,GACzB,OACE,EAAM,QAAQ,SAAS,gBACvB,EAAM,QAAQ,SAAS,sBAE3B,CAtGoC,CAAkB,MAE3C,EAAY,mBAIvB"}

package/dist/retry-D07aIs-1.js

@@ -0,0 +1,2 @@
+var t={maxRetries:3,retryDelay:300,backoffFactor:2,retryStatusCodes:[408,429,500,502,503,504],retryNetworkErrors:!0,maxRetryDelay:3e4,retryMethods:["GET","HEAD","OPTIONS","PUT","DELETE"],retryUnsafeMethods:!1,jitter:"none",respectRetryAfter:!0};function e(e,r){if(!function(t,e){return!1!==e&&(!0===t||"object"==typeof t||!0===e||"object"==typeof e)}(e,r))return;const n={...t,..."object"==typeof e?e:void 0};return!0===r?n:"object"==typeof r?{...n,...r}:n}async function r(t,e,r,n){if(!r)return!1;const o={...n,error:t,retryCount:e};return r.shouldRetry?await r.shouldRetry(t,e,o):!(!n.bodyReplayable||!function(t,e){if(e.retryUnsafeMethods)return!0;const r=t.toUpperCase();return e.retryMethods.some(t=>t.toUpperCase()===r)}(n.method,r))&&(a(t)?r.retryStatusCodes.includes(t.status):!(!function(t){return"NetworkError"===t.name}(t)&&("TypeError"!==t.name||function(t){return t.message.includes("Invalid URL")||t.message.includes("Failed to parse URL")}(t)))&&r.retryNetworkErrors)}function n(t,e,r){if(!e)return 0;const n=e.respectRetryAfter?function(t){if(!a(t))return;const e=t.response.headers.get("retry-after");if(!e)return;const r=Number(e);if(Number.isFinite(r))return Math.max(0,1e3*r);const n=Date.parse(e);if(Number.isNaN(n))return;return Math.max(0,n-Date.now())}(r):void 0;if(void 0!==n)return Math.min(n,e.maxRetryDelay);const o=e.retryDelay*Math.pow(e.backoffFactor,t);return function(t,e,r){return"function"==typeof e?Math.max(0,e(t,r)):"full"===e?Math.floor(Math.random()*t):"equal"===e?Math.floor(t/2+Math.random()*(t/2)):t}(Math.min(o,e.maxRetryDelay),e.jitter,t)}async function o(t,e){await(t?.onRetry?.(e))}function a(t){const e=t;return"HttpError"===t.name&&"number"==typeof e.status&&function(t){const e=t;return null!==e&&"object"==typeof e&&"function"==typeof e.get}(e.response?.headers)}export{n as calculateRetryDelay,e as createRetryPolicy,o as notifyRetry,r as shouldRetry};
+//# sourceMappingURL=retry-D07aIs-1.js.map

package/dist/retry-D07aIs-1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-D07aIs-1.js","names":[],"sources":["../src/request/retry/retry.ts"],"sourcesContent":["import type {\n  HttpMethod,\n  RetryContext,\n  RetryEvent,\n  RetryOptions,\n} from '../../types'\n\ntype RetryPolicy = {\n  maxRetries: number\n  retryDelay: number\n  backoffFactor: number\n  retryStatusCodes: number[]\n  retryNetworkErrors: boolean\n  maxRetryDelay: number\n  retryMethods: readonly HttpMethod[]\n  retryUnsafeMethods: boolean\n  jitter: NonNullable<RetryOptions['jitter']>\n  respectRetryAfter: boolean\n  shouldRetry?: RetryOptions['shouldRetry']\n  onRetry?: RetryOptions['onRetry']\n}\n\ntype HeaderReader = {\n  get(name: string): string | null\n}\n\ntype HttpErrorLike = Error & {\n  status: number\n  response: {\n    headers: HeaderReader\n  }\n}\n\ntype HttpErrorCandidate = Error & {\n  status?: unknown\n  response?: {\n    headers?: unknown\n  }\n}\n\nconst DEFAULT_RETRY_POLICY: Omit<RetryPolicy, 'shouldRetry' | 'onRetry'> = {\n  maxRetries: 3,\n  retryDelay: 300,\n  backoffFactor: 2,\n  retryStatusCodes: [408, 429, 500, 502, 503, 504],\n  retryNetworkErrors: true,\n  maxRetryDelay: 30_000,\n  retryMethods: ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE'],\n  retryUnsafeMethods: false,\n  jitter: 'none',\n  respectRetryAfter: true,\n}\n\nfunction shouldUseRetryPolicy(\n  clientRetry?: RetryOptions | boolean,\n  requestRetry?: RetryOptions | boolean\n): boolean {\n  return (\n    requestRetry !== false &&\n    (clientRetry === true ||\n      typeof clientRetry === 'object' ||\n      requestRetry === true ||\n      typeof requestRetry === 'object')\n  )\n}\n\nexport function createRetryPolicy(\n  clientRetry?: RetryOptions | boolean,\n  requestRetry?: RetryOptions | boolean\n): RetryPolicy | undefined {\n  if (!shouldUseRetryPolicy(clientRetry, requestRetry)) {\n    return undefined\n  }\n\n  const clientRetryOptions =\n    typeof clientRetry === 'object' ? clientRetry : undefined\n  const baseRetryOptions = {\n    ...DEFAULT_RETRY_POLICY,\n    ...clientRetryOptions,\n  }\n\n  if (requestRetry === true) {\n    return baseRetryOptions\n  }\n\n  if (typeof requestRetry === 'object') {\n    return {\n      ...baseRetryOptions,\n      ...requestRetry,\n    }\n  }\n\n  return baseRetryOptions\n}\n\nexport async function shouldRetry(\n  error: Error,\n  retryCount: number,\n  retryConfig: RetryPolicy | undefined,\n  context: Pick<RetryContext, 'bodyReplayable' | 'method' | 'url'>\n): Promise<boolean> {\n  if (!retryConfig) return false\n\n  const retryContext: RetryContext = {\n    ...context,\n    error,\n    retryCount,\n  }\n\n  if (retryConfig.shouldRetry) {\n    return await retryConfig.shouldRetry(error, retryCount, retryContext)\n  }\n\n  if (\n    !context.bodyReplayable ||\n    !isRetryMethodAllowed(context.method, retryConfig)\n  ) {\n    return false\n  }\n\n  if (isHttpError(error)) {\n    return retryConfig.retryStatusCodes.includes(error.status)\n  }\n\n  if (\n    isNetworkError(error) ||\n    (error.name === 'TypeError' && !isInvalidUrlError(error))\n  ) {\n    return retryConfig.retryNetworkErrors\n  }\n\n  return false\n}\n\nexport function calculateRetryDelay(\n  attempt: number,\n  retryConfig: RetryPolicy | undefined,\n  error: Error\n): number {\n  if (!retryConfig) return 0\n\n  const retryAfterDelay = retryConfig.respectRetryAfter\n    ? getRetryAfterDelay(error)\n    : undefined\n\n  if (retryAfterDelay !== undefined) {\n    return Math.min(retryAfterDelay, retryConfig.maxRetryDelay)\n  }\n\n  const delay =\n    retryConfig.retryDelay * Math.pow(retryConfig.backoffFactor, attempt)\n\n  return applyJitter(\n    Math.min(delay, retryConfig.maxRetryDelay),\n    retryConfig.jitter,\n    attempt\n  )\n}\n\nexport async function notifyRetry(\n  retryConfig: RetryPolicy | undefined,\n  event: RetryEvent\n): Promise<void> {\n  await retryConfig?.onRetry?.(event)\n}\n\nfunction isRetryMethodAllowed(\n  method: HttpMethod,\n  retryConfig: RetryPolicy\n): boolean {\n  if (retryConfig.retryUnsafeMethods) {\n    return true\n  }\n\n  const normalizedMethod = method.toUpperCase()\n  return retryConfig.retryMethods.some(\n    retryMethod => retryMethod.toUpperCase() === normalizedMethod\n  )\n}\n\nfunction getRetryAfterDelay(error: Error): number | undefined {\n  if (!isHttpError(error)) {\n    return undefined\n  }\n\n  const retryAfter = error.response.headers.get('retry-after')\n  if (!retryAfter) {\n    return undefined\n  }\n\n  const retryAfterSeconds = Number(retryAfter)\n  if (Number.isFinite(retryAfterSeconds)) {\n    return Math.max(0, retryAfterSeconds * 1000)\n  }\n\n  const retryAfterDate = Date.parse(retryAfter)\n  if (Number.isNaN(retryAfterDate)) {\n    return undefined\n  }\n\n  return Math.max(0, retryAfterDate - Date.now())\n}\n\nfunction applyJitter(\n  delay: number,\n  jitter: RetryPolicy['jitter'],\n  attempt: number\n): number {\n  if (typeof jitter === 'function') {\n    return Math.max(0, jitter(delay, attempt))\n  }\n\n  if (jitter === 'full') {\n    return Math.floor(Math.random() * delay)\n  }\n\n  if (jitter === 'equal') {\n    return Math.floor(delay / 2 + Math.random() * (delay / 2))\n  }\n\n  return delay\n}\n\nfunction isInvalidUrlError(error: Error): boolean {\n  return (\n    error.message.includes('Invalid URL') ||\n    error.message.includes('Failed to parse URL')\n  )\n}\n\nfunction isHttpError(error: Error): error is HttpErrorLike {\n  const candidate = error as HttpErrorCandidate\n\n  return (\n    error.name === 'HttpError' &&\n    typeof candidate.status === 'number' &&\n    isHeaderReader(candidate.response?.headers)\n  )\n}\n\nfunction isNetworkError(error: Error): boolean {\n  return error.name === 'NetworkError'\n}\n\nfunction isHeaderReader(value: unknown): value is HeaderReader {\n  const candidate = value as { get?: unknown }\n\n  return (\n    candidate !== null &&\n    typeof candidate === 'object' &&\n    typeof candidate.get === 'function'\n  )\n}\n"],"mappings":"AAwCA,IAAM,EAAqE,CACzE,WAAY,EACZ,WAAY,IACZ,cAAe,EACf,iBAAkB,CAAC,IAAK,IAAK,IAAK,IAAK,IAAK,KAC5C,oBAAoB,EACpB,cAAe,IACf,aAAc,CAAC,MAAO,OAAQ,UAAW,MAAO,UAChD,oBAAoB,EACpB,OAAQ,OACR,mBAAmB,GAgBrB,SAAgB,EACd,EACA,GAEA,IAjBF,SACE,EACA,GAEA,OACmB,IAAjB,KACiB,IAAhB,GACwB,iBAAhB,IACU,IAAjB,GACwB,iBAAjB,EAEb,CAMO,CAAqB,EAAa,GACrC,OAGF,MAEM,EAAmB,IACpB,KAFoB,iBAAhB,EAA2B,OAAc,GAMlD,OAAqB,IAAjB,EACK,EAGmB,iBAAjB,EACF,IACF,KACA,GAIA,CACT,CAEA,eAAsB,EACpB,EACA,EACA,EACA,GAEA,IAAK,EAAa,OAAO,EAEzB,MAAM,EAA6B,IAC9B,EACH,QACA,cAGF,OAAI,EAAY,kBACD,EAAY,YAAY,EAAO,EAAY,MAIvD,EAAQ,iBAoDb,SACE,EACA,GAEA,GAAI,EAAY,mBACd,OAAO,EAGT,MAAM,EAAmB,EAAO,cAChC,OAAO,EAAY,aAAa,KAC9B,GAAe,EAAY,gBAAkB,EAEjD,CA/DK,CAAqB,EAAQ,OAAQ,MAKpC,EAAY,GACP,EAAY,iBAAiB,SAAS,EAAM,WAuHvD,SAAwB,GACtB,MAAsB,iBAAf,EAAM,IACf,CArHI,CAAe,KACC,cAAf,EAAM,MAiGX,SAA2B,GACzB,OACE,EAAM,QAAQ,SAAS,gBACvB,EAAM,QAAQ,SAAS,sBAE3B,CAtGoC,CAAkB,MAE3C,EAAY,mBAIvB,CAEA,SAAgB,EACd,EACA,EACA,GAEA,IAAK,EAAa,OAAO,EAEzB,MAAM,EAAkB,EAAY,kBAuCtC,SAA4B,GAC1B,IAAK,EAAY,GACf,OAGF,MAAM,EAAa,EAAM,SAAS,QAAQ,IAAI,eAC9C,IAAK,EACH,OAGF,MAAM,EAAoB,OAAO,GACjC,GAAI,OAAO,SAAS,GAClB,OAAO,KAAK,IAAI,EAAuB,IAApB,GAGrB,MAAM,EAAiB,KAAK,MAAM,GAClC,GAAI,OAAO,MAAM,GACf,OAGF,OAAO,KAAK,IAAI,EAAG,EAAiB,KAAK,MAC3C,CA3DM,CAAmB,QACnB,EAEJ,QAAwB,IAApB,EACF,OAAO,KAAK,IAAI,EAAiB,EAAY,eAG/C,MAAM,EACJ,EAAY,WAAa,KAAK,IAAI,EAAY,cAAe,GAE/D,OAmDF,SACE,EACA,EACA,GAEA,MAAsB,mBAAX,EACF,KAAK,IAAI,EAAG,EAAO,EAAO,IAGpB,SAAX,EACK,KAAK,MAAM,KAAK,SAAW,GAGrB,UAAX,EACK,KAAK,MAAM,EAAQ,EAAI,KAAK,UAAY,EAAQ,IAGlD,CACT,CArES,CACL,KAAK,IAAI,EAAO,EAAY,eAC5B,EAAY,OACZ,EAEJ,CAEA,eAAsB,EACpB,EACA,SAEM,GAAa,UAAU,GAC/B,CAkEA,SAAS,EAAY,GACnB,MAAM,EAAY,EAElB,MACiB,cAAf,EAAM,MACsB,iBAArB,EAAU,QASrB,SAAwB,GACtB,MAAM,EAAY,EAElB,OACgB,OAAd,GACqB,iBAAd,GACkB,mBAAlB,EAAU,GAErB,CAhBI,CAAe,EAAU,UAAU,QAEvC"}

package/dist/{schema.d.ts → schema/index.d.ts}

@@ -1,4 +1,4 @@
-import { Schema } from './types';
+import { Schema } from '../types';
 /**
  * Interface for schema validators that can validate data against schemas.
  *

package/dist/status.d.ts

@@ -0,0 +1,2 @@
+export declare const successStatusValidator: unique symbol;
+export declare function isSuccessfulStatus(status: number): boolean;

package/dist/types.d.ts

@@ -68,8 +68,6 @@ export interface RequestOptions<TBody = unknown> {
     redirect?: RequestRedirect;
     fetchOptions?: FetchOptions;
     retry?: RetryOptions | boolean;
-    onUploadStreaming?: (event: UploadStreamingEvent) => void;
-    onDownloadStreaming?: (event: DownloadStreamingEvent) => void;
 }
 export interface ResponseType<T = unknown> {
     data: T;
@@ -84,8 +82,30 @@ export type ExtractableResponse<T> = Promise<ResponseType<T>> & {
     data(): Promise<T>;
     void(): Promise<void>;
 };
-export type SchemaableResponse<T> = ExtractableResponse<T> & {
-    schema<S extends Schema>(schema: S): ExtractableResponse<InferSchemaOutput<S>>;
+type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+export type SuccessContractStatus = `${2 | 3}${Digit}${Digit}`;
+export type ErrorContractStatus = `${4 | 5}${Digit}${Digit}`;
+export type ContractStatus = SuccessContractStatus | ErrorContractStatus;
+export type ContractStatusMap<Status extends string = ContractStatus> = {
+    default?: Schema;
+} & Partial<Record<Status, Schema>>;
+export type SuccessContractStatusMap = ContractStatusMap<SuccessContractStatus>;
+export type ErrorContractStatusMap = ContractStatusMap<ErrorContractStatus>;
+export type ResponseContractBranch<Status extends string = ContractStatus> = Schema | ContractStatusMap<Status>;
+export type ResponseContract = Schema | {
+    success: ResponseContractBranch<SuccessContractStatus>;
+    error?: ResponseContractBranch<ErrorContractStatus>;
+};
+type InferContractBranchSchema<Branch> = Branch extends Schema ? Branch : Branch extends object ? Extract<Branch[keyof Branch], Schema> : never;
+export type InferContractBranchOutput<Branch> = InferSchemaOutput<InferContractBranchSchema<Branch>>;
+export type InferContractSuccess<Contract> = Contract extends Schema ? InferSchemaOutput<Contract> : Contract extends {
+    success: infer Success;
+} ? InferContractBranchOutput<Success> : unknown;
+export type InferContractError<Contract> = Contract extends {
+    error: infer ErrorBranch;
+} ? InferContractBranchOutput<ErrorBranch> : unknown;
+export type ContractableResponse<T> = ExtractableResponse<T> & {
+    contract<C extends ResponseContract>(contract: C): ExtractableResponse<InferContractSuccess<C>>;
 };
 /**
  * Request context that can be modified by onRequest hook
@@ -111,7 +131,7 @@ export interface ExtendedRequestInit extends RequestInit {
 }
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | (string & {});
 export type HttpHeaders = Record<string, string>;
-export type RequestParamsType = Record<string, string | number | boolean | (string | number | boolean | undefined | null)[] | undefined | null>;
+export type RequestParamsType = Record<string, string | number | boolean | Date | (string | number | boolean | undefined | null)[] | readonly Date[] | undefined | null>;
 export type Schema<T = unknown> = StandardSchemaV1<unknown, T> | (StandardSchemaV1<unknown, T> & {
     _output: T;
 }) | (StandardSchemaV1<unknown, T> & {
@@ -124,22 +144,7 @@ export type InferSchemaOutput<ResponseSchema> = ResponseSchema extends unknown ?
 } ? Output : ResponseSchema extends {
     _output?: infer Output;
 } ? Output : ResponseSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ResponseSchema> : unknown : never;
-export interface UploadStreamingEvent {
-    /** Current data chunk being uploaded */
-    chunk: Uint8Array;
-    /** Total bytes to upload (from Content-Length header or body size) */
-    totalBytes: number | undefined;
-    /** Bytes already transferred */
-    transferredBytes: number;
-}
-export interface DownloadStreamingEvent {
-    /** Current data chunk being downloaded */
-    chunk: Uint8Array;
-    /** Total bytes to download (from Content-Length header, undefined if unknown) */
-    totalBytes: number | undefined;
-    /** Bytes already transferred */
-    transferredBytes: number;
-}
 export type SerializeBody<TBody = unknown> = (body: TBody) => BodyInit | null | undefined;
 export type SerializeParams = (params: RequestParamsType) => string;
 export type CustomFetch = typeof fetch;
+export {};

package/dist/utils/index.d.ts

@@ -1,2 +1 @@
-export { type AssertSupportedPath, generatePath, type HasRequiredParams, type PathParams, type RequirePathParams, } from './path';
-export { toStreamableRequest, toStreamableResponse } from './streaming';
+export { type AssertSupportedPath, type HasRequiredParams, type RequirePathParams, } from './path';

package/dist/utils/path.d.ts

@@ -1,12 +1,11 @@
-/**
- * Strips protocol from URL (e.g., https://, http://)
- */
-type StripProtocol<T extends string> = T extends `${string}://${infer After}` ? After : T;
 /**
  * Strips host and optional port from URL, keeping only the path
- * Handles cases like "localhost:3000/users" -> "/users"
  */
 type StripHost<T extends string> = T extends `${infer _Host}/${infer Path}` ? `/${Path}` : T;
+/**
+ * Strips protocol and host from full URLs, keeping bare relative paths intact.
+ */
+type StripUrlOrigin<T extends string> = T extends `${string}://${infer After}` ? StripHost<After> : T;
 /**
  * Strips query string from path (e.g., "/users?x=1" -> "/users")
  * Only strips ? that comes after the path, not ? that's part of path parameters
@@ -15,7 +14,7 @@ type StripQuery<T extends string> = T extends `${infer Path}?${infer Query}` ? Q
 /**
  * Normalizes URL to path only, stripping protocol, host, port, and query
  */
-type NormalizePath<T extends string> = StripQuery<StripHost<StripProtocol<T>>>;
+type NormalizePath<T extends string> = StripQuery<StripUrlOrigin<T>>;
 /**
  * Removes optional suffix from param name (e.g., ":id?" -> "id", ":id" -> "id")
  */
@@ -68,6 +67,5 @@ export type RequirePathParams<Path extends string, T> = [
  * // => '/users/123/posts/456'
  * ```
  */
-export declare function generatePath<Path extends string>(path: AssertSupportedPath<Path>): string;
-export declare function generatePath<Path extends string>(path: AssertSupportedPath<Path>, params: PathParams<Path>): string;
+export declare function generatePath<Path extends string>(path: AssertSupportedPath<Path>, ...args: HasRequiredParams<Path> extends true ? [params: PathParams<Path>] : HasPathParams<Path> extends true ? [params?: PathParams<Path>] : [params?: PathParams<Path>]): string;
 export {};

package/docs/BEST_PRACTICES.md

@@ -5,6 +5,7 @@ This guide provides recommendations for using 1000fetches effectively in product
 ## Table of Contents
 
 - [Client Configuration](#client-configuration)
+- [Dynamic Defaults](#dynamic-defaults)
 - [Error Handling](#error-handling)
 - [Schema Validation](#schema-validation)
 - [Middleware](#middleware)
@@ -68,12 +69,61 @@ const postClient = createHttpClient({ baseUrl: 'https://api.example.com' })
 const apiClient = createHttpClient({ baseUrl: 'https://api.example.com' })
 ```
 
+## Dynamic Defaults
+
+### ✅ DO: Use Defaults for Dynamic Auth and Request-Shaped Defaults
+
+Use `defaults` when a value should be resolved for each request but does not need to mutate the final request context.
+
+```typescript
+const apiClient = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  defaults: async ({ resolvedPath, method }) => {
+    const token = await getAuthToken()
+
+    return {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'X-Client': 'web',
+      },
+      timeout: resolvedPath.startsWith('/reports') ? 60_000 : 10_000,
+      retry: method === 'GET',
+      params: {
+        locale: 'en-US',
+      },
+    }
+  },
+})
+```
+
+### ✅ DO: Let Request Options Override Defaults
+
+Request options are applied after dynamic defaults, so callers can opt out or specialize one request without creating another client.
+
+```typescript
+const apiClient = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  defaults: () => ({
+    headers: { 'X-Client': 'web' },
+    timeout: 10_000,
+    retry: true,
+  }),
+})
+
+await apiClient.get('/health', {
+  timeout: 2_000,
+  retry: false,
+  headers: { 'X-Client': 'health-check' },
+})
+```
+
 ## Error Handling
 
 ### ✅ DO: Handle Specific Error Types
 
 ```typescript
 import {
+  AbortError,
   HttpError,
   NetworkError,
   TimeoutError,
@@ -97,6 +147,8 @@ async function fetchUser(id: string) {
       throw new ConnectivityError('Network connection failed')
     } else if (error instanceof TimeoutError) {
       throw new TimeoutError('Request timed out')
+    } else if (error instanceof AbortError) {
+      throw error
     } else {
       throw error
     }
@@ -121,6 +173,27 @@ const newUser = await apiClient.post('/users', userData, {
 })
 ```
 
+### ✅ DO: Declare Valid Non-2xx Statuses Explicitly
+
+The default success rule is any 2xx status. Use a response contract status map when the protocol intentionally uses another status, such as conditional requests that return `304 Not Modified`.
+
+```typescript
+const response = await apiClient
+  .get('/reports/:id', {
+    pathParams: { id: reportId },
+  })
+  .contract({
+    success: {
+      default: ReportSchema,
+      304: z.undefined(),
+    },
+  })
+
+if (response.status === 304) {
+  return cachedReport
+}
+```
+
 ## Schema Validation
 
 ### ✅ DO: Validate Response Data
@@ -137,7 +210,7 @@ const userSchema = z.object({
   updatedAt: z.iso.datetime(),
 })
 
-await apiClient.get(`/users/${id}`).schema(userSchema)
+await apiClient.get(`/users/${id}`).contract(userSchema)
 ```
 
 ### ✅ DO: Create Reusable Schema Compositions
@@ -163,24 +236,24 @@ const PostSchema = BaseEntitySchema.extend({
 
 ## Middleware
 
-### ✅ DO: Use Middleware for Cross-Cutting Concerns
+### ✅ DO: Use Middleware for Observation and Deliberate Mutation
 
 ```typescript
 const apiClient = createHttpClient({
   baseUrl: 'https://api.example.com',
-  onRequestMiddleware: async context => {
-    const token = await getAuthToken()
+  onRequestMiddleware: context => {
     console.log(`→ ${context.method} ${context.url}`)
-    context.headers.set('Authorization', `Bearer ${token}`)
     return context
   },
-  onResponseMiddleware: async response => {
+  onResponseMiddleware: response => {
     console.log(`← ${response.status} ${response.method} ${response.url}`)
     return response
   },
 })
 ```
 
+Middleware can observe requests and responses, and it can mutate request/response state. Keep it side-effect-light; use mutation only when dynamic defaults or request options are not expressive enough.
+
 ### ✅ DO: Handle Middleware Errors Gracefully
 
 ```typescript
@@ -188,12 +261,10 @@ const apiClient = createHttpClient({
   baseUrl: 'https://api.example.com',
   onRequestMiddleware: async context => {
     try {
-      const token = await getAuthToken()
-      context.headers.set('Authorization', `Bearer ${token}`)
+      context.headers.set('X-Request-ID', await createRequestId())
       return context
     } catch (error) {
-      // Log the error but don't fail the request
-      console.warn('Failed to get auth token:', error)
+      console.warn('Failed to create request id:', error)
       return context
     }
   },
@@ -454,36 +525,43 @@ const apiClient = createHttpClient({
 ### ✅ DO: Add Request Tracking
 
 ```typescript
-const requestTimings = new Map<string, number>()
+import type { ResponseType } from '1000fetches'
 
-const apiClient = createHttpClient({
-  onRequestMiddleware: async context => {
-    const requestId = generateRequestId()
-    requestTimings.set(requestId, Date.now())
-    context.headers.set('X-Request-ID', requestId)
-    return context
-  },
-  onResponseMiddleware: async response => {
-    const requestId = response.headers['x-request-id']
-    const startTime = requestId ? requestTimings.get(requestId) : undefined
+async function trackRequest<T>(
+  operation: string,
+  request: () => Promise<ResponseType<T>>
+) {
+  const startTime = Date.now()
 
-    if (requestId && startTime !== undefined) {
-      const duration = Date.now() - startTime
-      console.log(`Request ${requestId} completed in ${duration}ms`)
+  try {
+    const response = await request()
+    const duration = Date.now() - startTime
+
+    analytics.track('api_request', {
+      operation,
+      url: response.url,
+      method: response.method,
+      status: response.status,
+      duration,
+    })
 
-      analytics.track('api_request', {
-        method: response.method,
-        url: response.url,
-        status: response.status,
-        duration,
-      })
+    return response
+  } catch (error) {
+    analytics.track('api_request_failed', {
+      operation,
+      duration: Date.now() - startTime,
+    })
 
-      requestTimings.delete(requestId)
-    }
+    throw error
+  }
+}
 
-    return response
-  },
-})
+const response = await trackRequest('fetch_user', () =>
+  apiClient.get('/users/:id', {
+    pathParams: { id: userId },
+    headers: { 'X-Request-ID': generateRequestId() },
+  })
+)
 ```
 
 ### ✅ DO: Monitor Error Rates
@@ -577,8 +655,8 @@ try {
 // Bad: Synchronous operations in middleware
 const blockingClient = createHttpClient({
   onRequestMiddleware: context => {
-    const token = fs.readFileSync('/path/to/token', 'utf8') // Blocks event loop
-    context.headers.set('Authorization', `Bearer ${token}`)
+    const metadata = fs.readFileSync('/path/to/metadata', 'utf8') // Blocks event loop
+    context.headers.set('X-Metadata', metadata)
     return context
   },
 })
@@ -586,8 +664,8 @@ const blockingClient = createHttpClient({
 // Good: Asynchronous operations
 const asyncClient = createHttpClient({
   onRequestMiddleware: async context => {
-    const token = await fs.promises.readFile('/path/to/token', 'utf8')
-    context.headers.set('Authorization', `Bearer ${token}`)
+    const metadata = await fs.promises.readFile('/path/to/metadata', 'utf8')
+    context.headers.set('X-Metadata', metadata)
     return context
   },
 })
@@ -598,9 +676,10 @@ const asyncClient = createHttpClient({
 Following these best practices will help you build robust, maintainable, and performant applications with 1000fetches:
 
 1. **Configure once, use everywhere** - Create a single, well-configured client instance
-2. **Handle errors explicitly** - Don't let errors fail silently
-3. **Validate data** - Use schemas to ensure data integrity
-4. **Keep middleware lightweight** - Avoid heavy operations that slow down requests
-5. **Test thoroughly** - Mock HTTP calls and test error scenarios
-6. **Monitor in production** - Track request metrics and error rates
-7. **Secure by default** - Validate input and handle sensitive data carefully
+2. **Use dynamic defaults** - Resolve auth and request-shaped defaults per request
+3. **Handle errors explicitly** - Don't let errors fail silently
+4. **Validate data** - Use schemas to ensure data integrity
+5. **Keep middleware lightweight** - Avoid heavy operations that slow down requests
+6. **Test thoroughly** - Mock HTTP calls and test error scenarios
+7. **Monitor in production** - Track request metrics and error rates
+8. **Secure by default** - Validate input and handle sensitive data carefully