vue-api-kit 1.6.0 → 1.8.0

package/README.md

@@ -251,7 +251,8 @@ const api = createApiClient({
   headers: {
     'Authorization': 'Bearer token'
   },
-  withCredentials: true,
+  withCredentials: true, // Enable cookies
+  withXSRFToken: true,   // Enable automatic XSRF token handling
 
   // CSRF Token Protection
   csrfRefreshEndpoint: '/sanctum/csrf-cookie', // Auto-refresh CSRF token on 403/419 errors
@@ -289,6 +290,133 @@ const api = createApiClient({
 });
 ```
 
+## 🎯 Per-Query and Per-Mutation Request Interceptors
+
+In addition to global request interceptors, you can define `onBeforeRequest` hooks for individual queries and mutations. This is useful when you need to append specific headers or modify the request configuration for certain endpoints only.
+
+### Query-Level onBeforeRequest
+
+You can define `onBeforeRequest` in two ways for queries:
+
+**1. In the query definition:**
+
+```typescript
+const api = createApiClient({
+  baseURL: 'https://api.example.com',
+  queries: {
+    getUser: {
+      path: '/users/{id}',
+      params: z.object({ id: z.number() }),
+      response: z.object({ id: z.number(), name: z.string() }),
+      // Query-level interceptor
+      onBeforeRequest: async (config) => {
+        config.headers['X-Custom-Query-Header'] = 'special-value';
+        return config;
+      }
+    }
+  }
+});
+```
+
+**2. In the query options when calling it:**
+
+```typescript
+const { result, isLoading } = api.query.getUser({
+  params: { id: 1 },
+  // Runtime interceptor
+  onBeforeRequest: async (config) => {
+    const token = await getAuthToken();
+    config.headers.Authorization = `Bearer ${token}`;
+    return config;
+  }
+});
+```
+
+### Mutation-Level onBeforeRequest
+
+Similarly, you can define `onBeforeRequest` for mutations:
+
+**1. In the mutation definition:**
+
+```typescript
+const api = createApiClient({
+  baseURL: 'https://api.example.com',
+  mutations: {
+    createUser: {
+      method: 'POST',
+      path: '/users',
+      data: z.object({ name: z.string(), email: z.string() }),
+      response: z.object({ id: z.number(), name: z.string() }),
+      // Mutation-level interceptor
+      onBeforeRequest: async (config) => {
+        config.headers['X-Action'] = 'create-user';
+        return config;
+      }
+    }
+  }
+});
+```
+
+**2. In the mutation options when calling it:**
+
+```typescript
+const { mutate } = api.mutation.createUser({
+  // Runtime interceptor
+  onBeforeRequest: async (config) => {
+    const csrfToken = document.querySelector('meta[name="csrf-token"]')?.content;
+    if (csrfToken) {
+      config.headers['X-CSRF-Token'] = csrfToken;
+    }
+    return config;
+  }
+});
+
+await mutate({ data: { name: 'John', email: 'john@example.com' } });
+```
+
+### Execution Order
+
+When multiple `onBeforeRequest` hooks are defined, they execute in the following order:
+
+1. **Global interceptor** (defined in `createApiClient` options) - Applied via axios interceptor
+2. **Query/Mutation definition interceptor** (defined in query/mutation object)
+3. **Options interceptor** (defined when calling the query/mutation)
+
+Each hook can modify the config, and later hooks can see and override changes made by earlier hooks.
+
+### Use Cases
+
+- **Authentication**: Add tokens for specific endpoints that require authentication
+- **Custom Headers**: Append API keys, correlation IDs, or feature flags for specific requests
+- **Request Transformation**: Modify request data or parameters before sending
+- **Conditional Logic**: Apply different configurations based on runtime conditions
+- **Debugging**: Add request IDs or trace headers for specific endpoints
+
+### Example: Dynamic Authorization
+
+```typescript
+const api = createApiClient({
+  baseURL: 'https://api.example.com',
+  queries: {
+    getProtectedData: {
+      path: '/protected/data',
+      response: z.object({ data: z.string() }),
+      onBeforeRequest: async (config) => {
+        // This query always needs fresh token
+        const token = await refreshAndGetToken();
+        config.headers.Authorization = `Bearer ${token}`;
+        return config;
+      }
+    },
+    getPublicData: {
+      path: '/public/data',
+      response: z.object({ data: z.string() })
+      // No onBeforeRequest needed for public endpoint
+    }
+  }
+});
+```
+
 ## 🧩 Modular API Definitions
 
 For large applications, you can organize your API definitions into separate files and merge them together with full type safety.
@@ -459,9 +587,10 @@ The client includes built-in CSRF token protection, perfect for Laravel Sanctum
 ### How it works
 
 **Automatic XSRF Token Handling:**
-1. When `withCredentials: true`, the client automatically reads the `XSRF-TOKEN` cookie
-2. Decodes and sends it as `X-XSRF-TOKEN` header with every request
-3. This satisfies Laravel Sanctum's CSRF protection requirements
+1. Set `withCredentials: true` to enable cookie-based authentication
+2. Set `withXSRFToken: true` to enable automatic XSRF token handling
+3. Axios automatically reads `XSRF-TOKEN` cookie and sends it as `X-XSRF-TOKEN` header
+4. This satisfies Laravel Sanctum's CSRF protection requirements
 
 **Automatic CSRF Refresh:**
 1. Detects CSRF errors (403 or 419 status codes)
@@ -474,9 +603,9 @@ The client includes built-in CSRF token protection, perfect for Laravel Sanctum
 ```typescript
 const api = createApiClient({
   baseURL: 'https://api.example.com',
-  withCredentials: true, // Required! Enables cookies AND auto XSRF header
+  withCredentials: true,   // Enable cookies for authentication
+  withXSRFToken: true,     // Enable automatic XSRF token handling
   csrfRefreshEndpoint: '/sanctum/csrf-cookie', // Laravel Sanctum endpoint
-
   queries: { /* ... */ },
   mutations: { /* ... */ }
 });
@@ -491,10 +620,9 @@ import { z } from 'zod';
 
 export const api = createApiClient({
   baseURL: 'https://api.example.com',
-  withCredentials: true, // Enables cookies AND automatic XSRF-TOKEN header
-  csrfRefreshEndpoint: '/sanctum/csrf-cookie', // Laravel's CSRF endpoint
-
-  mutations: {
+  withCredentials: true,   // Enables cookies
+  withXSRFToken: true,     // Enables automatic XSRF-TOKEN header
+  csrfRefreshEndpoint: '/sanctum/csrf-cookie', // Laravel's CSRF endpoint  mutations: {
     login: {
       method: 'POST',
       path: '/login',
@@ -524,7 +652,8 @@ export const api = createApiClient({
 
 ### Benefits
 
-- ✅ **Automatic XSRF Header**: Cookie automatically sent as `X-XSRF-TOKEN` header
+- ✅ **Separate Options**: `withCredentials` and `withXSRFToken` can be configured independently
+- ✅ **Built-in XSRF Support**: Axios `withXSRFToken` handles token automatically
 - ✅ **Automatic Recovery**: No manual token refresh needed
 - ✅ **Seamless UX**: Users don't experience authentication errors
 - ✅ **Race Condition Safe**: Multiple simultaneous requests share the same refresh
@@ -533,7 +662,9 @@ export const api = createApiClient({
 
 ### Important Notes
 
-1. **withCredentials is required**: Set `withCredentials: true` to enable both cookies and automatic XSRF token handling
+1. **Two separate options**:
+   - `withCredentials: true` - Enables sending cookies with requests
+   - `withXSRFToken: true` - Enables automatic XSRF token header handling
 2. **Cookie Domain**: Ensure your API sets cookies with the correct domain (e.g., `.localhost` for local development)
 3. **CORS Configuration**: Your Laravel backend must allow credentials:
    ```php

package/dist/core/types.d.ts

@@ -42,6 +42,7 @@ export interface ApiQuery<TParams extends ZodType<any> | undefined = ZodType<any
     params?: TParams;
     data?: TData;
     response?: TResponse;
+    onBeforeRequest?: (config: InternalAxiosRequestConfig<any>) => Promise<any> | void | any;
 }
 /**
  * Defines a mutation (POST, PUT, PATCH, DELETE) endpoint configuration
@@ -63,6 +64,7 @@ export interface ApiMutation<TData extends ZodType<any> | undefined = ZodType<an
     data?: TData;
     response?: TResponse;
     isMultipart?: boolean;
+    onBeforeRequest?: (config: InternalAxiosRequestConfig<any>) => Promise<any> | void | any;
 }
 /**
  * Configuration options for creating an API client
@@ -83,6 +85,7 @@ export interface ApiClientOptions<Q extends Record<string, ApiQuery> = Record<st
     baseURL: string;
     headers?: Record<string, string>;
     withCredentials?: boolean;
+    withXSRFToken?: boolean;
     csrfRefreshEndpoint?: string;
     queries?: Q;
     mutations?: M;
@@ -125,6 +128,7 @@ export interface UseQueryOptions<TParams = any, TData = any, TResult = any> {
     onResult?: (result: TResult) => void;
     onError?: (error: AxiosError | ZodError | Error) => void;
     onZodError?: (issues: Omit<$ZodIssue, "input">[]) => void;
+    onBeforeRequest?: (config: InternalAxiosRequestConfig<any>) => Promise<any> | void | any;
 }
 /**
  * Options for configuring a mutation hook
@@ -141,6 +145,7 @@ export interface UseMutationOptions<TResult = any> {
     onError?: (error: AxiosError | ZodError | Error) => void;
     onZodError?: (issues: Omit<$ZodIssue, "input">[]) => void;
     onUploadProgress?: (progress: number) => void;
+    onBeforeRequest?: (config: InternalAxiosRequestConfig<any>) => Promise<any> | void | any;
 }
 /**
  * Return type from a query hook

package/dist/index.js

@@ -1,190 +1,204 @@
 import { ZodError as S } from "zod";
-import * as $ from "zod";
+import * as U from "zod";
 import L, { AxiosError as F } from "axios";
-import { AxiosError as G } from "axios";
-import { nextTick as N, ref as m, onMounted as T, watch as k, onBeforeUnmount as x } from "vue";
-import { debounce as U } from "lodash-es";
-function z(t) {
-  const p = L.create({
-    baseURL: t.baseURL,
+import { AxiosError as K } from "axios";
+import { nextTick as T, ref as m, onMounted as k, watch as Z, onBeforeUnmount as x } from "vue";
+import { debounce as N } from "lodash-es";
+function V(s) {
+  const R = L.create({
+    baseURL: s.baseURL,
     headers: {
       "Content-Type": "application/json",
       Accept: "application/json",
-      ...t.headers
+      ...s.headers
     },
-    withCredentials: t.withCredentials ?? !1
+    withCredentials: s.withCredentials ?? !1,
+    withXSRFToken: s.withXSRFToken ?? !1
   });
-  let C = !1, q = null;
-  t.onBeforeRequest && p.interceptors.request.use(
+  let C = !1, j = null;
+  s.onBeforeRequest && R.interceptors.request.use(
     async (e) => {
       try {
-        return await t.onBeforeRequest(e) || e;
+        return await s.onBeforeRequest(e) || e;
       } catch (r) {
         return Promise.reject(r);
       }
     },
     (e) => Promise.reject(e)
-  ), t.onStartRequest && p.interceptors.request.use(
+  ), s.onStartRequest && R.interceptors.request.use(
     async (e) => {
       try {
-        return await t.onStartRequest(), e;
+        return await s.onStartRequest(), e;
       } catch (r) {
         return Promise.reject(r);
       }
     },
     (e) => Promise.reject(e)
-  ), t.onFinishRequest && p.interceptors.response.use(
-    (e) => (t.onFinishRequest(), e),
-    (e) => (t.onFinishRequest(), Promise.reject(e))
-  ), p.interceptors.request.use((e) => {
+  ), s.onFinishRequest && R.interceptors.response.use(
+    (e) => (s.onFinishRequest(), e),
+    (e) => (s.onFinishRequest(), Promise.reject(e))
+  ), R.interceptors.request.use((e) => {
     if (!e.url) return e;
     const r = (a) => {
       if (a)
-        for (const [s, R] of Object.entries(a)) {
-          const l = `{${s}}`;
-          e.url.includes(l) && (e.url = e.url.replace(
-            l,
-            encodeURIComponent(String(R))
-          ), delete a[s]);
+        for (const [t, p] of Object.entries(a)) {
+          const f = `{${t}}`;
+          e.url.includes(f) && (e.url = e.url.replace(
+            f,
+            encodeURIComponent(String(p))
+          ), delete a[t]);
         }
     };
     return e.method !== "get" && e.data?.params && r(e.data.params), r(e.params), e;
-  }), t.withCredentials && p.interceptors.request.use((e) => {
-    const r = document.cookie.split("; ").find((a) => a.startsWith("XSRF-TOKEN="))?.split("=")[1];
-    return r && (e.headers["X-XSRF-TOKEN"] = decodeURIComponent(r)), e;
-  }), t.csrfRefreshEndpoint && p.interceptors.response.use(
+  }), s.csrfRefreshEndpoint && R.interceptors.response.use(
     (e) => e,
     async (e) => {
       const r = e.config;
-      if (r?.url === t.csrfRefreshEndpoint)
+      if (r?.url === s.csrfRefreshEndpoint)
         return Promise.reject(e);
       if (e.response && (e.response.status === 403 || e.response.status === 419) && !r?._retry) {
         r._retry = !0;
         try {
-          return C && q ? await q : (C = !0, q = p.get(t.csrfRefreshEndpoint).then(() => {
-            C = !1, q = null;
-          }), await q), p.request(r);
+          return C && j ? await j : (C = !0, j = R.get(s.csrfRefreshEndpoint).then(() => {
+            C = !1, j = null;
+          }), await j), R.request(r);
         } catch (a) {
-          return C = !1, q = null, Promise.reject(a);
+          return C = !1, j = null, Promise.reject(a);
         }
       }
       return Promise.reject(e);
     }
-  ), p.interceptors.response.use(
+  ), R.interceptors.response.use(
     (e) => e,
-    (e) => (N(() => {
+    (e) => (T(() => {
       e.code;
     }), Promise.reject(e))
   );
-  const P = t.queries ?? {}, M = {};
+  const P = s.queries ?? {}, M = {};
   for (const e in P) {
     const r = P[e];
     r && (M[e] = (a) => {
-      let s;
-      a && typeof a == "object" && ("loadOnMount" in a || "debounce" in a || "onResult" in a || "onError" in a || "data" in a ? s = a : s = { params: a });
-      const R = m(), l = m(), v = m(), g = m(!1), y = m(!1), A = m(!0);
-      let j = new AbortController();
-      const u = () => {
-        j?.abort(), j = new AbortController();
-      }, c = async () => {
-        g.value && u(), g.value = !0, l.value = void 0;
+      let t;
+      a && typeof a == "object" && ("loadOnMount" in a || "debounce" in a || "onResult" in a || "onError" in a || "onZodError" in a || "onBeforeRequest" in a || "data" in a ? t = a : t = { params: a });
+      const p = m(), f = m(), g = m(), E = m(!1), y = m(!1), A = m(!0);
+      let b = new AbortController();
+      const i = () => {
+        b?.abort(), b = new AbortController();
+      }, l = async () => {
+        E.value && i(), E.value = !0, f.value = void 0;
         try {
-          r.params && s?.params && r.params.parse(s.params);
-          let o = s?.data;
+          r.params && t?.params && r.params.parse(t.params);
+          let o = t?.data;
           r.data && o && r.data.parse(o);
-          const f = {
+          const u = {
             method: r.method ?? "GET",
             url: r.path,
-            params: s?.params,
-            signal: j.signal
+            params: t?.params,
+            signal: b.signal
           };
-          r.method === "POST" && o && (f.data = o);
-          const n = await p.request(f), i = r.response ? r.response.parse(n.data) : n.data;
-          R.value = i, s?.onResult?.(i);
+          if (r.method === "POST" && o && (u.data = o), r.onBeforeRequest) {
+            const c = await r.onBeforeRequest(u);
+            c !== void 0 && Object.assign(u, c);
+          }
+          if (t?.onBeforeRequest) {
+            const c = await t.onBeforeRequest(u);
+            c !== void 0 && Object.assign(u, c);
+          }
+          const h = await R.request(u), n = r.response ? r.response.parse(h.data) : h.data;
+          p.value = n, t?.onResult?.(n);
         } catch (o) {
           if (o instanceof F) {
             if (o.code !== "ERR_CANCELED") {
-              const f = o.response?.data?.message || o.message || "An error occurred", n = o.response?.status, i = o.code, h = o.response?.data;
-              l.value = f, s?.onError?.(o), t.onErrorRequest?.({ message: f, status: n, code: i, data: h });
+              const u = o.response?.data?.message || o.message || "An error occurred", h = o.response?.status, n = o.code, c = o.response?.data;
+              f.value = u, t?.onError?.(o), s.onErrorRequest?.({ message: u, status: h, code: n, data: c });
             }
           } else if (o instanceof S) {
-            v.value = o.issues || [];
-            const n = `Validation error: ${v.value.map(
-              (i) => `${i.path.join(".")}: ${i.message}`
+            g.value = o.issues || [];
+            const h = `Validation error: ${g.value.map(
+              (n) => `${n.path.join(".")}: ${n.message}`
             ).join(", ")}`;
-            l.value = n, s?.onError?.(o), s?.onZodError?.(v.value), t.onErrorRequest?.({ message: n, code: "VALIDATION_ERROR" }), t.onZodError && t.onZodError(v.value);
+            f.value = h, t?.onError?.(o), t?.onZodError?.(g.value), s.onErrorRequest?.({ message: h, code: "VALIDATION_ERROR" }), s.onZodError && s.onZodError(g.value);
           } else {
-            const f = o.message || "An error occurred";
-            l.value = f, s?.onError?.(f), t.onErrorRequest?.({ message: f });
+            const u = o.message || "An error occurred";
+            f.value = u, t?.onError?.(u), s.onErrorRequest?.({ message: u });
           }
         } finally {
-          g.value = !1, y.value = !0;
+          E.value = !1, y.value = !0;
         }
-      }, E = s?.debounce ? U(c, s.debounce) : c;
+      }, v = t?.debounce ? N(l, t.debounce) : l;
       let d = null;
-      return (s?.params || s?.data) && (T(() => {
-        d && d(), d = k(
-          () => JSON.stringify({ params: s.params, data: s.data }),
+      return (t?.params || t?.data) && (k(() => {
+        d && d(), d = Z(
+          () => JSON.stringify({ params: t.params, data: t.data }),
           () => {
-            E();
+            v();
           },
           { immediate: !1 }
         );
       }), x(() => {
-        d && d(), j?.abort();
-      })), (s?.loadOnMount === void 0 || s.loadOnMount) && !y.value && (A.value ? (A.value = !1, c()) : E()), { result: R, errorMessage: l, zodErrors: v, isLoading: g, isDone: y, refetch: c };
+        d && d(), b?.abort();
+      })), (t?.loadOnMount === void 0 || t.loadOnMount) && !y.value && (A.value ? (A.value = !1, l()) : v()), { result: p, errorMessage: f, zodErrors: g, isLoading: E, isDone: y, refetch: l };
     });
   }
-  const D = t.mutations ?? {}, w = {};
-  for (const e in D) {
-    const r = D[e];
-    r && (w[e] = (a) => {
-      const s = m(), R = m(), l = m(), v = m(!1), g = m(!1), y = m(0);
-      return { result: s, errorMessage: R, zodErrors: l, isLoading: v, isDone: g, uploadProgress: y, mutate: async (j) => {
-        if (!v.value) {
-          v.value = !0, R.value = void 0, y.value = 0;
+  const B = s.mutations ?? {}, D = {};
+  for (const e in B) {
+    const r = B[e];
+    r && (D[e] = (a) => {
+      const t = m(), p = m(), f = m(), g = m(!1), E = m(!1), y = m(0);
+      return { result: t, errorMessage: p, zodErrors: f, isLoading: g, isDone: E, uploadProgress: y, mutate: async (b) => {
+        if (!g.value) {
+          g.value = !0, p.value = void 0, y.value = 0;
           try {
-            const { data: u = {}, params: c } = j ?? {};
-            let E = u ?? {}, d = {};
+            const { data: i = {}, params: l } = b ?? {};
+            let v = i ?? {}, d = {};
             if (r.isMultipart) {
               const n = new FormData();
-              for (const [i, h] of Object.entries(u))
-                h instanceof File || h instanceof Blob ? n.append(i, h) : Array.isArray(h) ? h.forEach((b) => {
-                  b instanceof File || b instanceof Blob ? n.append(i, b) : n.append(i, JSON.stringify(b));
-                }) : typeof h == "object" && h !== null ? n.append(i, JSON.stringify(h)) : n.append(i, String(h));
-              E = n, d["Content-Type"] = "multipart/form-data";
-            } else r.data && r.data.parse(u);
-            r.params && c && r.params.parse(c);
-            const o = await p.request({
+              for (const [c, q] of Object.entries(i))
+                q instanceof File || q instanceof Blob ? n.append(c, q) : Array.isArray(q) ? q.forEach((w) => {
+                  w instanceof File || w instanceof Blob ? n.append(c, w) : n.append(c, JSON.stringify(w));
+                }) : typeof q == "object" && q !== null ? n.append(c, JSON.stringify(q)) : n.append(c, String(q));
+              v = n, d["Content-Type"] = "multipart/form-data";
+            } else r.data && r.data.parse(i);
+            r.params && l && r.params.parse(l);
+            const o = {
               method: r.method,
               url: r.path,
-              data: E,
-              params: c,
+              data: v,
+              params: l,
               headers: d,
               onUploadProgress: (n) => {
                 if (n.total) {
-                  const i = Math.round(n.loaded * 100 / n.total);
-                  y.value = i, a?.onUploadProgress?.(i);
+                  const c = Math.round(n.loaded * 100 / n.total);
+                  y.value = c, a?.onUploadProgress?.(c);
                 }
               }
-            }), f = r.response ? r.response.parse(o.data) : o.data;
-            s.value = f, a?.onResult?.(f);
-          } catch (u) {
-            if (u instanceof F) {
-              const c = u.response?.data?.message || u.message || "An error occurred", E = u.response?.status, d = u.code;
-              R.value = c, a?.onError?.(u), t.onErrorRequest?.({ message: c, status: E, code: d });
-            } else if (u instanceof S) {
-              l.value = u.issues || [];
-              const E = `Validation error: ${l.value.map(
+            };
+            if (r.onBeforeRequest) {
+              const n = await r.onBeforeRequest(o);
+              n !== void 0 && Object.assign(o, n);
+            }
+            if (a?.onBeforeRequest) {
+              const n = await a.onBeforeRequest(o);
+              n !== void 0 && Object.assign(o, n);
+            }
+            const u = await R.request(o), h = r.response ? r.response.parse(u.data) : u.data;
+            t.value = h, a?.onResult?.(h);
+          } catch (i) {
+            if (i instanceof F) {
+              const l = i.response?.data?.message || i.message || "An error occurred", v = i.response?.status, d = i.code;
+              p.value = l, a?.onError?.(i), s.onErrorRequest?.({ message: l, status: v, code: d });
+            } else if (i instanceof S) {
+              f.value = i.issues || [];
+              const v = `Validation error: ${f.value.map(
                 (d) => `${d.path.join(".")}: ${d.message}`
               ).join(", ")}`;
-              R.value = E, a?.onError?.(u), a?.onZodError?.(l.value), t.onErrorRequest?.({ message: E, code: "VALIDATION_ERROR" }), t.onZodError && t.onZodError(l.value);
+              p.value = v, a?.onError?.(i), a?.onZodError?.(f.value), s.onErrorRequest?.({ message: v, code: "VALIDATION_ERROR" }), s.onZodError && s.onZodError(f.value);
             } else {
-              const c = u.message || "An error occurred";
-              R.value = c, a?.onError?.(u), t.onErrorRequest?.({ message: c });
+              const l = i.message || "An error occurred";
+              p.value = l, a?.onError?.(i), s.onErrorRequest?.({ message: l });
             }
           } finally {
-            v.value = !1, g.value = !0;
+            g.value = !1, E.value = !0;
           }
         }
       } };
@@ -192,27 +206,27 @@ function z(t) {
   }
   return {
     query: M,
-    mutation: w
+    mutation: D
   };
 }
-function V(t) {
-  return t;
+function J(s) {
+  return s;
 }
-function J(t) {
-  return t;
+function Q(s) {
+  return s;
 }
-function Q(...t) {
-  return Object.assign({}, ...t);
+function W(...s) {
+  return Object.assign({}, ...s);
 }
-function W(...t) {
-  return Object.assign({}, ...t);
+function X(...s) {
+  return Object.assign({}, ...s);
 }
 export {
-  G as AxiosError,
-  z as createApiClient,
-  J as defineMutation,
-  V as defineQuery,
-  W as mergeMutations,
-  Q as mergeQueries,
-  $ as z
+  K as AxiosError,
+  V as createApiClient,
+  Q as defineMutation,
+  J as defineQuery,
+  X as mergeMutations,
+  W as mergeQueries,
+  U as z
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vue-api-kit",
   "type": "module",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "A powerful and flexible API client for Vue 3 applications, built with TypeScript and Zod for type-safe API interactions.",
   "keywords": [
     "vue3",