@fgrzl/fetch 1.4.0-alpha.2 → 1.4.0

package/dist/cjs/index.js

@@ -24,6 +24,16 @@ __export(index_exports, {
   FetchError: () => FetchError,
   HttpError: () => HttpError,
   NetworkError: () => NetworkError,
+  addAuthentication: () => addAuthentication,
+  addAuthorization: () => addAuthorization,
+  addBasicStack: () => addBasicStack,
+  addCSRF: () => addCSRF,
+  addCache: () => addCache,
+  addDevelopmentStack: () => addDevelopmentStack,
+  addLogging: () => addLogging,
+  addProductionStack: () => addProductionStack,
+  addRateLimit: () => addRateLimit,
+  addRetry: () => addRetry,
   appendQueryParams: () => appendQueryParams,
   buildQueryParams: () => buildQueryParams,
   createAuthenticationMiddleware: () => createAuthenticationMiddleware,
@@ -32,17 +42,7 @@ __export(index_exports, {
   createLoggingMiddleware: () => createLoggingMiddleware,
   createRateLimitMiddleware: () => createRateLimitMiddleware,
   createRetryMiddleware: () => createRetryMiddleware,
-  default: () => index_default,
-  useAuthentication: () => useAuthentication,
-  useAuthorization: () => useAuthorization,
-  useBasicStack: () => useBasicStack,
-  useCSRF: () => useCSRF,
-  useCache: () => useCache,
-  useDevelopmentStack: () => useDevelopmentStack,
-  useLogging: () => useLogging,
-  useProductionStack: () => useProductionStack,
-  useRateLimit: () => useRateLimit,
-  useRetry: () => useRetry
+  default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -52,6 +52,7 @@ var FetchClient = class {
     this.middlewares = [];
     this.credentials = config.credentials ?? "same-origin";
     this.baseUrl = config.baseUrl;
+    this.defaultTimeout = config.timeout;
   }
   use(middleware) {
     this.middlewares.push(middleware);
@@ -77,7 +78,7 @@ var FetchClient = class {
    *
    * @example Chain with middleware:
    * ```typescript
-   * const client = useProductionStack(new FetchClient())
+   * const client = addProductionStack(new FetchClient())
    *   .setBaseUrl(process.env.API_BASE_URL);
    * ```
    */
@@ -85,11 +86,31 @@ var FetchClient = class {
     this.baseUrl = baseUrl;
     return this;
   }
-  async request(url, init = {}) {
+  async request(url, init = {}, options) {
     const resolvedUrl = this.resolveUrl(url);
+    let timeoutId;
+    let timeoutController;
+    let effectiveSignal = options?.signal || init.signal;
+    const timeoutMs = options?.timeout ?? this.defaultTimeout;
+    if (timeoutMs && timeoutMs > 0) {
+      timeoutController = new AbortController();
+      if (effectiveSignal) {
+        effectiveSignal.addEventListener("abort", () => {
+          timeoutController?.abort();
+        });
+      }
+      effectiveSignal = timeoutController.signal;
+      timeoutId = setTimeout(() => {
+        timeoutController?.abort();
+      }, timeoutMs);
+    }
     let index = 0;
     const execute = async (request) => {
-      const currentRequest = request || { ...init, url: resolvedUrl };
+      const currentRequest = request || {
+        ...init,
+        url: resolvedUrl,
+        ...effectiveSignal ? { signal: effectiveSignal } : {}
+      };
       const currentUrl = currentRequest.url || resolvedUrl;
       if (index >= this.middlewares.length) {
         const { url: _, ...requestInit } = currentRequest;
@@ -102,8 +123,14 @@ var FetchClient = class {
       }
       return middleware(currentRequest, execute);
     };
-    const result = await execute();
-    return result;
+    try {
+      const result = await execute();
+      return result;
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
   }
   async coreFetch(request, url) {
     try {
@@ -135,6 +162,20 @@ var FetchClient = class {
         }
       };
     } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return {
+          data: null,
+          status: 0,
+          statusText: "Request Aborted",
+          headers: new Headers(),
+          url,
+          ok: false,
+          error: {
+            message: "Request was aborted",
+            body: error
+          }
+        };
+      }
       if (error instanceof TypeError && error.message.includes("fetch")) {
         return {
           data: null,
@@ -227,6 +268,7 @@ var FetchClient = class {
    * @template T - Expected response data type (will be null for HEAD requests)
    * @param url - Request URL
    * @param params - Query parameters to append to URL
+   * @param options - Request options (signal, timeout)
    * @returns Promise resolving to typed response (data will always be null)
    *
    * @example Check if resource exists:
@@ -239,17 +281,16 @@ var FetchClient = class {
    * }
    * ```
    *
-   * @example Check with query parameters:
+   * @example With cancellation:
    * ```typescript
-   * const exists = await client.head('/api/users', { id: 123 });
-   * if (exists.status === 404) {
-   *   console.log('User not found');
-   * }
+   * const controller = new AbortController();
+   * const request = client.head('/api/users', { id: 123 }, { signal: controller.signal });
+   * controller.abort(); // Cancel the request
    * ```
    */
-  head(url, params) {
+  head(url, params, options) {
     const finalUrl = this.buildUrlWithParams(url, params);
-    return this.request(finalUrl, { method: "HEAD" });
+    return this.request(finalUrl, { method: "HEAD" }, options);
   }
   /**
    * HEAD request that returns useful metadata about a resource.
@@ -292,6 +333,7 @@ var FetchClient = class {
    * @template T - Expected response data type
    * @param url - Request URL
    * @param params - Query parameters to append to URL
+   * @param options - Request options (signal, timeout)
    * @returns Promise resolving to typed response
    *
    * @example
@@ -300,10 +342,15 @@ var FetchClient = class {
    * const filteredUsers = await client.get<User[]>('/api/users', { status: 'active', limit: 10 });
    * if (users.ok) console.log(users.data);
    * ```
+   *
+   * @example With timeout:
+   * ```typescript
+   * const users = await client.get<User[]>('/api/users', {}, { timeout: 5000 });
+   * ```
    */
-  get(url, params) {
+  get(url, params, options) {
     const finalUrl = this.buildUrlWithParams(url, params);
-    return this.request(finalUrl, { method: "GET" });
+    return this.request(finalUrl, { method: "GET" }, options);
   }
   /**
    * POST request with automatic JSON serialization.
@@ -312,23 +359,35 @@ var FetchClient = class {
    * @param url - Request URL
    * @param body - Request body (auto-serialized to JSON)
    * @param headers - Additional headers (Content-Type: application/json is default)
+   * @param options - Request options (signal, timeout)
    * @returns Promise resolving to typed response
    *
    * @example
    * ```typescript
    * const result = await client.post<User>('/api/users', { name: 'John' });
    * ```
+   *
+   * @example With cancellation:
+   * ```typescript
+   * const controller = new AbortController();
+   * const result = client.post('/api/users', { name: 'John' }, {}, { signal: controller.signal });
+   * controller.abort();
+   * ```
    */
-  post(url, body, headers) {
+  post(url, body, headers, options) {
     const requestHeaders = {
       "Content-Type": "application/json",
       ...headers ?? {}
     };
-    return this.request(url, {
-      method: "POST",
-      headers: requestHeaders,
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-    });
+    return this.request(
+      url,
+      {
+        method: "POST",
+        headers: requestHeaders,
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      },
+      options
+    );
   }
   /**
    * PUT request with automatic JSON serialization.
@@ -337,18 +396,23 @@ var FetchClient = class {
    * @param url - Request URL
    * @param body - Request body (auto-serialized to JSON)
    * @param headers - Additional headers (Content-Type: application/json is default)
+   * @param options - Request options (signal, timeout)
    * @returns Promise resolving to typed response
    */
-  put(url, body, headers) {
+  put(url, body, headers, options) {
     const requestHeaders = {
       "Content-Type": "application/json",
       ...headers ?? {}
     };
-    return this.request(url, {
-      method: "PUT",
-      headers: requestHeaders,
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-    });
+    return this.request(
+      url,
+      {
+        method: "PUT",
+        headers: requestHeaders,
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      },
+      options
+    );
   }
   /**
    * PATCH request with automatic JSON serialization.
@@ -357,18 +421,23 @@ var FetchClient = class {
    * @param url - Request URL
    * @param body - Request body (auto-serialized to JSON)
    * @param headers - Additional headers (Content-Type: application/json is default)
+   * @param options - Request options (signal, timeout)
    * @returns Promise resolving to typed response
    */
-  patch(url, body, headers) {
+  patch(url, body, headers, options) {
     const requestHeaders = {
       "Content-Type": "application/json",
       ...headers ?? {}
     };
-    return this.request(url, {
-      method: "PATCH",
-      headers: requestHeaders,
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-    });
+    return this.request(
+      url,
+      {
+        method: "PATCH",
+        headers: requestHeaders,
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      },
+      options
+    );
   }
   /**
    * DELETE request with query parameter support.
@@ -376,6 +445,7 @@ var FetchClient = class {
    * @template T - Expected response data type
    * @param url - Request URL
    * @param params - Query parameters to append to URL
+   * @param options - Request options (signal, timeout)
    * @returns Promise resolving to typed response
    *
    * @example
@@ -385,9 +455,9 @@ var FetchClient = class {
    * if (result.ok) console.log('Deleted successfully');
    * ```
    */
-  del(url, params) {
+  del(url, params, options) {
     const finalUrl = this.buildUrlWithParams(url, params);
-    return this.request(finalUrl, { method: "DELETE" });
+    return this.request(finalUrl, { method: "DELETE" }, options);
   }
 };
 
@@ -445,7 +515,7 @@ function createAuthenticationMiddleware(options) {
 }
 
 // src/middleware/authentication/index.ts
-function useAuthentication(client, options) {
+function addAuthentication(client, options) {
   return client.use(createAuthenticationMiddleware(options));
 }
 
@@ -524,7 +594,7 @@ function createAuthorizationMiddleware(options = {}) {
 }
 
 // src/middleware/authorization/index.ts
-function useAuthorization(client, options = {}) {
+function addAuthorization(client, options = {}) {
   return client.use(createAuthorizationMiddleware(options));
 }
 
@@ -668,7 +738,7 @@ function createCacheMiddleware(options = {}) {
 }
 
 // src/middleware/cache/index.ts
-function useCache(client, options = {}) {
+function addCache(client, options = {}) {
   return client.use(createCacheMiddleware(options));
 }
 
@@ -725,7 +795,7 @@ function createCSRFMiddleware(options = {}) {
 }
 
 // src/middleware/csrf/index.ts
-function useCSRF(client, options = {}) {
+function addCSRF(client, options = {}) {
   return client.use(createCSRFMiddleware(options));
 }
 
@@ -857,7 +927,7 @@ function getHeadersObject(headers) {
 }
 
 // src/middleware/logging/index.ts
-function useLogging(client, options = {}) {
+function addLogging(client, options = {}) {
   return client.use(createLoggingMiddleware(options));
 }
 
@@ -940,7 +1010,7 @@ function createRateLimitMiddleware(options = {}) {
 }
 
 // src/middleware/rate-limit/index.ts
-function useRateLimit(client, options = {}) {
+function addRateLimit(client, options = {}) {
   return client.use(createRateLimitMiddleware(options));
 }
 
@@ -1038,40 +1108,40 @@ function createRetryMiddleware(options = {}) {
 }
 
 // src/middleware/retry/index.ts
-function useRetry(client, options = {}) {
+function addRetry(client, options = {}) {
   return client.use(createRetryMiddleware(options));
 }
 
 // src/middleware/index.ts
-function useProductionStack(client, config = {}) {
+function addProductionStack(client, config = {}) {
   let enhanced = client;
   if (config.auth) {
-    enhanced = useAuthentication(enhanced, config.auth);
+    enhanced = addAuthentication(enhanced, config.auth);
   }
   if (config.cache !== void 0) {
-    enhanced = useCache(enhanced, config.cache);
+    enhanced = addCache(enhanced, config.cache);
   }
   if (config.retry !== void 0) {
-    enhanced = useRetry(enhanced, config.retry);
+    enhanced = addRetry(enhanced, config.retry);
   }
   if (config.rateLimit !== void 0) {
-    enhanced = useRateLimit(enhanced, config.rateLimit);
+    enhanced = addRateLimit(enhanced, config.rateLimit);
   }
   if (config.logging !== void 0) {
-    enhanced = useLogging(enhanced, config.logging);
+    enhanced = addLogging(enhanced, config.logging);
   }
   return enhanced;
 }
-function useDevelopmentStack(client, config = {}) {
+function addDevelopmentStack(client, config = {}) {
   let enhanced = client;
   if (config.auth) {
-    enhanced = useAuthentication(enhanced, config.auth);
+    enhanced = addAuthentication(enhanced, config.auth);
   }
-  enhanced = useRetry(enhanced, {
+  enhanced = addRetry(enhanced, {
     maxRetries: 1,
     delay: 100
   });
-  enhanced = useLogging(enhanced, {
+  enhanced = addLogging(enhanced, {
     level: "debug",
     includeRequestHeaders: true,
     includeResponseHeaders: true,
@@ -1080,8 +1150,8 @@ function useDevelopmentStack(client, config = {}) {
   });
   return enhanced;
 }
-function useBasicStack(client, config) {
-  return useRetry(useAuthentication(client, config.auth), { maxRetries: 2 });
+function addBasicStack(client, config) {
+  return addRetry(addAuthentication(client, config.auth), { maxRetries: 2 });
 }
 
 // src/errors/index.ts
@@ -1163,7 +1233,7 @@ function appendQueryParams(baseUrl, query) {
 }
 
 // src/index.ts
-var api = useProductionStack(
+var api = addProductionStack(
   new FetchClient({
     // Smart default: include cookies for session-based auth
     // Can be overridden by creating a custom FetchClient
@@ -1197,6 +1267,16 @@ var index_default = api;
   FetchError,
   HttpError,
   NetworkError,
+  addAuthentication,
+  addAuthorization,
+  addBasicStack,
+  addCSRF,
+  addCache,
+  addDevelopmentStack,
+  addLogging,
+  addProductionStack,
+  addRateLimit,
+  addRetry,
   appendQueryParams,
   buildQueryParams,
   createAuthenticationMiddleware,
@@ -1204,16 +1284,6 @@ var index_default = api;
   createCacheMiddleware,
   createLoggingMiddleware,
   createRateLimitMiddleware,
-  createRetryMiddleware,
-  useAuthentication,
-  useAuthorization,
-  useBasicStack,
-  useCSRF,
-  useCache,
-  useDevelopmentStack,
-  useLogging,
-  useProductionStack,
-  useRateLimit,
-  useRetry
+  createRetryMiddleware
 });
 //# sourceMappingURL=index.js.map