@fetchkit/ffetch 5.0.1 → 5.1.0

package/dist/index.d.cts

@@ -1,51 +1,9 @@
-import { C as ClientPlugin, P as PluginExtensionBase, a as PluginExtensions } from './plugins-9qcU31nU.cjs';
-export { c as PluginDispatch, b as PluginRequestContext, d as PluginSetupContext } from './plugins-9qcU31nU.cjs';
+import { F as FFetchOptions, a as FFetch } from './types-DbmivXba.cjs';
+export { H as Hooks } from './types-DbmivXba.cjs';
+import { C as ClientPlugin, P as PluginExtensionBase, a as PluginRequestPromiseExtensionBase, b as PluginExtensions, c as PluginRequestPromiseExtensions } from './plugins-DqBQVM4I.cjs';
+export { e as PluginDispatch, d as PluginRequestContext, f as PluginSetupContext } from './plugins-DqBQVM4I.cjs';
 
-type Hooks = {
-    before?: (req: Request) => void | Promise<void>;
-    after?: (req: Request, res: Response) => void | Promise<void>;
-    onError?: (req: Request, err: unknown) => void | Promise<void>;
-    onRetry?: (req: Request, attempt: number, err?: unknown, res?: Response) => void | Promise<void>;
-    onTimeout?: (req: Request) => void | Promise<void>;
-    onAbort?: (req: Request) => void | Promise<void>;
-    onComplete?: (req: Request, res?: Response, err?: unknown) => void | Promise<void>;
-    transformRequest?: (req: Request) => Request | Promise<Request>;
-    transformResponse?: (res: Response, req: Request) => Response | Promise<Response>;
-};
-
-interface RetryContext {
-    attempt: number;
-    request: Request;
-    response?: Response;
-    error?: unknown;
-}
-interface CoreClientOptions {
-    timeout?: number;
-    retries?: number;
-    retryDelay?: number | ((ctx: RetryContext) => number);
-    shouldRetry?: (ctx: RetryContext) => boolean;
-    throwOnHttpError?: boolean;
-    hooks?: Hooks;
-    fetchHandler?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-}
-interface FFetchOptions<TPlugins extends readonly ClientPlugin<PluginExtensionBase>[] = readonly ClientPlugin<PluginExtensionBase>[]> extends CoreClientOptions {
-    plugins?: TPlugins;
-}
-type FFetchRequestOptions = CoreClientOptions;
-type FFetch<TExtensions extends object = Record<never, never>> = {
-    (input: RequestInfo | URL, init?: FFetchRequestInit): Promise<Response>;
-    pendingRequests: PendingRequest[];
-    abortAll: () => void;
-} & TExtensions;
-interface FFetchRequestInit extends RequestInit, FFetchRequestOptions {
-}
-type PendingRequest = {
-    promise: Promise<Response>;
-    request: Request;
-    controller?: AbortController;
-};
-
-declare function createClient<TPlugins extends readonly ClientPlugin<PluginExtensionBase>[] = readonly ClientPlugin<PluginExtensionBase>[]>(opts?: FFetchOptions<TPlugins>): FFetch<PluginExtensions<TPlugins>>;
+declare function createClient<TPlugins extends readonly ClientPlugin<PluginExtensionBase, PluginRequestPromiseExtensionBase>[] = readonly ClientPlugin<PluginExtensionBase, PluginRequestPromiseExtensionBase>[]>(opts?: FFetchOptions<TPlugins>): FFetch<PluginExtensions<TPlugins>, PluginRequestPromiseExtensions<TPlugins>>;
 
 declare class BaseError extends Error {
     cause?: unknown;
@@ -66,5 +24,8 @@ declare class RetryLimitError extends BaseError {
 declare class NetworkError extends BaseError {
     constructor(message?: string, cause?: unknown);
 }
+declare class HttpError extends BaseError {
+    constructor(message?: string, cause?: unknown);
+}
 
-export { AbortError, CircuitOpenError, ClientPlugin, type FFetch, type FFetchOptions, type Hooks, NetworkError, RetryLimitError, TimeoutError, createClient };
+export { AbortError, CircuitOpenError, ClientPlugin, FFetch, FFetchOptions, HttpError, NetworkError, RetryLimitError, TimeoutError, createClient };

package/dist/index.d.ts

@@ -1,51 +1,9 @@
-import { C as ClientPlugin, P as PluginExtensionBase, a as PluginExtensions } from './plugins-9qcU31nU.js';
-export { c as PluginDispatch, b as PluginRequestContext, d as PluginSetupContext } from './plugins-9qcU31nU.js';
+import { F as FFetchOptions, a as FFetch } from './types-DpHoyvhy.js';
+export { H as Hooks } from './types-DpHoyvhy.js';
+import { C as ClientPlugin, P as PluginExtensionBase, a as PluginRequestPromiseExtensionBase, b as PluginExtensions, c as PluginRequestPromiseExtensions } from './plugins-DqBQVM4I.js';
+export { e as PluginDispatch, d as PluginRequestContext, f as PluginSetupContext } from './plugins-DqBQVM4I.js';
 
-type Hooks = {
-    before?: (req: Request) => void | Promise<void>;
-    after?: (req: Request, res: Response) => void | Promise<void>;
-    onError?: (req: Request, err: unknown) => void | Promise<void>;
-    onRetry?: (req: Request, attempt: number, err?: unknown, res?: Response) => void | Promise<void>;
-    onTimeout?: (req: Request) => void | Promise<void>;
-    onAbort?: (req: Request) => void | Promise<void>;
-    onComplete?: (req: Request, res?: Response, err?: unknown) => void | Promise<void>;
-    transformRequest?: (req: Request) => Request | Promise<Request>;
-    transformResponse?: (res: Response, req: Request) => Response | Promise<Response>;
-};
-
-interface RetryContext {
-    attempt: number;
-    request: Request;
-    response?: Response;
-    error?: unknown;
-}
-interface CoreClientOptions {
-    timeout?: number;
-    retries?: number;
-    retryDelay?: number | ((ctx: RetryContext) => number);
-    shouldRetry?: (ctx: RetryContext) => boolean;
-    throwOnHttpError?: boolean;
-    hooks?: Hooks;
-    fetchHandler?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-}
-interface FFetchOptions<TPlugins extends readonly ClientPlugin<PluginExtensionBase>[] = readonly ClientPlugin<PluginExtensionBase>[]> extends CoreClientOptions {
-    plugins?: TPlugins;
-}
-type FFetchRequestOptions = CoreClientOptions;
-type FFetch<TExtensions extends object = Record<never, never>> = {
-    (input: RequestInfo | URL, init?: FFetchRequestInit): Promise<Response>;
-    pendingRequests: PendingRequest[];
-    abortAll: () => void;
-} & TExtensions;
-interface FFetchRequestInit extends RequestInit, FFetchRequestOptions {
-}
-type PendingRequest = {
-    promise: Promise<Response>;
-    request: Request;
-    controller?: AbortController;
-};
-
-declare function createClient<TPlugins extends readonly ClientPlugin<PluginExtensionBase>[] = readonly ClientPlugin<PluginExtensionBase>[]>(opts?: FFetchOptions<TPlugins>): FFetch<PluginExtensions<TPlugins>>;
+declare function createClient<TPlugins extends readonly ClientPlugin<PluginExtensionBase, PluginRequestPromiseExtensionBase>[] = readonly ClientPlugin<PluginExtensionBase, PluginRequestPromiseExtensionBase>[]>(opts?: FFetchOptions<TPlugins>): FFetch<PluginExtensions<TPlugins>, PluginRequestPromiseExtensions<TPlugins>>;
 
 declare class BaseError extends Error {
     cause?: unknown;
@@ -66,5 +24,8 @@ declare class RetryLimitError extends BaseError {
 declare class NetworkError extends BaseError {
     constructor(message?: string, cause?: unknown);
 }
+declare class HttpError extends BaseError {
+    constructor(message?: string, cause?: unknown);
+}
 
-export { AbortError, CircuitOpenError, ClientPlugin, type FFetch, type FFetchOptions, type Hooks, NetworkError, RetryLimitError, TimeoutError, createClient };
+export { AbortError, CircuitOpenError, ClientPlugin, FFetch, FFetchOptions, HttpError, NetworkError, RetryLimitError, TimeoutError, createClient };

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
   AbortError,
   CircuitOpenError,
+  HttpError,
   NetworkError,
   RetryLimitError,
   TimeoutError
@@ -129,251 +130,260 @@ function createClient(opts = {}) {
       entry.controller?.abort();
     }
   }
-  const client = async (input, init = {}) => {
-    let request = new Request(input, init);
-    const effectiveHooks = { ...clientDefaultHooks, ...init.hooks || {} };
-    if (effectiveHooks.transformRequest) {
-      request = await effectiveHooks.transformRequest(request);
-    }
-    await effectiveHooks.before?.(request);
-    const effectiveRetries = init.retries ?? clientDefaultRetries;
-    const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
-    const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
-    const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
-    const userSignal = init.signal;
-    const transformedSignal = request.signal;
-    const pluginContext = {
-      request,
-      init,
-      state: /* @__PURE__ */ Object.create(null),
-      metadata: {
-        startedAt: Date.now(),
-        timeoutMs: effectiveTimeout,
-        signals: {
-          user: userSignal === void 0 || userSignal === null ? void 0 : userSignal,
-          transformed: transformedSignal
-        },
-        retry: {
-          configuredRetries: effectiveRetries,
-          configuredDelay: effectiveRetryDelay,
-          attempt: 0
-        }
+  const client = (input, init = {}) => {
+    const execute = async () => {
+      let request = new Request(input, init);
+      const effectiveHooks = { ...clientDefaultHooks, ...init.hooks || {} };
+      if (effectiveHooks.transformRequest) {
+        request = await effectiveHooks.transformRequest(request);
       }
-    };
-    for (const plugin of plugins) {
-      await plugin.preRequest?.(pluginContext);
-    }
-    const effectiveThrowOnHttpError = typeof init.throwOnHttpError !== "undefined" ? init.throwOnHttpError : opts.throwOnHttpError ?? false;
-    function createTimeoutSignal(timeout) {
-      if (typeof AbortSignal?.timeout === "function") {
-        return AbortSignal.timeout(timeout);
+      await effectiveHooks.before?.(request);
+      const effectiveRetries = init.retries ?? clientDefaultRetries;
+      const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
+      const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
+      const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
+      const userSignal = init.signal;
+      const transformedSignal = request.signal;
+      const pluginContext = {
+        request,
+        init,
+        state: /* @__PURE__ */ Object.create(null),
+        metadata: {
+          startedAt: Date.now(),
+          timeoutMs: effectiveTimeout,
+          signals: {
+            user: userSignal === void 0 || userSignal === null ? void 0 : userSignal,
+            transformed: transformedSignal
+          },
+          retry: {
+            configuredRetries: effectiveRetries,
+            configuredDelay: effectiveRetryDelay,
+            attempt: 0
+          }
+        }
+      };
+      for (const plugin of plugins) {
+        await plugin.preRequest?.(pluginContext);
       }
-      const controller2 = new AbortController();
-      const timeoutId = setTimeout(() => controller2.abort(), timeout);
-      controller2.signal.addEventListener(
-        "abort",
-        () => clearTimeout(timeoutId),
-        { once: true }
-      );
-      return controller2.signal;
-    }
-    let timeoutSignal = void 0;
-    let combinedSignal = void 0;
-    let controller = void 0;
-    if (effectiveTimeout > 0) {
-      timeoutSignal = createTimeoutSignal(effectiveTimeout);
-      pluginContext.metadata.signals.timeout = timeoutSignal;
-    }
-    const signals = [];
-    if (userSignal) signals.push(userSignal);
-    if (transformedSignal && transformedSignal !== userSignal) {
-      signals.push(transformedSignal);
-    }
-    if (timeoutSignal) signals.push(timeoutSignal);
-    if (signals.length === 1) {
-      combinedSignal = signals[0];
-      controller = new AbortController();
-    } else {
-      if (typeof AbortSignal.any !== "function") {
-        throw new Error(
-          "AbortSignal.any is required for combining multiple signals. Please install a polyfill for environments that do not support it."
+      const effectiveThrowOnHttpError = typeof init.throwOnHttpError !== "undefined" ? init.throwOnHttpError : opts.throwOnHttpError ?? false;
+      function createTimeoutSignal(timeout) {
+        if (typeof AbortSignal?.timeout === "function") {
+          return AbortSignal.timeout(timeout);
+        }
+        const controller2 = new AbortController();
+        const timeoutId = setTimeout(() => controller2.abort(), timeout);
+        controller2.signal.addEventListener(
+          "abort",
+          () => clearTimeout(timeoutId),
+          { once: true }
         );
+        return controller2.signal;
       }
-      combinedSignal = AbortSignal.any(signals);
-      controller = new AbortController();
-    }
-    pluginContext.metadata.signals.combined = combinedSignal;
-    const retryWithHooks = async () => {
-      let attempt = 0;
-      const shouldRetryWithHook = (ctx) => {
-        attempt = ctx.attempt;
-        pluginContext.metadata.retry.attempt = attempt;
-        pluginContext.metadata.retry.lastError = ctx.error;
-        pluginContext.metadata.retry.lastResponse = ctx.response;
-        const retrying = effectiveShouldRetry(ctx);
-        pluginContext.metadata.retry.shouldRetryResult = retrying;
-        if (retrying && attempt <= effectiveRetries) {
-          effectiveHooks.onRetry?.(
-            request,
-            attempt - 1,
-            ctx.error,
-            ctx.response
+      let timeoutSignal = void 0;
+      let combinedSignal = void 0;
+      let controller = void 0;
+      if (effectiveTimeout > 0) {
+        timeoutSignal = createTimeoutSignal(effectiveTimeout);
+        pluginContext.metadata.signals.timeout = timeoutSignal;
+      }
+      const signals = [];
+      if (userSignal) signals.push(userSignal);
+      if (transformedSignal && transformedSignal !== userSignal) {
+        signals.push(transformedSignal);
+      }
+      if (timeoutSignal) signals.push(timeoutSignal);
+      if (signals.length === 1) {
+        combinedSignal = signals[0];
+        controller = new AbortController();
+      } else {
+        if (typeof AbortSignal.any !== "function") {
+          throw new Error(
+            "AbortSignal.any is required for combining multiple signals. Please install a polyfill for environments that do not support it."
           );
         }
-        return retrying;
-      };
-      let lastResponse = void 0;
-      try {
-        let res = await retry(
-          async () => {
-            if (userSignal?.aborted) {
-              effectiveHooks.onAbort?.(request);
-              throw new AbortError("Request was aborted by user");
-            }
-            if (timeoutSignal?.aborted) {
-              effectiveHooks.onTimeout?.(request);
-              throw new TimeoutError("signal timed out");
-            }
-            if (typeof combinedSignal?.throwIfAborted === "function") {
-              combinedSignal.throwIfAborted();
-            } else if (combinedSignal?.aborted) {
+        combinedSignal = AbortSignal.any(signals);
+        controller = new AbortController();
+      }
+      pluginContext.metadata.signals.combined = combinedSignal;
+      const retryWithHooks = async () => {
+        let attempt = 0;
+        const shouldRetryWithHook = (ctx) => {
+          attempt = ctx.attempt;
+          pluginContext.metadata.retry.attempt = attempt;
+          pluginContext.metadata.retry.lastError = ctx.error;
+          pluginContext.metadata.retry.lastResponse = ctx.response;
+          const retrying = effectiveShouldRetry(ctx);
+          pluginContext.metadata.retry.shouldRetryResult = retrying;
+          if (retrying && attempt <= effectiveRetries) {
+            effectiveHooks.onRetry?.(
+              request,
+              attempt - 1,
+              ctx.error,
+              ctx.response
+            );
+          }
+          return retrying;
+        };
+        let lastResponse = void 0;
+        try {
+          let res = await retry(
+            async () => {
               if (userSignal?.aborted) {
                 effectiveHooks.onAbort?.(request);
                 throw new AbortError("Request was aborted by user");
-              } else if (timeoutSignal?.aborted) {
+              }
+              if (timeoutSignal?.aborted) {
                 effectiveHooks.onTimeout?.(request);
                 throw new TimeoutError("signal timed out");
-              } else {
-                throw new AbortError(
-                  "Request was aborted",
-                  new DOMException("Aborted", "AbortError")
-                );
               }
-            }
-            const reqWithSignal = new Request(request, {
-              signal: combinedSignal
-            });
-            try {
-              const handler = init.fetchHandler ?? fetchHandler ?? fetch;
-              const response = await handler(reqWithSignal);
-              lastResponse = response;
-              pluginContext.metadata.retry.lastResponse = response;
-              return response;
-            } catch (err) {
-              pluginContext.metadata.retry.lastError = err;
-              if (err instanceof DOMException && err.name === "AbortError") {
-                if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {
-                  effectiveHooks.onTimeout?.(request);
-                  throw new TimeoutError("signal timed out", err);
-                } else if (userSignal?.aborted) {
+              if (typeof combinedSignal?.throwIfAborted === "function") {
+                combinedSignal.throwIfAborted();
+              } else if (combinedSignal?.aborted) {
+                if (userSignal?.aborted) {
                   effectiveHooks.onAbort?.(request);
                   throw new AbortError("Request was aborted by user");
+                } else if (timeoutSignal?.aborted) {
+                  effectiveHooks.onTimeout?.(request);
+                  throw new TimeoutError("signal timed out");
                 } else {
                   throw new AbortError(
                     "Request was aborted",
                     new DOMException("Aborted", "AbortError")
                   );
                 }
-              } else if (err instanceof TypeError && /NetworkError|network error|failed to fetch|lost connection|NetworkError when attempting to fetch resource/i.test(
-                err.message
-              )) {
-                throw new NetworkError(err.message, err);
               }
-              throw err;
-            }
-          },
-          effectiveRetries,
-          effectiveRetryDelay,
-          shouldRetryWithHook,
-          request,
-          combinedSignal
-        );
-        if (effectiveHooks.transformResponse) {
-          res = await effectiveHooks.transformResponse(res, request);
-        }
-        await effectiveHooks.after?.(request, res);
-        await effectiveHooks.onComplete?.(request, res, void 0);
-        if (effectiveThrowOnHttpError && (res.status >= 400 && res.status < 500 && res.status !== 429 || res.status >= 500 || res.status === 429)) {
-          const { HttpError } = await import("./error-XBHPSMAQ.js");
-          throw new HttpError(
-            `HTTP error: ${res.status} ${res.statusText}`,
-            res
+              const reqWithSignal = new Request(request, {
+                signal: combinedSignal
+              });
+              try {
+                const handler = init.fetchHandler ?? fetchHandler ?? fetch;
+                const response = await handler(reqWithSignal);
+                lastResponse = response;
+                pluginContext.metadata.retry.lastResponse = response;
+                return response;
+              } catch (err) {
+                pluginContext.metadata.retry.lastError = err;
+                if (err instanceof DOMException && err.name === "AbortError") {
+                  if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {
+                    effectiveHooks.onTimeout?.(request);
+                    throw new TimeoutError("signal timed out", err);
+                  } else if (userSignal?.aborted) {
+                    effectiveHooks.onAbort?.(request);
+                    throw new AbortError("Request was aborted by user");
+                  } else {
+                    throw new AbortError(
+                      "Request was aborted",
+                      new DOMException("Aborted", "AbortError")
+                    );
+                  }
+                } else if (err instanceof TypeError && /NetworkError|network error|failed to fetch|lost connection|NetworkError when attempting to fetch resource/i.test(
+                  err.message
+                )) {
+                  throw new NetworkError(err.message, err);
+                }
+                throw err;
+              }
+            },
+            effectiveRetries,
+            effectiveRetryDelay,
+            shouldRetryWithHook,
+            request,
+            combinedSignal
           );
-        }
-        return res;
-      } catch (err) {
-        pluginContext.metadata.retry.lastError = err;
-        if (lastResponse) {
-          const resp = lastResponse;
-          if (effectiveThrowOnHttpError && (resp.status >= 400 && resp.status < 500 && resp.status !== 429 || resp.status >= 500 || resp.status === 429)) {
-            const { HttpError } = await import("./error-XBHPSMAQ.js");
-            throw new HttpError(
-              `HTTP error: ${resp.status} ${resp.statusText}`,
-              resp
+          if (effectiveHooks.transformResponse) {
+            res = await effectiveHooks.transformResponse(res, request);
+          }
+          await effectiveHooks.after?.(request, res);
+          await effectiveHooks.onComplete?.(request, res, void 0);
+          if (effectiveThrowOnHttpError && (res.status >= 400 && res.status < 500 && res.status !== 429 || res.status >= 500 || res.status === 429)) {
+            const { HttpError: HttpError2 } = await import("./error-XBHPSMAQ.js");
+            throw new HttpError2(
+              `HTTP error: ${res.status} ${res.statusText}`,
+              res
             );
           }
-          return resp;
+          return res;
+        } catch (err) {
+          pluginContext.metadata.retry.lastError = err;
+          if (lastResponse) {
+            const resp = lastResponse;
+            if (effectiveThrowOnHttpError && (resp.status >= 400 && resp.status < 500 && resp.status !== 429 || resp.status >= 500 || resp.status === 429)) {
+              const { HttpError: HttpError2 } = await import("./error-XBHPSMAQ.js");
+              throw new HttpError2(
+                `HTTP error: ${resp.status} ${resp.statusText}`,
+                resp
+              );
+            }
+            return resp;
+          }
+          if (err instanceof TimeoutError) {
+            await effectiveHooks.onTimeout?.(request);
+            await effectiveHooks.onError?.(request, err);
+            await effectiveHooks.onComplete?.(request, void 0, err);
+            throw err;
+          }
+          if (err instanceof AbortError) {
+            await effectiveHooks.onAbort?.(request);
+            await effectiveHooks.onError?.(request, err);
+            await effectiveHooks.onComplete?.(request, void 0, err);
+            throw err;
+          }
+          if (err instanceof NetworkError) {
+            await effectiveHooks.onError?.(request, err);
+            await effectiveHooks.onComplete?.(request, void 0, err);
+            throw err;
+          }
+          const retryErr = new RetryLimitError(
+            typeof err === "object" && err && "message" in err && typeof err.message === "string" ? err.message : "Retry limit reached",
+            err
+          );
+          await effectiveHooks.onError?.(request, retryErr);
+          await effectiveHooks.onComplete?.(request, void 0, retryErr);
+          throw retryErr;
         }
-        if (err instanceof TimeoutError) {
-          await effectiveHooks.onTimeout?.(request);
-          await effectiveHooks.onError?.(request, err);
-          await effectiveHooks.onComplete?.(request, void 0, err);
-          throw err;
+      };
+      const baseDispatch = async () => retryWithHooks();
+      let dispatch = baseDispatch;
+      for (let i = plugins.length - 1; i >= 0; i--) {
+        const plugin = plugins[i];
+        if (plugin.wrapDispatch) {
+          dispatch = plugin.wrapDispatch(dispatch);
         }
-        if (err instanceof AbortError) {
-          await effectiveHooks.onAbort?.(request);
-          await effectiveHooks.onError?.(request, err);
-          await effectiveHooks.onComplete?.(request, void 0, err);
-          throw err;
+      }
+      const actualPromise = dispatch(pluginContext).then(async (response) => {
+        for (const plugin of plugins) {
+          await plugin.onSuccess?.(pluginContext, response);
         }
-        if (err instanceof NetworkError) {
-          await effectiveHooks.onError?.(request, err);
-          await effectiveHooks.onComplete?.(request, void 0, err);
-          throw err;
+        return response;
+      }).catch(async (err) => {
+        for (const plugin of plugins) {
+          await plugin.onError?.(pluginContext, err);
         }
-        const retryErr = new RetryLimitError(
-          typeof err === "object" && err && "message" in err && typeof err.message === "string" ? err.message : "Retry limit reached",
-          err
-        );
-        await effectiveHooks.onError?.(request, retryErr);
-        await effectiveHooks.onComplete?.(request, void 0, retryErr);
-        throw retryErr;
-      }
+        throw err;
+      });
+      const pendingEntry = {
+        promise: actualPromise,
+        request,
+        controller
+      };
+      pendingRequests.push(pendingEntry);
+      return actualPromise.finally(async () => {
+        for (const plugin of plugins) {
+          await plugin.onFinally?.(pluginContext);
+        }
+        const index = pendingRequests.indexOf(pendingEntry);
+        if (index > -1) {
+          pendingRequests.splice(index, 1);
+        }
+      });
     };
-    const baseDispatch = async () => retryWithHooks();
-    let dispatch = baseDispatch;
-    for (let i = plugins.length - 1; i >= 0; i--) {
-      const plugin = plugins[i];
-      if (plugin.wrapDispatch) {
-        dispatch = plugin.wrapDispatch(dispatch);
+    let promise = execute();
+    for (const plugin of plugins) {
+      if (plugin.decoratePromise) {
+        promise = plugin.decoratePromise(promise);
       }
     }
-    const actualPromise = dispatch(pluginContext).then(async (response) => {
-      for (const plugin of plugins) {
-        await plugin.onSuccess?.(pluginContext, response);
-      }
-      return response;
-    }).catch(async (err) => {
-      for (const plugin of plugins) {
-        await plugin.onError?.(pluginContext, err);
-      }
-      throw err;
-    });
-    const pendingEntry = {
-      promise: actualPromise,
-      request,
-      controller
-    };
-    pendingRequests.push(pendingEntry);
-    return actualPromise.finally(async () => {
-      for (const plugin of plugins) {
-        await plugin.onFinally?.(pluginContext);
-      }
-      const index = pendingRequests.indexOf(pendingEntry);
-      if (index > -1) {
-        pendingRequests.splice(index, 1);
-      }
-    });
+    return promise;
   };
   Object.defineProperty(client, "pendingRequests", {
     get() {
@@ -394,6 +404,7 @@ function createClient(opts = {}) {
 export {
   AbortError,
   CircuitOpenError,
+  HttpError,
   NetworkError,
   RetryLimitError,
   TimeoutError,