vue-api-kit 1.8.1 → 1.10.1

package/README.md

@@ -234,6 +234,7 @@ async function handleSubmit() {
 - ✅ **Auto Loading States**: Built-in loading, error, and success states
 - ✅ **POST Queries**: Support for both GET and POST methods in queries for complex data retrieval
 - ✅ **Modular APIs**: Merge queries and mutations from separate files with full type safety
+- ✅ **Multi-Level Nesting**: Organize queries and mutations in nested structures with full type safety
 - ✅ **File Upload**: Support for multipart/form-data in mutations
 - ✅ **Path Parameters**: Automatic path parameter replacement
 - ✅ **Debouncing**: Built-in request debouncing
@@ -243,6 +244,164 @@ async function handleSubmit() {
 - ✅ **Fully Typed**: Complete type inference for params, data, and response
 - ✅ **Tree-Shakeable**: Only bundles what you use
 
+## 🏗️ Multi-Level Nested Structure
+
+Organize your API endpoints in a hierarchical structure for better code organization and maintainability.
+
+### Basic Nested Structure
+
+```typescript
+import { createApiClient, defineQuery, defineMutation } from 'vue-api-kit';
+import { z } from 'zod';
+
+const api = createApiClient({
+  baseURL: 'https://api.example.com',
+
+  queries: {
+    // Organize queries by resource
+    users: {
+      getAll: defineQuery({
+        path: '/users',
+        response: z.array(z.object({
+          id: z.number(),
+          name: z.string()
+        }))
+      }),
+      getById: defineQuery({
+        path: '/users/{id}',
+        params: z.object({ id: z.number() }),
+        response: z.object({
+          id: z.number(),
+          name: z.string()
+        })
+      }),
+      search: defineQuery({
+        method: 'POST',
+        path: '/users/search',
+        data: z.object({ query: z.string() }),
+        response: z.array(z.object({ id: z.number(), name: z.string() }))
+      })
+    },
+    posts: {
+      getAll: defineQuery({
+        path: '/posts',
+        response: z.array(z.object({ id: z.number(), title: z.string() }))
+      }),
+      getById: defineQuery({
+        path: '/posts/{id}',
+        params: z.object({ id: z.number() }),
+        response: z.object({ id: z.number(), title: z.string() })
+      })
+    }
+  },
+
+  mutations: {
+    users: {
+      create: defineMutation({
+        method: 'POST',
+        path: '/users',
+        data: z.object({ name: z.string(), email: z.string().email() }),
+        response: z.object({ id: z.number(), name: z.string() })
+      }),
+      update: defineMutation({
+        method: 'PUT',
+        path: '/users/{id}',
+        params: z.object({ id: z.number() }),
+        data: z.object({ name: z.string() }),
+        response: z.object({ id: z.number(), name: z.string() })
+      }),
+      delete: defineMutation({
+        method: 'DELETE',
+        path: '/users/{id}',
+        params: z.object({ id: z.number() })
+      })
+    }
+  }
+});
+
+// Usage in components:
+const { result, isLoading } = api.query.users.getAll();
+const { mutate } = api.mutation.users.create();
+```
+
+### Deep Nesting
+
+You can nest as deeply as needed for complex API structures:
+
+```typescript
+const api = createApiClient({
+  baseURL: 'https://api.example.com',
+
+  queries: {
+    api: {
+      v1: {
+        admin: {
+          users: {
+            list: defineQuery({ path: '/api/v1/admin/users' }),
+            search: defineQuery({
+              method: 'POST',
+              path: '/api/v1/admin/users/search'
+            })
+          },
+          reports: {
+            daily: defineQuery({ path: '/api/v1/admin/reports/daily' }),
+            monthly: defineQuery({ path: '/api/v1/admin/reports/monthly' })
+          }
+        },
+        public: {
+          posts: {
+            list: defineQuery({ path: '/api/v1/public/posts' })
+          }
+        }
+      }
+    }
+  }
+});
+
+// Access deeply nested endpoints:
+api.query.api.v1.admin.users.list()
+api.query.api.v1.admin.reports.daily()
+api.query.api.v1.public.posts.list()
+```
+
+### Mixed Flat and Nested Structure
+
+You can combine flat and nested structures as needed:
+
+```typescript
+const api = createApiClient({
+  baseURL: 'https://api.example.com',
+
+  queries: {
+    // Flat queries
+    getStatus: defineQuery({ path: '/status' }),
+    getHealth: defineQuery({ path: '/health' }),
+
+    // Nested queries
+    users: {
+      getAll: defineQuery({ path: '/users' }),
+      getById: defineQuery({ path: '/users/{id}' })
+    },
+    posts: {
+      getAll: defineQuery({ path: '/posts' })
+    }
+  }
+});
+
+// Both flat and nested work together:
+api.query.getStatus()       // Flat
+api.query.users.getAll()    // Nested
+```
+
+### Benefits
+
+- **Better Organization**: Group related endpoints together
+- **Improved Readability**: Clear hierarchical structure reflects your API design
+- **Namespace Separation**: Prevent naming conflicts (e.g., `users.create` vs `posts.create`)
+- **Scalability**: Easy to add new endpoints without cluttering the root level
+- **Type Safety**: Full TypeScript inference throughout the nested structure
+- **Backward Compatible**: Works alongside existing flat structure
+
 ## 🔧 Advanced Configuration
 
 ```typescript
@@ -539,6 +698,99 @@ export const api = createApiClient({
 // api.mutation.createPost ✓ Fully typed
 ```
 
+### Nested Structure with Modular APIs
+
+You can also use nested structures with modular API definitions:
+
+**user-api.ts** - User module with nested structure
+```typescript
+import { z, defineQuery, defineMutation } from 'vue-api-kit';
+
+export const userApi = {
+  queries: {
+    users: {
+      getAll: defineQuery({
+        path: '/users',
+        response: z.array(z.object({ id: z.number(), name: z.string() }))
+      }),
+      getById: defineQuery({
+        path: '/users/{id}',
+        params: z.object({ id: z.number() }),
+        response: z.object({ id: z.number(), name: z.string() })
+      })
+    }
+  },
+  mutations: {
+    users: {
+      create: defineMutation({
+        method: 'POST',
+        path: '/users',
+        data: z.object({ name: z.string() })
+      }),
+      update: defineMutation({
+        method: 'PUT',
+        path: '/users/{id}',
+        params: z.object({ id: z.number() }),
+        data: z.object({ name: z.string() })
+      })
+    }
+  }
+};
+```
+
+**post-api.ts** - Post module with nested structure
+```typescript
+import { z, defineQuery, defineMutation } from 'vue-api-kit';
+
+export const postApi = {
+  queries: {
+    posts: {
+      getAll: defineQuery({
+        path: '/posts',
+        response: z.array(z.object({ id: z.number(), title: z.string() }))
+      }),
+      getById: defineQuery({
+        path: '/posts/{id}',
+        params: z.object({ id: z.number() }),
+        response: z.object({ id: z.number(), title: z.string() })
+      })
+    }
+  },
+  mutations: {
+    posts: {
+      create: defineMutation({
+        method: 'POST',
+        path: '/posts',
+        data: z.object({ title: z.string(), content: z.string() })
+      })
+    }
+  }
+};
+```
+
+**api.ts** - Merge nested structures
+```typescript
+import { createApiClient, mergeQueries, mergeMutations } from 'vue-api-kit';
+import { userApi } from './user-api';
+import { postApi } from './post-api';
+
+export const api = createApiClient({
+  baseURL: 'https://api.example.com',
+
+  // Merge nested queries from modules
+  queries: mergeQueries(userApi.queries, postApi.queries),
+
+  // Merge nested mutations from modules
+  mutations: mergeMutations(userApi.mutations, postApi.mutations)
+});
+
+// Usage with nested structure:
+api.query.users.getAll()     // ✓ Fully typed
+api.query.posts.getById()    // ✓ Fully typed
+api.mutation.users.create()  // ✓ Fully typed
+api.mutation.posts.create()  // ✓ Fully typed
+```
+
 ### Benefits of Modular Approach
 
 - **Separation of Concerns**: Keep related API endpoints together in dedicated files
@@ -682,3 +934,4 @@ MIT
 ## 👤 Author
 
 MelvishNiz - [GitHub](https://github.com/MelvishNiz)
+

package/dist/core/client.d.ts

@@ -1,4 +1,4 @@
-import { ApiClientOptions, ApiMutation, ApiQuery, Infer, MutationResult, QueryResult, UseMutationOptions, UseQueryOptions } from './types';
+import { ApiClientOptions, ApiMutation, ApiQuery, QueryHooksFromDefinitions, MutationHooksFromDefinitions, NestedStructure } from './types';
 /**
  * Creates a type-safe API client with query and mutation hooks for Vue 3
  * @template Q - Record of query endpoint definitions
@@ -41,7 +41,7 @@ import { ApiClientOptions, ApiMutation, ApiQuery, Infer, MutationResult, QueryRe
  * const { result, isLoading } = api.query.getUsers();
  * const { mutate } = api.mutation.createUser();
  */
-export declare function createApiClient<Q extends Record<string, ApiQuery>, M extends Record<string, ApiMutation>>(options: ApiClientOptions<Q, M>): {
-    query: { [K in keyof Q]: (options?: UseQueryOptions<Infer<Q[K]["params"]>, Infer<Q[K]["data"]>, Infer<Q[K]["response"]>>) => QueryResult<Infer<Q[K]["response"]>>; };
-    mutation: { [K_1 in keyof M]: (options?: UseMutationOptions<Infer<M[K_1]["response"]>>) => MutationResult<Infer<M[K_1]["response"]>, Infer<M[K_1]["data"]>, Infer<M[K_1]["params"]>>; };
+export declare function createApiClient<Q extends Record<string, NestedStructure<ApiQuery>>, M extends Record<string, NestedStructure<ApiMutation>>>(options: ApiClientOptions<Q, M>): {
+    query: QueryHooksFromDefinitions<Q>;
+    mutation: MutationHooksFromDefinitions<M>;
 };

package/dist/core/types.d.ts

@@ -66,10 +66,36 @@ export interface ApiMutation<TData extends ZodType<any> | undefined = ZodType<an
     isMultipart?: boolean;
     onBeforeRequest?: (config: InternalAxiosRequestConfig<any>) => Promise<any> | void | any;
 }
+/**
+ * Recursive type to represent nested query or mutation structure
+ */
+export type NestedStructure<T> = T | {
+    [key: string]: NestedStructure<T>;
+};
+/**
+ * Extract query hook function from ApiQuery definition
+ */
+export type QueryHookFromDefinition<Q extends ApiQuery> = (options?: UseQueryOptions<Infer<Q["params"]>, Infer<Q["data"]>, Infer<Q["response"]>>) => QueryResult<Infer<Q["response"]>>;
+/**
+ * Extract mutation hook function from ApiMutation definition
+ */
+export type MutationHookFromDefinition<M extends ApiMutation> = (options?: UseMutationOptions<Infer<M["response"]>>) => MutationResult<Infer<M["response"]>, Infer<M["data"]>, Infer<M["params"]>>;
+/**
+ * Recursively transform nested query definitions into query hooks
+ */
+export type QueryHooksFromDefinitions<Q> = {
+    [K in keyof Q]: Q[K] extends ApiQuery ? QueryHookFromDefinition<Q[K]> : Q[K] extends Record<string, NestedStructure<ApiQuery>> ? QueryHooksFromDefinitions<Q[K]> : never;
+};
+/**
+ * Recursively transform nested mutation definitions into mutation hooks
+ */
+export type MutationHooksFromDefinitions<M> = {
+    [K in keyof M]: M[K] extends ApiMutation ? MutationHookFromDefinition<M[K]> : M[K] extends Record<string, NestedStructure<ApiMutation>> ? MutationHooksFromDefinitions<M[K]> : never;
+};
 /**
  * Configuration options for creating an API client
- * @template Q - Record of query endpoint definitions
- * @template M - Record of mutation endpoint definitions
+ * @template Q - Record of query endpoint definitions (can be nested)
+ * @template M - Record of mutation endpoint definitions (can be nested)
  * @example
  * const options: ApiClientOptions = {
  *   baseURL: "https://api.example.com",
@@ -80,8 +106,19 @@ export interface ApiMutation<TData extends ZodType<any> | undefined = ZodType<an
  *   mutations: { createUser: { method: "POST", path: "/users" } },
  *   onErrorRequest: (error) => console.error(error.message)
  * };
+ * @example
+ * // Nested structure
+ * const options: ApiClientOptions = {
+ *   baseURL: "https://api.example.com",
+ *   queries: {
+ *     users: {
+ *       getAll: { path: "/users" },
+ *       getById: { path: "/users/{id}" }
+ *     }
+ *   }
+ * };
  */
-export interface ApiClientOptions<Q extends Record<string, ApiQuery> = Record<string, ApiQuery>, M extends Record<string, ApiMutation> = Record<string, ApiMutation>> {
+export interface ApiClientOptions<Q extends Record<string, NestedStructure<ApiQuery>> = Record<string, NestedStructure<ApiQuery>>, M extends Record<string, NestedStructure<ApiMutation>> = Record<string, NestedStructure<ApiMutation>>> {
     baseURL: string;
     headers?: Record<string, string>;
     withCredentials?: boolean;
@@ -97,6 +134,7 @@ export interface ApiClientOptions<Q extends Record<string, ApiQuery> = Record<st
         status?: number;
         code?: string;
         data?: any;
+        url?: string;
     }) => void;
     onZodError?: (issues: Omit<$ZodIssue, "input">[]) => void;
 }

package/dist/index.js

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

package/package.json

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