@torthu/jacketui-bring 0.2.5 → 1.0.0

package/README.md

@@ -7,5 +7,3 @@ Bring is a fetch wrapper that provides a simple API for making HTTP requests. It
 We want flexibility in our components and escape hatches in order to solve edge cases and make components truly expandable and reusable.
 
 In order to achieve this we need to create flexible components, meaning expandable and full of escape hatches in order to cater for edge cases.
-
-## In practice

package/dist/bring.js

@@ -1,8 +1,8 @@
 import { success, failure, withResolvers, } from "@torthu/jacketui-core";
-import { isClientErrorResponse } from "./types/ClientErrorResponse";
-import { isServerErrorResponse } from "./types/ServerErrorResponse";
-import { AbortError, ClientError, BringError, NetworkError, ServerError, TimeoutError, } from "./errors";
-import { tryFetch } from "./tryFetch";
+import { isClientErrorResponse } from "./types/ClientErrorResponse.js";
+import { isServerErrorResponse } from "./types/ServerErrorResponse.js";
+import { AbortError, ClientError, BringError, NetworkError, ServerError, TimeoutError, } from "./errors/index.js";
+import { tryFetch } from "./tryFetch.js";
 /** bring({url: string | URL})
  *
  * A wrapper around the fetch API that adds support for timeouts, retries, and aborts.
@@ -89,6 +89,7 @@ export const bring = (init) => {
                     url,
                     requestInit: init,
                 });
+                onNetworkError?.(networkError);
                 onError?.(networkError);
                 return resolve(failure(networkError));
             }

package/dist/errors/AbortError.js

@@ -1,4 +1,4 @@
-import { BringError } from "./BringError";
+import { BringError } from "./BringError.js";
 export class AbortError extends BringError {
     tag = "AbortError";
 }

package/dist/errors/ClientError.js

@@ -1,4 +1,4 @@
-import { BringError } from "./BringError";
+import { BringError } from "./BringError.js";
 export class ClientError extends BringError {
     tag = "ClientError";
 }

package/dist/errors/NetworkError.js

@@ -1,4 +1,4 @@
-import { BringError } from "./BringError";
+import { BringError } from "./BringError.js";
 export class NetworkError extends BringError {
     tag = "NetworkError";
 }

package/dist/errors/ServerError.js

@@ -1,4 +1,4 @@
-import { BringError } from "./BringError";
+import { BringError } from "./BringError.js";
 export class ServerError extends BringError {
     tag = "ServerError";
 }

package/dist/errors/TimeoutError.js

@@ -1,4 +1,4 @@
-import { BringError } from "./BringError";
+import { BringError } from "./BringError.js";
 export class TimeoutError extends BringError {
     tag = "TimeoutError";
 }

package/dist/errors/index.js

@@ -1,6 +1,6 @@
-export * from "./AbortError";
-export * from "./ClientError";
-export * from "./BringError";
-export * from "./NetworkError";
-export * from "./ServerError";
-export * from "./TimeoutError";
+export * from "./AbortError.js";
+export * from "./ClientError.js";
+export * from "./BringError.js";
+export * from "./NetworkError.js";
+export * from "./ServerError.js";
+export * from "./TimeoutError.js";

package/dist/fetch.js

@@ -1,4 +1,4 @@
-import { bring } from "./bring";
+import { bring } from "./bring.js";
 /** fetch(url: string, init?: Omit<BringInit, "url">): AbortablePromise<Result<Response, BringError>>
  *
  * Wraps bring in a fetch-like API.

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,6 @@
-export * from "./bring";
-export * from "./tryFetch";
-export * from "./errors";
-export * from "./request-builder-pipe";
-export * from "./response-pipe";
+export * from "./bring.js";
+export * from "./fetch.js";
+export * from "./tryFetch.js";
+export * from "./errors/index.js";
+export * from "./request-builder-pipe/index.js";
+export * from "./response-pipe/index.js";

package/dist/request-builder-pipe/headers.js

@@ -12,15 +12,24 @@
 export const headers = (headers) => {
     return (init) => {
         init.headers ??= new Headers();
+        const entries = [];
+        if (headers instanceof Headers) {
+            headers.forEach((value, key) => entries.push([key, value]));
+        }
+        else {
+            for (const [key, value] of Object.entries(headers)) {
+                entries.push([key, String(value)]);
+            }
+        }
         if (init.headers instanceof Headers) {
-            for (const [key, val] of Object.entries(headers)) {
+            for (const [key, val] of entries) {
                 !init.headers.has(key)
                     ? init.headers.append(key, val)
                     : init.headers.set(key, val);
             }
         }
         else {
-            for (const [key, val] of Object.entries(headers)) {
+            for (const [key, val] of entries) {
                 init.headers[key] = val;
             }
         }

package/dist/request-builder-pipe/index.d.ts

@@ -17,3 +17,4 @@ export * from "./url";
 export * from "./backoff";
 export * from "./jitter";
 export * from "./timeout";
+export * from "./shouldRetry";

package/dist/request-builder-pipe/index.js

@@ -1,19 +1,20 @@
-export * from "./cache";
-export * from "./cors";
-export * from "./credentials";
-export * from "./header";
-export * from "./headers";
-export * from "./integrity";
-export * from "./keepalive";
-export * from "./method";
-export * from "./redirect";
-export * from "./referrer";
-export * from "./referrerPolicy";
-export * from "./retry";
-export * from "./body";
-export * from "./jsonBody";
-export * from "./priority";
-export * from "./url";
-export * from "./backoff";
-export * from "./jitter";
-export * from "./timeout";
+export * from "./cache.js";
+export * from "./cors.js";
+export * from "./credentials.js";
+export * from "./header.js";
+export * from "./headers.js";
+export * from "./integrity.js";
+export * from "./keepalive.js";
+export * from "./method.js";
+export * from "./redirect.js";
+export * from "./referrer.js";
+export * from "./referrerPolicy.js";
+export * from "./retry.js";
+export * from "./body.js";
+export * from "./jsonBody.js";
+export * from "./priority.js";
+export * from "./url.js";
+export * from "./backoff.js";
+export * from "./jitter.js";
+export * from "./timeout.js";
+export * from "./shouldRetry.js";

package/dist/request-builder-pipe/jitter.js

@@ -11,5 +11,5 @@ import { randomJitter } from "../helpers/randomJitter";
  */
 export const jitter = (options) => {
     const jitterFun = () => randomJitter(options);
-    return (init) => ({ ...init, backoff: jitterFun });
+    return (init) => ({ ...init, jitter: jitterFun });
 };

package/dist/response-pipe/index.js

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

package/dist/tryFetch.js

@@ -1,7 +1,11 @@
 import { failure, sleep, success, tryAwait, } from "@torthu/jacketui-core";
+const shouldRetryFailure = (response, init, retryNum) => response ? init.shouldRetry?.(response, retryNum) ?? false : true;
 export const tryFetch = async (url, requestInit, init, retryCount = 0) => {
     const { error, value } = await tryAwait(fetch(url, requestInit));
-    if (error && retryCount < (init.retry ?? 0)) {
+    const maxRetries = init.retry ?? 0;
+    if (error &&
+        retryCount < maxRetries &&
+        shouldRetryFailure(undefined, init, retryCount)) {
         init.onRetry?.(retryCount);
         const backoff = init.backoff?.(retryCount) ?? 0;
         const jitter = init.jitter?.() ?? 0;
@@ -14,6 +18,18 @@ export const tryFetch = async (url, requestInit, init, retryCount = 0) => {
         return failure(error);
     }
     else {
+        if (!value.ok && retryCount < maxRetries) {
+            const shouldRetry = shouldRetryFailure(value, init, retryCount);
+            if (shouldRetry) {
+                init.onRetry?.(retryCount);
+                const backoff = init.backoff?.(retryCount) ?? 0;
+                const jitter = init.jitter?.() ?? 0;
+                if (backoff + jitter > 0) {
+                    await sleep(backoff + jitter);
+                }
+                return await tryFetch(url, requestInit, init, retryCount + 1);
+            }
+        }
         return success(value);
     }
 };

package/dist/types/BringInit.d.ts

@@ -1,5 +1,4 @@
 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;
@@ -12,7 +11,7 @@ export interface BringCallbacks {
 }
 export interface RequestInit {
     method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-    body?: string | ArrayBuffer | Blob | DataView | File | FormData | TypedArray | URLSearchParams | ReadableStream;
+    body?: BodyInit | null;
     cache?: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached";
     credentials?: "omit" | "same-origin" | "include";
     headers?: Record<string, string> | Headers;
@@ -35,4 +34,3 @@ export type BringInit = RequestInit & RetryBackoff & BringCallbacks & {
     url: string | URL;
     abortController?: AbortController;
 };
-export {};

package/package.json

@@ -1,24 +1,42 @@
 {
   "name": "@torthu/jacketui-bring",
-  "version": "0.2.5",
+  "version": "1.0.0",
   "description": "Improved fetch API with retry, timeout, and more.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "author": {
     "name": "Torstein Thune",
     "email": "torstein@thune.io",
     "url": "https://thune.io"
   },
-  "devDependencies": {
-    "fetch-mock": "^12.5.2"
+  "homepage": "https://code.thune.io/torstein/jacketui",
+  "repository": {
+    "type": "git",
+    "url": "git+https://code.thune.io/torstein/jacketui.git",
+    "directory": "packages/bring"
   },
-  "dependencies": {
-    "@torthu/jacketui-core": "latest"
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "scripts": {
     "prepublish": "npm run build",
-    "build": "rimraf ./dist && tsc",
-    "test": "vitest run"
+    "typecheck": "tsc --noEmit",
+    "build": "rimraf ./dist && tsc --project tsconfig.json && fix-imports --tsconfig tsconfig.json",
+    "test": "vitest run",
+    "coverage": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "fetch-mock": "12.6.0"
+  },
+  "dependencies": {
+    "@torthu/jacketui-core": "latest"
   },
   "license": "LGPL-3.0-only"
 }

package/src/bring.ts

@@ -1,207 +0,0 @@
-import {
-  Result,
-  success,
-  failure,
-  AbortablePromise,
-  withResolvers,
-} from "@torthu/jacketui-core";
-import { isClientErrorResponse } from "./types/ClientErrorResponse";
-import { BringInit } from "./types/BringInit";
-import { isInformationalResponse } from "./types/InformationalResponse";
-import { isRedirectResponse } from "./types/RedirectResponse";
-import { isServerErrorResponse } from "./types/ServerErrorResponse";
-import {
-  AbortError,
-  ClientError,
-  BringError,
-  NetworkError,
-  ServerError,
-  TimeoutError,
-} from "./errors";
-import { tryFetch } from "./tryFetch";
-
-/** bring({url: string | URL})
- *
- * A wrapper around the fetch API that adds support for timeouts, retries, and aborts.
- * It also adds support for custom error handling and success handling.
- * It returns a promise that resolves to a Result object.
- * The returned promise is extended with an abort method that can be used to abort the fetch request.
- *
- * The Result object contains either a Response object or a BringError.
- *
- * @param init {BringInit | BringError} RequestInit + retries, timeout, onSuccess, onError, onAbort, onRetry, onTimeout, onClientError, onServerError
- * @param init.url The URL to fetch.
- * @param init.abortController (optional) An AbortController object to abort the fetch request. (default: new AbortController())
- * @param init.timeout (optional) The timeout in milliseconds. (default: 0)
- * @param init.retry (optional) The number of times to retry the fetch request. (default: 0)
- * @param init.onSuccess (optional) A callback function that is called when the fetch request is successful.
- * @param init.onError (optional) A callback function that is called when the fetch request fails.
- * @param init.onAbort (optional) A callback function that is called when the fetch request is aborted.
- * @param init.onRetry (optional) A callback function that is called when the fetch request is retried.
- * @param init.onTimeout (optional) A callback function that is called when the fetch request times out.
- * @param init.onClientError (optional) A callback function that is called when the fetch request fails with a client error.
- * @param init.onServerError (optional) A callback function that is called when the fetch request fails with a server error.
- * @param init.body (optional) The body of the fetch request.
- * @param init.headers (optional) The headers of the fetch request.
- * @param init.method (optional) The method of the fetch request.
- * @param init.mode (optional) The mode of the fetch request.
- * @param init.credentials (optional) The credentials of the fetch request.
- * @param init.cache (optional) The cache of the fetch request.
- * @param init.redirect (optional) The redirect of the fetch request.
- * @param init.referrer (optional) The referrer of the fetch request.
- * @param init.referrerPolicy (optional) The referrerPolicy of the fetch request.
- * @param init.integrity (optional) The integrity of the fetch request.
- * @param init.keepalive (optional) The keepalive of the fetch request.
- * @returns AbortablePromise<Result<Response, BringError>>
- */
-export const bring = (init: BringInit | BringError) => {
-  if (init instanceof BringError) init = init.requestInit;
-
-  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 as AbortablePromise<
-    Result<Response, BringError>
-  >;
-  abortablePromise.abort = abortController.abort;
-
-  // Configure timeout signal
-  const timeoutSignal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
-  const signal = AbortSignal.any(
-    [abortController.signal, timeoutSignal].filter((s) => !!s)
-  );
-
-  tryFetch(
-    url,
-    {
-      ...requestInit,
-      signal,
-    },
-    init,
-    0
-  ).then(({ error, value }) => {
-    if (error) {
-      if (abortController.signal.aborted) {
-        const abortError = new AbortError(abortController.signal.reason, {
-          context: {
-            url: url,
-            method: requestInit.method ?? "GET",
-            reason: abortController.signal.reason,
-          },
-          cause: error,
-          url,
-          requestInit: init,
-        });
-
-        onAbort?.(abortError);
-        onError?.(abortError);
-        return resolve(failure(abortError));
-      }
-
-      if (timeoutSignal?.aborted) {
-        const timeoutError = new TimeoutError("Timeout", {
-          context: {
-            reason: timeoutSignal.reason,
-            timeout,
-          },
-          cause: error,
-          url,
-          requestInit: init,
-        });
-
-        onTimeout?.(timeoutError);
-        onError?.(timeoutError);
-        return resolve(failure(timeoutError));
-      }
-
-      if (error instanceof Error) {
-        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") {
-        return resolve(
-          failure(new BringError(error, { url, requestInit: init }))
-        );
-      }
-
-      return resolve(
-        failure(new BringError("Unknown error", { url, requestInit: init }))
-      );
-    } else {
-      const response = value;
-
-      if (response.ok) {
-        onSuccess?.(response);
-        return resolve(success(response));
-      } else {
-        if (isClientErrorResponse(response)) {
-          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)) {
-          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 unknownError = new BringError("Fetch failed", {
-          context: {
-            url,
-            status: response.status,
-            statusText: response.statusText,
-          },
-          url: url,
-          requestInit: init,
-          response,
-        });
-
-        onError?.(unknownError);
-        return resolve(failure(unknownError));
-      }
-    }
-  });
-
-  return abortablePromise;
-};

package/src/errors/AbortError.ts

@@ -1,18 +0,0 @@
-import { BringError } from "./BringError";
-
-export class AbortError extends BringError {
-  tag = "AbortError";
-}
-
-/** isAbortError
- *
- * Checks if error is AbortError.
- * An AbortError is either an instance of AbortError or a BringError with tag "AbortError".
- *
- */
-export const isAbortError = (error: unknown): error is AbortError => {
-  return (
-    error instanceof AbortError ||
-    (error instanceof BringError && error.tag === "AbortError")
-  );
-};

package/src/errors/BringError.ts

@@ -1,24 +0,0 @@
-import { BringInit } from "../types/BringInit";
-import { JuiError, JuiErrorOptions } from "@torthu/jacketui-core";
-
-export interface BringErrorOptions extends JuiErrorOptions {
-  response?: Response;
-  request?: Request;
-  requestInit: BringInit;
-  url: string | URL;
-}
-
-export class BringError extends JuiError {
-  public readonly response?: BringErrorOptions["response"];
-  public readonly request?: BringErrorOptions["request"];
-  public readonly requestInit: BringErrorOptions["requestInit"];
-  public readonly url: BringErrorOptions["url"];
-
-  constructor(message: string, options: BringErrorOptions) {
-    super(message, options);
-    this.response = options.response;
-    this.request = options.request;
-    this.requestInit = options.requestInit;
-    this.url = options.url;
-  }
-}

package/src/errors/ClientError.ts

@@ -1,24 +0,0 @@
-import { BringError } from "./BringError";
-
-export class ClientError extends BringError {
-  tag = "ClientError";
-}
-
-/** isClientError
- *
- * Checks if error is ClientError.
- * A ClientError is either an instance of ClientError or a BringError with a status code between 400 and 499.
- *
- */
-export const isClientError = (error: unknown): error is ClientError => {
-  if (error instanceof ClientError) {
-    return true;
-  }
-
-  return (
-    error instanceof BringError &&
-    !!error.response &&
-    error.response.status >= 400 &&
-    error.response.status < 500
-  );
-};

package/src/errors/NetworkError.ts

@@ -1,23 +0,0 @@
-import { BringError } from "./BringError";
-
-export class NetworkError extends BringError {
-  tag = "NetworkError";
-}
-
-/** isNetworkError
- *
- * Checks if error is NetworkError.
- * A NetworkError is either an instance of NetworkError or a BringError with status code 0.
- *
- */
-export const isNetworkError = (error: unknown): error is NetworkError => {
-  if (error instanceof NetworkError) {
-    return true;
-  }
-
-  return (
-    error instanceof BringError &&
-    !!error.response &&
-    error.response.status === 0
-  );
-};

package/src/errors/ServerError.ts

@@ -1,24 +0,0 @@
-import { BringError } from "./BringError";
-
-export class ServerError extends BringError {
-  tag = "ServerError";
-}
-
-/** isServerError
- *
- * Checks if error is ServerError.
- * A ServerError is either an instance of ServerError or a BringError with status code >= 500 and < 600.
- *
- */
-export const isServerError = (error: unknown): error is ServerError => {
-  if (error instanceof ServerError) {
-    return true;
-  }
-
-  return (
-    error instanceof BringError &&
-    !!error.response &&
-    error.response.status >= 500 &&
-    error.response.status < 600
-  );
-};

package/src/errors/TimeoutError.ts

@@ -1,18 +0,0 @@
-import { BringError } from "./BringError";
-
-export class TimeoutError extends BringError {
-  tag = "TimeoutError";
-}
-
-/** isTimeoutError
- *
- * Checks if error is TimeoutError.
- * A TimeoutError is either an instance of TimeoutError or a BringError with tag "TimeoutError".
- *
- */
-export const isTimeoutError = (error: unknown): error is TimeoutError => {
-  return (
-    error instanceof TimeoutError ||
-    (error instanceof BringError && error.tag === "TimeoutError")
-  );
-};

package/src/errors/index.ts

@@ -1,6 +0,0 @@
-export * from "./AbortError";
-export * from "./ClientError";
-export * from "./BringError";
-export * from "./NetworkError";
-export * from "./ServerError";
-export * from "./TimeoutError";