@torthu/jacketui-bring 0.0.1 → 0.1.0

package/dist/bring.js

@@ -1,7 +1,7 @@
 import { success, failure, withResolvers, } from "@torthu/jacketui-core";
 import { isClientErrorResponse } from "./types/ClientErrorResponse";
 import { isServerErrorResponse } from "./types/ServerErrorResponse";
-import { AbortError, ClientError, BringError, ServerError, TimeoutError, } from "./errors";
+import { AbortError, ClientError, BringError, NetworkError, ServerError, TimeoutError, } from "./errors";
 import { tryFetch } from "./tryFetch";
 /** bring({url: string | URL})
  *
@@ -40,7 +40,7 @@ import { tryFetch } from "./tryFetch";
 export const bring = (init) => {
     if (init instanceof BringError)
         init = init.requestInit;
-    const { url, abortController = new AbortController(), timeout = 0, retry = 0, onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError, ...requestInit } = init;
+    const { url, abortController = new AbortController(), timeout = 0, retry = 0, onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError, onNetworkError, ...requestInit } = init;
     // Configure promise
     const { promise, resolve } = withResolvers();
     const abortablePromise = promise;
@@ -60,49 +60,52 @@ export const bring = (init) => {
                         method: requestInit.method ?? "GET",
                         reason: abortController.signal.reason,
                     },
+                    cause: error,
                     url,
                     requestInit: init,
                 });
-                resolve(failure(abortError));
                 onAbort?.(abortError);
                 onError?.(abortError);
-                return;
+                return resolve(failure(abortError));
             }
             if (timeoutSignal?.aborted) {
-                const error = new TimeoutError("Timeout", {
-                    context: { reason: timeoutSignal.reason, timeout },
+                const timeoutError = new TimeoutError("Timeout", {
+                    context: {
+                        reason: timeoutSignal.reason,
+                        timeout,
+                    },
+                    cause: error,
                     url,
                     requestInit: init,
                 });
-                resolve(failure(error));
-                onTimeout?.(error);
-                onError?.(error);
-                return;
+                onTimeout?.(timeoutError);
+                onError?.(timeoutError);
+                return resolve(failure(error));
             }
             if (error instanceof Error) {
-                resolve(failure(new BringError(error.message, {
-                    cause: error,
+                const networkError = new NetworkError(error.message, {
                     context: { url, method: requestInit.method ?? "GET" },
+                    cause: error,
                     url,
                     requestInit: init,
-                })));
-                return;
+                });
+                onError?.(networkError);
+                return resolve(failure(networkError));
             }
             if (typeof error === "string") {
-                resolve(failure(new BringError(error, { url, requestInit: init })));
-                return;
+                return resolve(failure(new BringError(error, { url, requestInit: init })));
             }
-            resolve(failure(new BringError("Unknown error", { url, requestInit: init })));
+            return resolve(failure(new BringError("Unknown error", { url, requestInit: init })));
         }
         else {
             const response = value;
             if (response.ok) {
-                resolve(success(response));
                 onSuccess?.(response);
+                return resolve(success(response));
             }
             else {
                 if (isClientErrorResponse(response)) {
-                    return failure(new ClientError(response.statusText, {
+                    const clientError = new ClientError(response.statusText, {
                         context: {
                             status: response.status,
                             statusText: response.statusText,
@@ -110,10 +113,13 @@ export const bring = (init) => {
                         response,
                         requestInit: init,
                         url,
-                    }));
+                    });
+                    onClientError?.(clientError);
+                    onError?.(clientError);
+                    return resolve(failure(clientError));
                 }
                 if (isServerErrorResponse(response)) {
-                    return failure(new ServerError(response.statusText, {
+                    const serverError = new ServerError(response.statusText, {
                         response,
                         requestInit: init,
                         url,
@@ -121,9 +127,12 @@ export const bring = (init) => {
                             status: response.status,
                             statusText: response.statusText,
                         },
-                    }));
+                    });
+                    onServerError?.(serverError);
+                    onError?.(serverError);
+                    return resolve(failure(serverError));
                 }
-                const error = new BringError("Fetch failed", {
+                const unknownError = new BringError("Fetch failed", {
                     context: {
                         url,
                         status: response.status,
@@ -133,8 +142,8 @@ export const bring = (init) => {
                     requestInit: init,
                     response,
                 });
-                resolve(failure(error));
-                onError?.(error);
+                onError?.(unknownError);
+                return resolve(failure(unknownError));
             }
         }
     });

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./bring";
 export * from "./tryFetch";
 export * from "./errors";
-export * from "./pipe-helpers";
+export * from "./request-builder-pipe";
+export * from "./response-pipe";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./bring";
 export * from "./tryFetch";
 export * from "./errors";
-export * from "./pipe-helpers";
+export * from "./request-builder-pipe";
+export * from "./response-pipe";

package/dist/response-pipe/arrayBuffer.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+/** arrayBuffer(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.arrayBuffer().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<ArrayBuffer, BringError>>
+ */
+export declare const arrayBuffer: (result: Result<Response, BringError>) => Promise<import("@torthu/jacketui-core").Failure<BringError> | import("@torthu/jacketui-core").Success<ArrayBuffer>>;

package/dist/response-pipe/arrayBuffer.js

@@ -0,0 +1,17 @@
+import { success } from "@torthu/jacketui-core";
+/** arrayBuffer(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.arrayBuffer().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<ArrayBuffer, BringError>>
+ */
+export const arrayBuffer = async (result) => {
+    if (result.ok) {
+        const res = await result.value.arrayBuffer();
+        return success(res);
+    }
+    else {
+        return result;
+    }
+};

package/dist/response-pipe/blob.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+/** blob(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.blob().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<Blob, BringError>>
+ */
+export declare const blob: (result: Result<Response, BringError>) => Promise<import("@torthu/jacketui-core").Failure<BringError> | import("@torthu/jacketui-core").Success<Blob>>;

package/dist/response-pipe/blob.js

@@ -0,0 +1,17 @@
+import { success } from "@torthu/jacketui-core";
+/** blob(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.blob().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<Blob, BringError>>
+ */
+export const blob = async (result) => {
+    if (result.ok) {
+        const res = await result.value.blob();
+        return success(res);
+    }
+    else {
+        return result;
+    }
+};

package/dist/response-pipe/bytes.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+/** bytes(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.bytes().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<Uint8Array, BringError>>
+ */
+export declare const bytes: (result: Result<Response, BringError>) => Promise<import("@torthu/jacketui-core").Failure<BringError> | import("@torthu/jacketui-core").Success<Uint8Array<ArrayBufferLike>>>;

package/dist/response-pipe/bytes.js

@@ -0,0 +1,17 @@
+import { success } from "@torthu/jacketui-core";
+/** bytes(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.bytes().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<Uint8Array, BringError>>
+ */
+export const bytes = async (result) => {
+    if (result.ok) {
+        const res = await result.value.bytes();
+        return success(res);
+    }
+    else {
+        return result;
+    }
+};

package/dist/response-pipe/formData.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+/** formData(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.formData().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<FormData, BringError>>
+ */
+export declare const formData: (result: Result<Response, BringError>) => Promise<import("@torthu/jacketui-core").Failure<BringError> | import("@torthu/jacketui-core").Success<FormData>>;

package/dist/response-pipe/formData.js

@@ -0,0 +1,17 @@
+import { success } from "@torthu/jacketui-core";
+/** formData(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.formData().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<FormData, BringError>>
+ */
+export const formData = async (result) => {
+    if (result.ok) {
+        const res = await result.value.formData();
+        return success(res);
+    }
+    else {
+        return result;
+    }
+};

package/dist/response-pipe/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./arrayBuffer";
+export * from "./blob";
+export * from "./bytes";
+export * from "./formData";
+export * from "./json";
+export * from "./text";

package/dist/response-pipe/index.js

@@ -0,0 +1,6 @@
+export * from "./arrayBuffer";
+export * from "./blob";
+export * from "./bytes";
+export * from "./formData";
+export * from "./json";
+export * from "./text";

package/dist/response-pipe/json.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+/** json(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.json().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<T, BringError>>
+ */
+export declare const json: <T = unknown>(result: Result<Response, BringError>) => Promise<import("@torthu/jacketui-core").Failure<BringError> | import("@torthu/jacketui-core").Success<T>>;

package/dist/response-pipe/json.js

@@ -0,0 +1,17 @@
+import { success } from "@torthu/jacketui-core";
+/** json(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.json().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<T, BringError>>
+ */
+export const json = async (result) => {
+    if (result.ok) {
+        const json = await result.value.json();
+        return success(json);
+    }
+    else {
+        return result;
+    }
+};

package/dist/response-pipe/text.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+/** text(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.text().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<string, BringError>>
+ */
+export declare const text: (result: Result<Response, BringError>) => Promise<import("@torthu/jacketui-core").Failure<BringError> | import("@torthu/jacketui-core").Success<string>>;

package/dist/response-pipe/text.js

@@ -0,0 +1,17 @@
+import { success } from "@torthu/jacketui-core";
+/** text(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.text().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<string, BringError>>
+ */
+export const text = async (result) => {
+    if (result.ok) {
+        const res = await result.value.text();
+        return success(res);
+    }
+    else {
+        return result;
+    }
+};

package/dist/types/BringInit.d.ts

@@ -1,13 +1,14 @@
-import { AbortError, BringError, TimeoutError } from "../errors";
+import { AbortError, BringError, ClientError, NetworkError, ServerError, TimeoutError } from "../errors";
 type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
 export interface BringCallbacks {
     onAbort?: (error: AbortError) => void;
+    onNetworkError?: (error: NetworkError) => void;
     onError?: (error: BringError) => void;
     onRetry?: (retryNum: number) => void;
     onSuccess?: (response: Response) => void;
     onTimeout?: (error: TimeoutError) => void;
-    onClientError?: (response: Response) => void;
-    onServerError?: (response: Response) => void;
+    onClientError?: (error: ClientError) => void;
+    onServerError?: (error: ServerError) => void;
 }
 export interface RequestInit {
     method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torthu/jacketui-bring",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Improved fetch API with retry, timeout, and more.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,8 +9,9 @@
     "email": "torstein@thune.io",
     "url": "https://thune.io"
   },
-  "peerDependencies": {},
-  "devDependencies": {},
+  "devDependencies": {
+    "fetch-mock": "^12.5.2"
+  },
   "dependencies": {
     "@torthu/jacketui-core": "latest"
   },

package/src/bring.ts

@@ -69,6 +69,7 @@ export const bring = (init: BringInit | BringError) => {
     onTimeout,
     onClientError,
     onServerError,
+    onNetworkError,
     ...requestInit
   } = init;
 
@@ -102,83 +103,90 @@ export const bring = (init: BringInit | BringError) => {
             method: requestInit.method ?? "GET",
             reason: abortController.signal.reason,
           },
+          cause: error,
           url,
           requestInit: init,
         });
-        resolve(failure(abortError));
+
         onAbort?.(abortError);
         onError?.(abortError);
-        return;
+        return resolve(failure(abortError));
       }
+
       if (timeoutSignal?.aborted) {
-        const error = new TimeoutError("Timeout", {
-          context: { reason: timeoutSignal.reason, timeout },
+        const timeoutError = new TimeoutError("Timeout", {
+          context: {
+            reason: timeoutSignal.reason,
+            timeout,
+          },
+          cause: error,
           url,
           requestInit: init,
         });
-        resolve(failure(error));
-        onTimeout?.(error);
-        onError?.(error);
-        return;
+
+        onTimeout?.(timeoutError);
+        onError?.(timeoutError);
+        return resolve(failure(error));
       }
 
       if (error instanceof Error) {
-        resolve(
-          failure(
-            new BringError(error.message, {
-              cause: error,
-              context: { url, method: requestInit.method ?? "GET" },
-              url,
-              requestInit: init,
-            })
-          )
-        );
-        return;
+        const networkError = new NetworkError(error.message, {
+          context: { url, method: requestInit.method ?? "GET" },
+          cause: error,
+          url,
+          requestInit: init,
+        });
+
+        onError?.(networkError);
+        return resolve(failure(networkError));
       }
 
       if (typeof error === "string") {
-        resolve(failure(new BringError(error, { url, requestInit: init })));
-        return;
+        return resolve(
+          failure(new BringError(error, { url, requestInit: init }))
+        );
       }
 
-      resolve(
+      return resolve(
         failure(new BringError("Unknown error", { url, requestInit: init }))
       );
     } else {
-      const response = value!;
+      const response = value;
 
       if (response.ok) {
-        resolve(success(response));
         onSuccess?.(response);
+        return resolve(success(response));
       } else {
         if (isClientErrorResponse(response)) {
-          return failure(
-            new ClientError(response.statusText, {
-              context: {
-                status: response.status,
-                statusText: response.statusText,
-              },
-              response,
-              requestInit: init,
-              url,
-            })
-          );
+          const clientError = new ClientError(response.statusText, {
+            context: {
+              status: response.status,
+              statusText: response.statusText,
+            },
+            response,
+            requestInit: init,
+            url,
+          });
+          onClientError?.(clientError);
+          onError?.(clientError);
+          return resolve(failure(clientError));
         }
         if (isServerErrorResponse(response)) {
-          return failure(
-            new ServerError(response.statusText, {
-              response,
-              requestInit: init,
-              url,
-              context: {
-                status: response.status,
-                statusText: response.statusText,
-              },
-            })
-          );
+          const serverError = new ServerError(response.statusText, {
+            response,
+            requestInit: init,
+            url,
+            context: {
+              status: response.status,
+              statusText: response.statusText,
+            },
+          });
+          onServerError?.(serverError);
+          onError?.(serverError);
+          return resolve(failure(serverError));
         }
 
-        const error = new BringError("Fetch failed", {
+        const unknownError = new BringError("Fetch failed", {
           context: {
             url,
             status: response.status,
@@ -188,8 +196,9 @@ export const bring = (init: BringInit | BringError) => {
           requestInit: init,
           response,
         });
-        resolve(failure(error));
-        onError?.(error);
+
+        onError?.(unknownError);
+        return resolve(failure(unknownError));
       }
     }
   });

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./bring";
 export * from "./tryFetch";
 export * from "./errors";
-export * from "./pipe-helpers";
+export * from "./request-builder-pipe";
+export * from "./response-pipe";

package/src/response-pipe/arrayBuffer.ts

@@ -0,0 +1,18 @@
+import { Result, success } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+
+/** arrayBuffer(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.arrayBuffer().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<ArrayBuffer, BringError>>
+ */
+export const arrayBuffer = async (result: Result<Response, BringError>) => {
+  if (result.ok) {
+    const res = await result.value.arrayBuffer();
+    return success(res);
+  } else {
+    return result;
+  }
+};

package/src/response-pipe/blob.ts

@@ -0,0 +1,18 @@
+import { Result, success } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+
+/** blob(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.blob().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<Blob, BringError>>
+ */
+export const blob = async (result: Result<Response, BringError>) => {
+  if (result.ok) {
+    const res = await result.value.blob();
+    return success(res);
+  } else {
+    return result;
+  }
+};

package/src/response-pipe/bytes.ts

@@ -0,0 +1,18 @@
+import { Result, success } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+
+/** bytes(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.bytes().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<Uint8Array, BringError>>
+ */
+export const bytes = async (result: Result<Response, BringError>) => {
+  if (result.ok) {
+    const res = await result.value.bytes();
+    return success(res);
+  } else {
+    return result;
+  }
+};

package/src/response-pipe/formData.ts

@@ -0,0 +1,18 @@
+import { Result, success } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+
+/** formData(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.formData().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<FormData, BringError>>
+ */
+export const formData = async (result: Result<Response, BringError>) => {
+  if (result.ok) {
+    const res = await result.value.formData();
+    return success(res);
+  } else {
+    return result;
+  }
+};

package/src/response-pipe/index.ts

@@ -0,0 +1,6 @@
+export * from "./arrayBuffer";
+export * from "./blob";
+export * from "./bytes";
+export * from "./formData";
+export * from "./json";
+export * from "./text";

package/src/response-pipe/json.ts

@@ -0,0 +1,20 @@
+import { Result, success } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+
+/** json(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.json().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<T, BringError>>
+ */
+export const json = async <T = unknown>(
+  result: Result<Response, BringError>
+) => {
+  if (result.ok) {
+    const json = await result.value.json();
+    return success(json as T);
+  } else {
+    return result;
+  }
+};

package/src/response-pipe/text.ts

@@ -0,0 +1,18 @@
+import { Result, success } from "@torthu/jacketui-core";
+import { BringError } from "../errors";
+
+/** text(result: Result<Response, BringError>)
+ *
+ * Utility function to await Response.text().
+ *
+ * @param result Result<Response, BringError>
+ * @returns Promise<Result<string, BringError>>
+ */
+export const text = async (result: Result<Response, BringError>) => {
+  if (result.ok) {
+    const res = await result.value.text();
+    return success(res);
+  } else {
+    return result;
+  }
+};

package/src/types/BringInit.ts

@@ -1,4 +1,11 @@
-import { AbortError, BringError, TimeoutError } from "../errors";
+import {
+  AbortError,
+  BringError,
+  ClientError,
+  NetworkError,
+  ServerError,
+  TimeoutError,
+} from "../errors";
 
 type TypedArray =
   | Int8Array
@@ -15,12 +22,13 @@ type TypedArray =
 
 export interface BringCallbacks {
   onAbort?: (error: AbortError) => void;
+  onNetworkError?: (error: NetworkError) => void;
   onError?: (error: BringError) => void;
   onRetry?: (retryNum: number) => void;
   onSuccess?: (response: Response) => void;
   onTimeout?: (error: TimeoutError) => void;
-  onClientError?: (response: Response) => void;
-  onServerError?: (response: Response) => void;
+  onClientError?: (error: ClientError) => void;
+  onServerError?: (error: ServerError) => void;
 }
 
 export interface RequestInit {

package/test/bring.spec.ts

@@ -0,0 +1,149 @@
+import {
+  describe,
+  expect,
+  it,
+  beforeAll,
+  afterAll,
+  afterEach,
+  vi,
+} from "vitest";
+import fetchMock from "fetch-mock";
+import {
+  AbortError,
+  bring,
+  ClientError,
+  ServerError,
+  TimeoutError,
+} from "../src";
+import { isResult } from "@torthu/jacketui-core";
+
+describe("bring", () => {
+  beforeAll(() => {
+    fetchMock.mockGlobal();
+  });
+
+  afterEach(() => {
+    fetchMock.removeRoutes();
+  });
+
+  afterAll(() => {
+    fetchMock.unmockGlobal();
+  });
+
+  it("should return a Response wrapped in Result", async () => {
+    fetchMock.get("http://example.com", 200);
+
+    const response = await bring({ url: "http://example.com" });
+
+    expect(isResult(response)).toBe(true);
+    expect(response.ok).toBe(true);
+    expect(response.value).toBeInstanceOf(Response);
+
+    fetchMock.removeRoute("http://example.com");
+  });
+
+  it("server error should return an Error wrapped in Result", async () => {
+    fetchMock.get("http://example.com", 500);
+
+    const response = await bring({
+      url: "http://example.com",
+      retry: 1,
+      timeout: 100,
+      onError: () => console.log("error"),
+      onRetry: () => console.log("retrying"),
+      onTimeout: () => console.log("timeout"),
+      onClientError: () => console.log("client error"),
+      onServerError: () => console.log("server error"),
+      onAbort: () => console.log("aborted"),
+      onSuccess: () => console.log("success"),
+    });
+
+    console.log(response);
+
+    expect(isResult(response)).toBe(true);
+    expect(response.ok).toBe(false);
+    expect(response.error).toBeInstanceOf(ServerError);
+  });
+
+  it("client error should return an Error wrapped in Result", async () => {
+    fetchMock.get("http://example.com", 400);
+    const response = await bring({ url: "http://example.com" });
+    expect(isResult(response)).toBe(true);
+    expect(response.ok).toBe(false);
+    expect(response.error).toBeInstanceOf(ClientError);
+  });
+
+  it("client error should return an Error wrapped in Result", async () => {
+    fetchMock.get("http://example.com", 400);
+    const response = await bring({ url: "http://example.com" });
+    expect(isResult(response)).toBe(true);
+    expect(response.ok).toBe(false);
+    expect(response.error).toBeInstanceOf(ClientError);
+  });
+
+  it("should timeout", async () => {
+    fetchMock.get("http://foo.bar.com", 200, {
+      delay: 5000,
+    });
+
+    const retryCb = vi.fn();
+
+    const response = await bring({
+      url: "http://foo.bar.com",
+      timeout: 10,
+      onRetry: retryCb,
+      retry: 3,
+    });
+
+    expect(isResult(response)).toBe(true);
+    expect(response.ok).toBe(false);
+    expect(response.error).toBeInstanceOf(TimeoutError);
+    expect(retryCb).toHaveBeenCalledTimes(3);
+  });
+
+  it("should retry", async () => {
+    fetchMock.get("http://foo.bar.com", 200, {
+      delay: 5000,
+    });
+
+    const retryCb = vi.fn();
+
+    const response = await bring({
+      url: "http://foo.bar.com",
+      timeout: 10,
+      onRetry: retryCb,
+      retry: 3,
+    });
+
+    expect(isResult(response)).toBe(true);
+    expect(response.ok).toBe(false);
+    expect(response.error).toBeInstanceOf(TimeoutError);
+    expect(retryCb).toHaveBeenCalledTimes(3);
+  });
+
+  it("should abort", () =>
+    new Promise<void>((done) => {
+      fetchMock.get("http://foo.bar.com", 200, {
+        delay: 5000,
+      });
+
+      const abortController = new AbortController();
+      let response;
+
+      const promise = bring({
+        url: "http://foo.bar.com",
+        timeout: 10,
+        abortController,
+      });
+
+      promise.then((res) => {
+        response = res;
+        expect(isResult(response)).toBe(true);
+        expect(response.ok).toBe(false);
+        expect(response.error).toBeInstanceOf(AbortError);
+        done();
+      });
+
+      abortController.abort();
+    }));
+});