@braine/quantum-query 1.3.3 → 1.3.4

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   unwrapPromise: () => unwrapPromise,
   useCombinedQueries: () => useCombinedQueries,
   useInfiniteQuery: () => useInfiniteQuery,
+  useMutation: () => useMutation,
   usePaginatedQuery: () => usePaginatedQuery,
   useQueries: () => useQueries,
   useQuery: () => useQuery,
@@ -2243,9 +2244,156 @@ function useSuspenseQuery(options) {
   };
 }
 
-// src/query/infiniteQuery.ts
+// src/query/useMutation.ts
 var import_react9 = require("react");
 
+// src/query/mutationObserver.ts
+var generateId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "mutation-" + Date.now() + "-" + Math.random().toString(36).slice(2);
+};
+var MutationObserver = class {
+  client;
+  options;
+  currentMutationId = null;
+  // We maintain our own signal for this observer's view of the mutation
+  // This ensures we don't miss updates if we switch IDs.
+  signal;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+    this.signal = createSignal({
+      status: "idle",
+      data: void 0,
+      error: null,
+      variables: void 0,
+      context: void 0,
+      submittedAt: 0
+    });
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  mutate = (variables) => {
+    const id = generateId();
+    this.currentMutationId = id;
+    this.client.mutationCache.register(id, this.options.mutationKey);
+    const pendingState = {
+      status: "pending",
+      variables,
+      submittedAt: Date.now(),
+      data: void 0,
+      error: null,
+      context: void 0
+    };
+    this.signal.set({
+      ...this.signal.get(),
+      ...pendingState
+    });
+    this.client.mutationCache.notify(id, pendingState);
+    const unsubscribe = this.client.mutationCache.getSignal(id).subscribe((state) => {
+      untracked(() => {
+        const current = this.signal.get();
+        if (current.status !== state.status || current.data !== state.data || current.error !== state.error) {
+          this.signal.set(state);
+        }
+      });
+    });
+    return this.executeMutation(id, variables).finally(() => {
+    });
+  };
+  executeMutation = async (id, variables) => {
+    const { mutationFn, onMutate, onSuccess, onError, onSettled, invalidatesTags, optimistic, mutationKey } = this.options;
+    let context;
+    let optimisticSnapshot;
+    const notify = (update) => {
+      this.client.mutationCache.notify(id, update);
+    };
+    try {
+      if (optimistic) {
+        const { queryKey, update } = optimistic;
+        const signal2 = this.client.getSignal(queryKey);
+        const currentData = signal2.get()?.data;
+        optimisticSnapshot = currentData;
+        const optimisticData = update(variables, currentData);
+        this.client.set(queryKey, optimisticData);
+      }
+      if (onMutate) {
+        context = await onMutate(variables);
+        notify({ context });
+      }
+      const result = await mutationFn(variables);
+      notify({ status: "success", data: result });
+      if (onSuccess) await onSuccess(result, variables, context);
+      if (this.client.invalidateTags && invalidatesTags) {
+        this.client.invalidateTags(invalidatesTags);
+      }
+      if (optimistic) {
+        this.client.invalidate(optimistic.queryKey);
+      }
+      if (onSettled) onSettled(result, null, variables, context);
+      return result;
+    } catch (error) {
+      if (optimistic && optimisticSnapshot !== void 0) {
+        this.client.set(optimistic.queryKey, optimisticSnapshot);
+      }
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      notify({ status: "error", error: errorObj });
+      if (onError) onError(errorObj, variables, context);
+      if (onSettled) onSettled(void 0, errorObj, variables, context);
+      throw error;
+    }
+  };
+  reset = () => {
+    this.signal.set({
+      status: "idle",
+      data: void 0,
+      error: null,
+      variables: void 0,
+      context: void 0,
+      submittedAt: 0
+    });
+    this.currentMutationId = null;
+  };
+};
+
+// src/query/useMutation.ts
+function useMutation(options) {
+  const client = useQueryClient();
+  const [observer] = (0, import_react9.useState)(() => new MutationObserver(client, options));
+  (0, import_react9.useEffect)(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const state = (0, import_react9.useSyncExternalStore)(
+    (0, import_react9.useCallback)((cb) => observer.signal.subscribe(cb), [observer]),
+    () => observer.signal.get()
+  );
+  const mutateAsync = (0, import_react9.useCallback)((variables) => {
+    return observer.mutate(variables);
+  }, [observer]);
+  const mutate = (0, import_react9.useCallback)((variables) => {
+    observer.mutate(variables).catch(() => {
+    });
+  }, [observer]);
+  return {
+    mutate,
+    mutateAsync,
+    data: state.data,
+    error: state.error,
+    status: state.status,
+    isLoading: state.status === "pending",
+    isError: state.status === "error",
+    isSuccess: state.status === "success",
+    isIdle: state.status === "idle",
+    reset: observer.reset
+  };
+}
+
+// src/query/infiniteQuery.ts
+var import_react10 = require("react");
+
 // src/query/plugins/logger.ts
 var consoleLogger = {
   log: console.log,
@@ -2517,26 +2665,26 @@ var InfiniteQueryObserver = class {
 // src/query/infiniteQuery.ts
 function useInfiniteQuery(options) {
   const client = useQueryClient();
-  const [observer] = (0, import_react9.useState)(() => new InfiniteQueryObserver(client, options));
-  (0, import_react9.useEffect)(() => {
+  const [observer] = (0, import_react10.useState)(() => new InfiniteQueryObserver(client, options));
+  (0, import_react10.useEffect)(() => {
     observer.setOptions(options);
   }, [observer, options]);
-  (0, import_react9.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     return () => {
       observer.destroy();
     };
   }, [observer]);
-  const subscribe = (0, import_react9.useCallback)((onStoreChange) => {
+  const subscribe = (0, import_react10.useCallback)((onStoreChange) => {
     return observer.result$.subscribe(() => onStoreChange());
   }, [observer]);
-  const getSnapshot = (0, import_react9.useCallback)(() => {
+  const getSnapshot = (0, import_react10.useCallback)(() => {
     return observer.result$.get();
   }, [observer]);
-  return (0, import_react9.useSyncExternalStore)(subscribe, getSnapshot);
+  return (0, import_react10.useSyncExternalStore)(subscribe, getSnapshot);
 }
 
 // src/query/HydrationBoundary.tsx
-var import_react10 = require("react");
+var import_react11 = require("react");
 
 // src/query/hydration.ts
 function dehydrate(client) {
@@ -2564,7 +2712,7 @@ function hydrate(client, state) {
 var import_jsx_runtime6 = require("react/jsx-runtime");
 function HydrationBoundary({ state, children }) {
   const client = useQueryClient();
-  const hydratedRef = (0, import_react10.useRef)(false);
+  const hydratedRef = (0, import_react11.useRef)(false);
   if (state && !hydratedRef.current) {
     hydrate(client, state);
     hydratedRef.current = true;
@@ -2573,14 +2721,14 @@ function HydrationBoundary({ state, children }) {
 }
 
 // src/query/useQuerySignal.ts
-var import_react11 = require("react");
+var import_react12 = require("react");
 function useQuery$(options) {
   const client = useQueryClient();
-  const [observer] = (0, import_react11.useState)(() => new QueryObserver(client, options));
-  (0, import_react11.useEffect)(() => {
+  const [observer] = (0, import_react12.useState)(() => new QueryObserver(client, options));
+  (0, import_react12.useEffect)(() => {
     observer.setOptions(options);
   }, [observer, options.enabled, options.staleTime, options.cacheTime, options.queryKey, options.refetchInterval]);
-  (0, import_react11.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     const unsubscribe = observer.subscribe(() => {
     });
     return () => {
@@ -2592,18 +2740,18 @@ function useQuery$(options) {
 }
 
 // src/query/useQueries.ts
-var import_react12 = require("react");
+var import_react13 = require("react");
 function useQueries(queries, client) {
   const queryClient = client || globalThis.__QUANTUM_CLIENT__;
   if (!queryClient) {
     throw new Error("[Quantum] No QueryClient found. Wrap your app with QueryClientProvider or pass a client.");
   }
-  const [observers] = (0, import_react12.useState)(
+  const [observers] = (0, import_react13.useState)(
     () => queries.map(
       (options) => new QueryObserver(queryClient, options)
     )
   );
-  const results = (0, import_react12.useSyncExternalStore)(
+  const results = (0, import_react13.useSyncExternalStore)(
     (callback) => {
       const unsubscribes = observers.map((observer) => observer.subscribe(callback));
       return () => {
@@ -2613,7 +2761,7 @@ function useQueries(queries, client) {
     () => observers.map((observer) => observer.getSnapshot()),
     () => observers.map((observer) => observer.getSnapshot())
   );
-  (0, import_react12.useEffect)(() => {
+  (0, import_react13.useEffect)(() => {
     queries.forEach((options, index) => {
       const observer = observers[index];
       if (observer) {
@@ -2621,7 +2769,7 @@ function useQueries(queries, client) {
       }
     });
   }, [queries, observers]);
-  (0, import_react12.useEffect)(() => {
+  (0, import_react13.useEffect)(() => {
     return () => {
       observers.forEach((observer) => observer.destroy());
     };
@@ -2671,6 +2819,7 @@ function useCombinedQueries(queries, client) {
   unwrapPromise,
   useCombinedQueries,
   useInfiniteQuery,
+  useMutation,
   usePaginatedQuery,
   useQueries,
   useQuery,

package/dist/index.d.cts

@@ -380,6 +380,33 @@ type SuspenseQueryResult<T> = Omit<UseQueryResult<T, T>, 'data' | 'isLoading' |
 };
 declare function useSuspenseQuery<T>(options: UseSuspenseQueryOptions<T>): SuspenseQueryResult<T>;
 
+interface UseMutationOptions<TData, TVariables, TContext = unknown> {
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    mutationKey?: unknown[];
+    onMutate?: (variables: TVariables) => Promise<TContext> | TContext;
+    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => void;
+    onError?: (error: Error, variables: TVariables, context: TContext | undefined) => void;
+    onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables, context: TContext | undefined) => void;
+    invalidatesTags?: string[];
+    optimistic?: {
+        queryKey: unknown[];
+        update: (variables: TVariables, oldData: unknown) => unknown;
+    };
+}
+interface MutationResult<TData, TVariables> {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    data: TData | undefined;
+    error: Error | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    isIdle: boolean;
+    status: 'idle' | 'pending' | 'success' | 'error';
+    reset: () => void;
+}
+declare function useMutation<TData = unknown, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TVariables, TContext>): MutationResult<TData, TVariables>;
+
 declare const QueryClientProvider: ({ client, children }: {
     client: QueryClient;
     children: ReactNode | undefined;
@@ -521,4 +548,4 @@ declare function useCombinedQueries<T extends readonly UseQueryOptions<any, any>
     refetchAll: () => Promise<void[]>;
 };
 
-export { type CacheEntry, HydrationBoundary, Match, MutationCache, type MutationState, type MutationStatus, type PaginatedQueryResult, QuantumDevTools, QueryClient, QueryClientProvider, type QueryKey, type QueryKeyInput, QueryMatch, type QueryPlugin, type QueryStatus, type Signal, SignalValue, type SuspenseQueryResult, type UsePaginatedQueryOptions, type UseQueriesResult, type UseQueryOptions, type UseQueryResult, type UseSuspenseQueryOptions, atom, createHttpClient, dehydrate, enableDevTools, getPromiseState, handlePromise, hydrate, isPromise, scheduleUpdate, unwrapPromise, useCombinedQueries, useInfiniteQuery, usePaginatedQuery, useQueries, useQuery, useQuery$, useQueryClient, useQueryStore, useSuspenseQuery };
+export { type CacheEntry, HydrationBoundary, Match, MutationCache, type MutationResult, type MutationState, type MutationStatus, type PaginatedQueryResult, QuantumDevTools, QueryClient, QueryClientProvider, type QueryKey, type QueryKeyInput, QueryMatch, type QueryPlugin, type QueryStatus, type Signal, SignalValue, type SuspenseQueryResult, type UseMutationOptions, type UsePaginatedQueryOptions, type UseQueriesResult, type UseQueryOptions, type UseQueryResult, type UseSuspenseQueryOptions, atom, createHttpClient, dehydrate, enableDevTools, getPromiseState, handlePromise, hydrate, isPromise, scheduleUpdate, unwrapPromise, useCombinedQueries, useInfiniteQuery, useMutation, usePaginatedQuery, useQueries, useQuery, useQuery$, useQueryClient, useQueryStore, useSuspenseQuery };

package/dist/index.d.ts

@@ -380,6 +380,33 @@ type SuspenseQueryResult<T> = Omit<UseQueryResult<T, T>, 'data' | 'isLoading' |
 };
 declare function useSuspenseQuery<T>(options: UseSuspenseQueryOptions<T>): SuspenseQueryResult<T>;
 
+interface UseMutationOptions<TData, TVariables, TContext = unknown> {
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    mutationKey?: unknown[];
+    onMutate?: (variables: TVariables) => Promise<TContext> | TContext;
+    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => void;
+    onError?: (error: Error, variables: TVariables, context: TContext | undefined) => void;
+    onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables, context: TContext | undefined) => void;
+    invalidatesTags?: string[];
+    optimistic?: {
+        queryKey: unknown[];
+        update: (variables: TVariables, oldData: unknown) => unknown;
+    };
+}
+interface MutationResult<TData, TVariables> {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    data: TData | undefined;
+    error: Error | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    isIdle: boolean;
+    status: 'idle' | 'pending' | 'success' | 'error';
+    reset: () => void;
+}
+declare function useMutation<TData = unknown, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TVariables, TContext>): MutationResult<TData, TVariables>;
+
 declare const QueryClientProvider: ({ client, children }: {
     client: QueryClient;
     children: ReactNode | undefined;
@@ -521,4 +548,4 @@ declare function useCombinedQueries<T extends readonly UseQueryOptions<any, any>
     refetchAll: () => Promise<void[]>;
 };
 
-export { type CacheEntry, HydrationBoundary, Match, MutationCache, type MutationState, type MutationStatus, type PaginatedQueryResult, QuantumDevTools, QueryClient, QueryClientProvider, type QueryKey, type QueryKeyInput, QueryMatch, type QueryPlugin, type QueryStatus, type Signal, SignalValue, type SuspenseQueryResult, type UsePaginatedQueryOptions, type UseQueriesResult, type UseQueryOptions, type UseQueryResult, type UseSuspenseQueryOptions, atom, createHttpClient, dehydrate, enableDevTools, getPromiseState, handlePromise, hydrate, isPromise, scheduleUpdate, unwrapPromise, useCombinedQueries, useInfiniteQuery, usePaginatedQuery, useQueries, useQuery, useQuery$, useQueryClient, useQueryStore, useSuspenseQuery };
+export { type CacheEntry, HydrationBoundary, Match, MutationCache, type MutationResult, type MutationState, type MutationStatus, type PaginatedQueryResult, QuantumDevTools, QueryClient, QueryClientProvider, type QueryKey, type QueryKeyInput, QueryMatch, type QueryPlugin, type QueryStatus, type Signal, SignalValue, type SuspenseQueryResult, type UseMutationOptions, type UsePaginatedQueryOptions, type UseQueriesResult, type UseQueryOptions, type UseQueryResult, type UseSuspenseQueryOptions, atom, createHttpClient, dehydrate, enableDevTools, getPromiseState, handlePromise, hydrate, isPromise, scheduleUpdate, unwrapPromise, useCombinedQueries, useInfiniteQuery, useMutation, usePaginatedQuery, useQueries, useQuery, useQuery$, useQueryClient, useQueryStore, useSuspenseQuery };

package/dist/index.js

@@ -2197,8 +2197,155 @@ function useSuspenseQuery(options) {
   };
 }
 
+// src/query/useMutation.ts
+import { useCallback as useCallback3, useEffect as useEffect6, useSyncExternalStore as useSyncExternalStore3, useState as useState7 } from "react";
+
+// src/query/mutationObserver.ts
+var generateId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "mutation-" + Date.now() + "-" + Math.random().toString(36).slice(2);
+};
+var MutationObserver = class {
+  client;
+  options;
+  currentMutationId = null;
+  // We maintain our own signal for this observer's view of the mutation
+  // This ensures we don't miss updates if we switch IDs.
+  signal;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+    this.signal = createSignal({
+      status: "idle",
+      data: void 0,
+      error: null,
+      variables: void 0,
+      context: void 0,
+      submittedAt: 0
+    });
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  mutate = (variables) => {
+    const id = generateId();
+    this.currentMutationId = id;
+    this.client.mutationCache.register(id, this.options.mutationKey);
+    const pendingState = {
+      status: "pending",
+      variables,
+      submittedAt: Date.now(),
+      data: void 0,
+      error: null,
+      context: void 0
+    };
+    this.signal.set({
+      ...this.signal.get(),
+      ...pendingState
+    });
+    this.client.mutationCache.notify(id, pendingState);
+    const unsubscribe = this.client.mutationCache.getSignal(id).subscribe((state) => {
+      untracked(() => {
+        const current = this.signal.get();
+        if (current.status !== state.status || current.data !== state.data || current.error !== state.error) {
+          this.signal.set(state);
+        }
+      });
+    });
+    return this.executeMutation(id, variables).finally(() => {
+    });
+  };
+  executeMutation = async (id, variables) => {
+    const { mutationFn, onMutate, onSuccess, onError, onSettled, invalidatesTags, optimistic, mutationKey } = this.options;
+    let context;
+    let optimisticSnapshot;
+    const notify = (update) => {
+      this.client.mutationCache.notify(id, update);
+    };
+    try {
+      if (optimistic) {
+        const { queryKey, update } = optimistic;
+        const signal2 = this.client.getSignal(queryKey);
+        const currentData = signal2.get()?.data;
+        optimisticSnapshot = currentData;
+        const optimisticData = update(variables, currentData);
+        this.client.set(queryKey, optimisticData);
+      }
+      if (onMutate) {
+        context = await onMutate(variables);
+        notify({ context });
+      }
+      const result = await mutationFn(variables);
+      notify({ status: "success", data: result });
+      if (onSuccess) await onSuccess(result, variables, context);
+      if (this.client.invalidateTags && invalidatesTags) {
+        this.client.invalidateTags(invalidatesTags);
+      }
+      if (optimistic) {
+        this.client.invalidate(optimistic.queryKey);
+      }
+      if (onSettled) onSettled(result, null, variables, context);
+      return result;
+    } catch (error) {
+      if (optimistic && optimisticSnapshot !== void 0) {
+        this.client.set(optimistic.queryKey, optimisticSnapshot);
+      }
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      notify({ status: "error", error: errorObj });
+      if (onError) onError(errorObj, variables, context);
+      if (onSettled) onSettled(void 0, errorObj, variables, context);
+      throw error;
+    }
+  };
+  reset = () => {
+    this.signal.set({
+      status: "idle",
+      data: void 0,
+      error: null,
+      variables: void 0,
+      context: void 0,
+      submittedAt: 0
+    });
+    this.currentMutationId = null;
+  };
+};
+
+// src/query/useMutation.ts
+function useMutation(options) {
+  const client = useQueryClient();
+  const [observer] = useState7(() => new MutationObserver(client, options));
+  useEffect6(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const state = useSyncExternalStore3(
+    useCallback3((cb) => observer.signal.subscribe(cb), [observer]),
+    () => observer.signal.get()
+  );
+  const mutateAsync = useCallback3((variables) => {
+    return observer.mutate(variables);
+  }, [observer]);
+  const mutate = useCallback3((variables) => {
+    observer.mutate(variables).catch(() => {
+    });
+  }, [observer]);
+  return {
+    mutate,
+    mutateAsync,
+    data: state.data,
+    error: state.error,
+    status: state.status,
+    isLoading: state.status === "pending",
+    isError: state.status === "error",
+    isSuccess: state.status === "success",
+    isIdle: state.status === "idle",
+    reset: observer.reset
+  };
+}
+
 // src/query/infiniteQuery.ts
-import { useState as useState7, useEffect as useEffect6, useCallback as useCallback3, useSyncExternalStore as useSyncExternalStore3 } from "react";
+import { useState as useState8, useEffect as useEffect7, useCallback as useCallback4, useSyncExternalStore as useSyncExternalStore4 } from "react";
 
 // src/query/plugins/logger.ts
 var consoleLogger = {
@@ -2471,22 +2618,22 @@ var InfiniteQueryObserver = class {
 // src/query/infiniteQuery.ts
 function useInfiniteQuery(options) {
   const client = useQueryClient();
-  const [observer] = useState7(() => new InfiniteQueryObserver(client, options));
-  useEffect6(() => {
+  const [observer] = useState8(() => new InfiniteQueryObserver(client, options));
+  useEffect7(() => {
     observer.setOptions(options);
   }, [observer, options]);
-  useEffect6(() => {
+  useEffect7(() => {
     return () => {
       observer.destroy();
     };
   }, [observer]);
-  const subscribe = useCallback3((onStoreChange) => {
+  const subscribe = useCallback4((onStoreChange) => {
     return observer.result$.subscribe(() => onStoreChange());
   }, [observer]);
-  const getSnapshot = useCallback3(() => {
+  const getSnapshot = useCallback4(() => {
     return observer.result$.get();
   }, [observer]);
-  return useSyncExternalStore3(subscribe, getSnapshot);
+  return useSyncExternalStore4(subscribe, getSnapshot);
 }
 
 // src/query/HydrationBoundary.tsx
@@ -2527,14 +2674,14 @@ function HydrationBoundary({ state, children }) {
 }
 
 // src/query/useQuerySignal.ts
-import { useEffect as useEffect7, useState as useState8 } from "react";
+import { useEffect as useEffect8, useState as useState9 } from "react";
 function useQuery$(options) {
   const client = useQueryClient();
-  const [observer] = useState8(() => new QueryObserver(client, options));
-  useEffect7(() => {
+  const [observer] = useState9(() => new QueryObserver(client, options));
+  useEffect8(() => {
     observer.setOptions(options);
   }, [observer, options.enabled, options.staleTime, options.cacheTime, options.queryKey, options.refetchInterval]);
-  useEffect7(() => {
+  useEffect8(() => {
     const unsubscribe = observer.subscribe(() => {
     });
     return () => {
@@ -2546,18 +2693,18 @@ function useQuery$(options) {
 }
 
 // src/query/useQueries.ts
-import { useEffect as useEffect8, useState as useState9, useSyncExternalStore as useSyncExternalStore4 } from "react";
+import { useEffect as useEffect9, useState as useState10, useSyncExternalStore as useSyncExternalStore5 } from "react";
 function useQueries(queries, client) {
   const queryClient = client || globalThis.__QUANTUM_CLIENT__;
   if (!queryClient) {
     throw new Error("[Quantum] No QueryClient found. Wrap your app with QueryClientProvider or pass a client.");
   }
-  const [observers] = useState9(
+  const [observers] = useState10(
     () => queries.map(
       (options) => new QueryObserver(queryClient, options)
     )
   );
-  const results = useSyncExternalStore4(
+  const results = useSyncExternalStore5(
     (callback) => {
       const unsubscribes = observers.map((observer) => observer.subscribe(callback));
       return () => {
@@ -2567,7 +2714,7 @@ function useQueries(queries, client) {
     () => observers.map((observer) => observer.getSnapshot()),
     () => observers.map((observer) => observer.getSnapshot())
   );
-  useEffect8(() => {
+  useEffect9(() => {
     queries.forEach((options, index) => {
       const observer = observers[index];
       if (observer) {
@@ -2575,7 +2722,7 @@ function useQueries(queries, client) {
       }
     });
   }, [queries, observers]);
-  useEffect8(() => {
+  useEffect9(() => {
     return () => {
       observers.forEach((observer) => observer.destroy());
     };
@@ -2624,6 +2771,7 @@ export {
   unwrapPromise,
   useCombinedQueries,
   useInfiniteQuery,
+  useMutation,
   usePaginatedQuery,
   useQueries,
   useQuery,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@braine/quantum-query",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "type": "module",
   "main": "index.js",
   "scripts": {