@fgrzl/fetch 1.1.0 → 1.3.0-alpha.3

package/README.md

@@ -28,6 +28,26 @@ npm install @fgrzl/fetch
 ```ts
 import api from "@fgrzl/fetch";
 
+// It just works! 🎉
+const users = await api.get("https://api.example.com/api/users");
+const newUser = await api.post("https://api.example.com/api/users", {
+  name: "John",
+});
+
+// Built-in error handling
+if (users.ok) {
+  console.log("Users:", users.data);
+} else {
+  console.error("Error:", users.error?.message);
+}
+```
+
+```ts
+import api from "@fgrzl/fetch";
+
+// Set the base url to keep things simple
+api.setBaseUrl("https://api.example.com");
+
 // It just works! 🎉
 const users = await api.get("/api/users");
 const newUser = await api.post("/api/users", { name: "John" });
@@ -48,7 +68,28 @@ import { FetchClient, useAuthentication } from "@fgrzl/fetch";
 const authClient = useAuthentication(new FetchClient(), {
   tokenProvider: () => localStorage.getItem("token") || "",
 });
+```
+
+**Working with APIs?** Use a base URL:
 
+```ts
+import { FetchClient } from "@fgrzl/fetch";
+
+const apiClient = new FetchClient({
+  baseUrl: "https://api.example.com",
+});
+
+// All relative URLs are prefixed with the base URL
+await apiClient.get("/users"); // → GET https://api.example.com/users
+await apiClient.post("/users", data); // → POST https://api.example.com/users
+
+// Absolute URLs work as expected
+await apiClient.get("https://other-api.com/data"); // → GET https://other-api.com/data
+```
+
+**Advanced usage** with middleware stacks:
+
+```ts
 // Smart defaults - just works
 useCSRF(client);
 useAuthorization(client); // Redirects to /login with return URL

package/dist/cjs/index.js

@@ -24,6 +24,8 @@ __export(index_exports, {
   FetchError: () => FetchError,
   HttpError: () => HttpError,
   NetworkError: () => NetworkError,
+  appendQueryParams: () => appendQueryParams,
+  buildQueryParams: () => buildQueryParams,
   createAuthenticationMiddleware: () => createAuthenticationMiddleware,
   createAuthorizationMiddleware: () => createAuthorizationMiddleware,
   createCacheMiddleware: () => createCacheMiddleware,
@@ -49,16 +51,46 @@ var FetchClient = class {
   constructor(config = {}) {
     this.middlewares = [];
     this.credentials = config.credentials ?? "same-origin";
+    this.baseUrl = config.baseUrl;
   }
   use(middleware) {
     this.middlewares.push(middleware);
     return this;
   }
+  /**
+   * Set or update the base URL for this client instance.
+   *
+   * When a base URL is set, relative URLs will be resolved against it.
+   * Absolute URLs will continue to work unchanged.
+   *
+   * @param baseUrl - The base URL to set, or undefined to clear it
+   * @returns The client instance for method chaining
+   *
+   * @example Set base URL:
+   * ```typescript
+   * const client = new FetchClient();
+   * client.setBaseUrl('https://api.example.com');
+   *
+   * // Now relative URLs work
+   * await client.get('/users'); // → GET https://api.example.com/users
+   * ```
+   *
+   * @example Chain with middleware:
+   * ```typescript
+   * const client = useProductionStack(new FetchClient())
+   *   .setBaseUrl(process.env.API_BASE_URL);
+   * ```
+   */
+  setBaseUrl(baseUrl) {
+    this.baseUrl = baseUrl;
+    return this;
+  }
   async request(url, init = {}) {
+    const resolvedUrl = this.resolveUrl(url);
     let index = 0;
     const execute = async (request) => {
-      const currentRequest = request || { ...init, url };
-      const currentUrl = currentRequest.url || url;
+      const currentRequest = request || { ...init, url: resolvedUrl };
+      const currentUrl = currentRequest.url || resolvedUrl;
       if (index >= this.middlewares.length) {
         const { url: _, ...requestInit } = currentRequest;
         return this.coreFetch(requestInit, currentUrl);
@@ -142,20 +174,48 @@ var FetchClient = class {
     if (!params) {
       return url;
     }
-    const urlObj = new URL(
-      url,
-      url.startsWith("http") ? void 0 : "http://localhost"
-    );
+    const resolvedUrl = this.resolveUrl(url);
+    if (!resolvedUrl.startsWith("http://") && !resolvedUrl.startsWith("https://") && !resolvedUrl.startsWith("//")) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          searchParams.set(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      return queryString ? `${resolvedUrl}?${queryString}` : resolvedUrl;
+    }
+    const urlObj = new URL(resolvedUrl);
     Object.entries(params).forEach(([key, value]) => {
       if (value !== void 0 && value !== null) {
         urlObj.searchParams.set(key, String(value));
       }
     });
-    if (!url.startsWith("http")) {
-      return urlObj.pathname + urlObj.search;
-    }
     return urlObj.toString();
   }
+  /**
+   * Resolves a URL with the base URL if it's relative and base URL is configured
+   * @param url - The URL to resolve
+   * @returns The resolved URL
+   * @private
+   */
+  resolveUrl(url) {
+    if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) {
+      return url;
+    }
+    if (!this.baseUrl) {
+      return url;
+    }
+    try {
+      const baseUrl = new URL(this.baseUrl);
+      const resolvedUrl = new URL(url, baseUrl);
+      return resolvedUrl.toString();
+    } catch {
+      throw new Error(
+        `Invalid URL: Unable to resolve "${url}" with baseUrl "${this.baseUrl}"`
+      );
+    }
+  }
   // 🎯 PIT OF SUCCESS: Convenience methods with smart defaults
   /**
    * HEAD request with query parameter support.
@@ -1068,6 +1128,40 @@ var NetworkError = class extends FetchError {
   }
 };
 
+// src/client/query.ts
+function buildQueryParams(query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) {
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item !== void 0) {
+            params.append(key, String(item));
+          }
+        });
+      } else {
+        params.set(key, String(value));
+      }
+    }
+  }
+  return params.toString();
+}
+function appendQueryParams(baseUrl, query) {
+  const queryString = buildQueryParams(query);
+  if (!queryString) {
+    return baseUrl;
+  }
+  const fragmentIndex = baseUrl.indexOf("#");
+  if (fragmentIndex !== -1) {
+    const urlPart = baseUrl.substring(0, fragmentIndex);
+    const fragmentPart = baseUrl.substring(fragmentIndex);
+    const separator2 = urlPart.includes("?") ? "&" : "?";
+    return `${urlPart}${separator2}${queryString}${fragmentPart}`;
+  }
+  const separator = baseUrl.includes("?") ? "&" : "?";
+  return `${baseUrl}${separator}${queryString}`;
+}
+
 // src/index.ts
 var api = useProductionStack(
   new FetchClient({
@@ -1103,6 +1197,8 @@ var index_default = api;
   FetchError,
   HttpError,
   NetworkError,
+  appendQueryParams,
+  buildQueryParams,
   createAuthenticationMiddleware,
   createAuthorizationMiddleware,
   createCacheMiddleware,