@pixotope/query 0.2.0 → 0.5.0

package/dist/index.d.cts

@@ -1,4 +1,5 @@
-import { ZMQProxyWSClient } from '@pixotope/zmq-client';
+import * as _pixotope_zmq_client from '@pixotope/zmq-client';
+import { ZMQClient, TSocketServerCallOptions, ZMQProxyWSClient } from '@pixotope/zmq-client';
 
 interface QueryOptions<TData = unknown, TError = unknown, TParams = void, TSelectData = TData, Stateless extends true | undefined = undefined> {
     queryFn: (params: TParams | undefined | void) => Promise<TData>;
@@ -45,6 +46,67 @@ interface MutateOptions<TData = unknown, TError = unknown, TParams = void> {
     onError?: (error: TError, variables: TParams) => void;
     onSettled?: (data: TData | undefined, error: TError | null, variables: TParams) => void;
 }
+type MutationStatus = "idle" | "loading" | "success" | "error";
+declare class ComparisonFailError<TPayload = unknown> extends Error {
+    readonly payload: TPayload;
+    constructor(message: string, payload: TPayload);
+}
+/**
+ * `useMutation` is a hook that allows you to perform a mutation/push updates to the services while
+ * providing extensive API to tap into the status and results of the mutation.
+ * @param mutationFn The mutation function to be called when the `mutate` function is called.
+ * `useMutation` does not care about what the function does, all it needs it a function that returns
+ * a promise.
+ * @param options Options to configure the mutation.
+ * @returns An object with the following properties:
+ * - `mutateAsync`: A function that takes in the variables and returns a promise that resolves to the
+ * result of the mutation. This function can be awaited to get the result of the mutation. Callbacks can
+ * be passed to this function to be called when the mutation is successful or when it fails. It's good idea
+ * to wrap this function in a try/catch block.
+ * - `mutate`: A function that takes in the variables and returns nothing. This function does not
+ * return a promise. Callbacks can be passed to this function to be called when the mutation is
+ * successful or when it fails.
+ * - `status`: The status of the mutation. Can be one of `idle`, `loading`, `success` or `error`.
+ * - `result`: The result of the mutation. This is undefined until the mutation is successful.
+ * - `reset`: A function that resets the mutation to the initial state.
+ * - `error`: The error object if the mutation has failed.
+ * @example
+ * ```typescript
+ * const mutationRes = useMutation({
+ *    mutationFn: (variables) => {
+ *      return ZMQHelper.callSomethingAsync(variables)
+ *    },
+ *    onSuccess: (data) => {
+ *      // do something with the result
+ *    },
+ *    onError: (error) => {
+ *      // do something with the error
+ *    },
+ *    onSettled: (data, error) => {
+ *      // do something when the mutation is done
+ *   }});
+ *
+ * // call the mutation
+ * const res = await mutationRes.mutateAsync({ foo: "bar" });
+ * // OR
+ * mutationRes.mutate({ foo: "bar" }, {
+ *  onSuccess: (data) => {
+ *    // do something with the result
+ *    // for example show a toast message
+ *    // stop local loading state
+ * });
+ * ```
+ */
+declare const useMutation: <TData = unknown, TError = unknown, TParams = void>(options: MutationOptions<TData, TError, TParams>) => {
+    mutateAsync: (params: TParams, overrideTargetMachine?: string) => Promise<TData>;
+    status: MutationStatus;
+    result: TData | undefined;
+    mutate: (variables: TParams, options?: MutateOptions<TData, TError, TParams> & {
+        overrideTargetMachine?: string;
+    }) => void;
+    reset: () => void;
+    error: TError | null;
+};
 
 type MutationInfo<TData, TError, TParams> = {
     data: TData;
@@ -52,7 +114,12 @@ type MutationInfo<TData, TError, TParams> = {
     params: TParams;
 };
 type FnToParamsBase = Record<string, MutationInfo<unknown, unknown, unknown>>;
-declare const useCallMutationBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown>(clientProxy: ZMQProxyWSClient, functionName: keyof TFnToParams, service: string, options?: Omit<MutationOptions<TData, TError, TParams>, "mutationFn"> & {
+type TPromiseFunction<TResponse, TParams> = (args: Omit<ZMQClient.Call<TResponse, {
+    functionName: string;
+    parameters: TParams;
+    options?: Omit<TSocketServerCallOptions, "toCallIfNoResponse">;
+}>, "id">) => Promise<TResponse>;
+declare const useCallMutationBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown>(promiseFunc: TPromiseFunction<TData, TParams>, functionName: keyof TFnToParams, service: string, options?: Omit<MutationOptions<TData, TError, TParams>, "mutationFn"> & {
     avoidTimeout?: boolean;
     customTimeout?: number;
 }) => {
@@ -65,7 +132,7 @@ declare const useCallMutationBase: <TFnToParams extends FnToParamsBase, TData =
     reset: () => void;
     error: TError | null;
 };
-declare function buildMutationHook<TFnToParams extends FnToParamsBase>(socketClientProxy: ZMQProxyWSClient, genTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams>(func: TFn, options?: Parameters<typeof useCallMutationBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"]>>[3] & {
+declare function buildMutationHook<TFnToParams extends FnToParamsBase>(promiseFunc: TPromiseFunction<unknown, unknown>, genTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams>(func: TFn, options?: Parameters<typeof useCallMutationBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"]>>[3] & {
     machine?: string;
 }) => {
     mutateAsync: (params: TFnToParams[TFn]["params"], overrideTargetMachine?: string) => Promise<TFnToParams[TFn]["data"]>;
@@ -77,11 +144,11 @@ declare function buildMutationHook<TFnToParams extends FnToParamsBase>(socketCli
     reset: () => void;
     error: TFnToParams[TFn]["error"] | null;
 };
-declare const useCallQueryBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown, TSelect = TData>(clientProxy: ZMQProxyWSClient, functionName: keyof TFnToParams, params: TParams, service: string, options?: Omit<QueryOptions<TData, TError, TParams, TSelect>, "queryFn"> & {
+declare const useCallQueryBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown, TSelect = TData>(promiseFunction: TPromiseFunction<TData, TParams>, functionName: keyof TFnToParams, params: TParams, service: string, options?: Omit<QueryOptions<TData, TError, TParams, TSelect>, "queryFn"> & {
     avoidTimeout?: boolean;
     customTimeout?: number;
 }) => UseQueryResult<TSelect, TError, TParams, TSelect, undefined>;
-declare function buildQueryHook<TFnToParams extends FnToParamsBase>(clientSocketProxy: ZMQProxyWSClient, getTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams, TSelect = TFnToParams[TFn]["data"]>(func: TFn, params: TFnToParams[TFn]["params"], options?: Parameters<typeof useCallQueryBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"], TSelect>>[4] & {
+declare function buildQueryHook<TFnToParams extends FnToParamsBase>(promiseFunction: TPromiseFunction<unknown, unknown>, getTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams, TSelect = TFnToParams[TFn]["data"]>(func: TFn, params: TFnToParams[TFn]["params"], options?: Parameters<typeof useCallQueryBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"], TSelect>>[4] & {
     machine?: string;
 }) => UseQueryResult<TSelect, TFnToParams[TFn]["error"], TFnToParams[TFn]["params"], TSelect, undefined>;
 
@@ -153,6 +220,19 @@ type WithData<TData> = {
 type SubscriptionCoreReturnType<TData, Stateless extends true | undefined> = {
     reSubscribe: () => void;
 } & (Stateless extends true ? {} : WithStatus & WithData<TData>);
+/**
+ * @description `useSubscriptionCore` | This hook handle core subscription logic
+ * and provides a way to subscribe and unsubscribe to a topic via any callback.
+ * The hook expose a handler function. All the consumer code need to do is to
+ * call this handler function with the message received from the topic or pass
+ * it directly to the callback function that is passed to the subscriberFn.
+ *  - `status` - current status of the subscription
+ *  - `data` - the data after the select function is applied to the message
+ *  - `reSubscribe` - function that can be called to re-subscribe to the topic
+ *
+ * An example how this hook works can be found in {@link ./useSubscription.ts}
+ */
+declare function useSubscriptionCore<TData = unknown, TMessage = TData, Stateless extends true | undefined = undefined>(options: SubscriptionCoreOptions<TData, TMessage, Stateless>): SubscriptionCoreReturnType<TData, Stateless>;
 
 type SubscriptionOptions<TData, TMessage = unknown, Stateless extends true | undefined = undefined> = Omit<SubscriptionCoreOptions<TData, TMessage, Stateless>, "subscriberFn"> & {
     service: string;
@@ -169,11 +249,17 @@ declare function useSubscription<TData = unknown, TMessage = TData, Stateless ex
 declare function buildServiceSubscriptionHook(subscriptionHandler: TSubscriptionHandlerFunction<unknown>, targetMachine: (machine: string | undefined) => string): <TData, TMessage = TData, Stateless extends true | undefined = undefined>(options: Omit<SubscriptionOptions<TData, TMessage, Stateless>, "service"> & {
     machine?: string;
 }) => SubscriptionCoreReturnType<TData, Stateless>;
+
 declare function bindClientSocketProxy(socketClientProxy: ZMQProxyWSClient): (opts: {
     service: string;
     name: string;
     callback: (message: unknown) => void;
     maxDownwardDepth?: number;
 }) => () => void;
+declare function bindPromiseFunction(clientSocketProxy: ZMQProxyWSClient): (args: Omit<_pixotope_zmq_client.ZMQClient.Call<unknown, {
+    functionName: string;
+    parameters: unknown;
+    options?: Omit<_pixotope_zmq_client.TSocketServerCallOptions, "toCallIfNoResponse">;
+}>, "id">) => Promise<unknown>;
 
-export { type MutationInfo, type QueryOptions, type SubscriptionOptions, type TSubscriptionHandlerFunction, type UseQueryResult, bindClientSocketProxy, buildMutationHook, buildQueryHook, buildServiceSubscriptionHook, useQuery, useSubscription };
+export { ComparisonFailError, type Connection, type MessageHandler, type MutateOptions, type MutationFunction, type MutationInfo, type MutationOptions, type QueryOptions, type SubscriptionCoreOptions, type SubscriptionCoreReturnType, type SubscriptionOptions, type TPromiseFunction, type TSubscriptionHandlerFunction, type UseQueryResult, bindClientSocketProxy, bindPromiseFunction, buildMutationHook, buildQueryHook, buildServiceSubscriptionHook, useMutation, useQuery, useSubscription, useSubscriptionCore };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { ZMQProxyWSClient } from '@pixotope/zmq-client';
+import * as _pixotope_zmq_client from '@pixotope/zmq-client';
+import { ZMQClient, TSocketServerCallOptions, ZMQProxyWSClient } from '@pixotope/zmq-client';
 
 interface QueryOptions<TData = unknown, TError = unknown, TParams = void, TSelectData = TData, Stateless extends true | undefined = undefined> {
     queryFn: (params: TParams | undefined | void) => Promise<TData>;
@@ -45,6 +46,67 @@ interface MutateOptions<TData = unknown, TError = unknown, TParams = void> {
     onError?: (error: TError, variables: TParams) => void;
     onSettled?: (data: TData | undefined, error: TError | null, variables: TParams) => void;
 }
+type MutationStatus = "idle" | "loading" | "success" | "error";
+declare class ComparisonFailError<TPayload = unknown> extends Error {
+    readonly payload: TPayload;
+    constructor(message: string, payload: TPayload);
+}
+/**
+ * `useMutation` is a hook that allows you to perform a mutation/push updates to the services while
+ * providing extensive API to tap into the status and results of the mutation.
+ * @param mutationFn The mutation function to be called when the `mutate` function is called.
+ * `useMutation` does not care about what the function does, all it needs it a function that returns
+ * a promise.
+ * @param options Options to configure the mutation.
+ * @returns An object with the following properties:
+ * - `mutateAsync`: A function that takes in the variables and returns a promise that resolves to the
+ * result of the mutation. This function can be awaited to get the result of the mutation. Callbacks can
+ * be passed to this function to be called when the mutation is successful or when it fails. It's good idea
+ * to wrap this function in a try/catch block.
+ * - `mutate`: A function that takes in the variables and returns nothing. This function does not
+ * return a promise. Callbacks can be passed to this function to be called when the mutation is
+ * successful or when it fails.
+ * - `status`: The status of the mutation. Can be one of `idle`, `loading`, `success` or `error`.
+ * - `result`: The result of the mutation. This is undefined until the mutation is successful.
+ * - `reset`: A function that resets the mutation to the initial state.
+ * - `error`: The error object if the mutation has failed.
+ * @example
+ * ```typescript
+ * const mutationRes = useMutation({
+ *    mutationFn: (variables) => {
+ *      return ZMQHelper.callSomethingAsync(variables)
+ *    },
+ *    onSuccess: (data) => {
+ *      // do something with the result
+ *    },
+ *    onError: (error) => {
+ *      // do something with the error
+ *    },
+ *    onSettled: (data, error) => {
+ *      // do something when the mutation is done
+ *   }});
+ *
+ * // call the mutation
+ * const res = await mutationRes.mutateAsync({ foo: "bar" });
+ * // OR
+ * mutationRes.mutate({ foo: "bar" }, {
+ *  onSuccess: (data) => {
+ *    // do something with the result
+ *    // for example show a toast message
+ *    // stop local loading state
+ * });
+ * ```
+ */
+declare const useMutation: <TData = unknown, TError = unknown, TParams = void>(options: MutationOptions<TData, TError, TParams>) => {
+    mutateAsync: (params: TParams, overrideTargetMachine?: string) => Promise<TData>;
+    status: MutationStatus;
+    result: TData | undefined;
+    mutate: (variables: TParams, options?: MutateOptions<TData, TError, TParams> & {
+        overrideTargetMachine?: string;
+    }) => void;
+    reset: () => void;
+    error: TError | null;
+};
 
 type MutationInfo<TData, TError, TParams> = {
     data: TData;
@@ -52,7 +114,12 @@ type MutationInfo<TData, TError, TParams> = {
     params: TParams;
 };
 type FnToParamsBase = Record<string, MutationInfo<unknown, unknown, unknown>>;
-declare const useCallMutationBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown>(clientProxy: ZMQProxyWSClient, functionName: keyof TFnToParams, service: string, options?: Omit<MutationOptions<TData, TError, TParams>, "mutationFn"> & {
+type TPromiseFunction<TResponse, TParams> = (args: Omit<ZMQClient.Call<TResponse, {
+    functionName: string;
+    parameters: TParams;
+    options?: Omit<TSocketServerCallOptions, "toCallIfNoResponse">;
+}>, "id">) => Promise<TResponse>;
+declare const useCallMutationBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown>(promiseFunc: TPromiseFunction<TData, TParams>, functionName: keyof TFnToParams, service: string, options?: Omit<MutationOptions<TData, TError, TParams>, "mutationFn"> & {
     avoidTimeout?: boolean;
     customTimeout?: number;
 }) => {
@@ -65,7 +132,7 @@ declare const useCallMutationBase: <TFnToParams extends FnToParamsBase, TData =
     reset: () => void;
     error: TError | null;
 };
-declare function buildMutationHook<TFnToParams extends FnToParamsBase>(socketClientProxy: ZMQProxyWSClient, genTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams>(func: TFn, options?: Parameters<typeof useCallMutationBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"]>>[3] & {
+declare function buildMutationHook<TFnToParams extends FnToParamsBase>(promiseFunc: TPromiseFunction<unknown, unknown>, genTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams>(func: TFn, options?: Parameters<typeof useCallMutationBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"]>>[3] & {
     machine?: string;
 }) => {
     mutateAsync: (params: TFnToParams[TFn]["params"], overrideTargetMachine?: string) => Promise<TFnToParams[TFn]["data"]>;
@@ -77,11 +144,11 @@ declare function buildMutationHook<TFnToParams extends FnToParamsBase>(socketCli
     reset: () => void;
     error: TFnToParams[TFn]["error"] | null;
 };
-declare const useCallQueryBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown, TSelect = TData>(clientProxy: ZMQProxyWSClient, functionName: keyof TFnToParams, params: TParams, service: string, options?: Omit<QueryOptions<TData, TError, TParams, TSelect>, "queryFn"> & {
+declare const useCallQueryBase: <TFnToParams extends FnToParamsBase, TData = unknown, TError = unknown, TParams = unknown, TSelect = TData>(promiseFunction: TPromiseFunction<TData, TParams>, functionName: keyof TFnToParams, params: TParams, service: string, options?: Omit<QueryOptions<TData, TError, TParams, TSelect>, "queryFn"> & {
     avoidTimeout?: boolean;
     customTimeout?: number;
 }) => UseQueryResult<TSelect, TError, TParams, TSelect, undefined>;
-declare function buildQueryHook<TFnToParams extends FnToParamsBase>(clientSocketProxy: ZMQProxyWSClient, getTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams, TSelect = TFnToParams[TFn]["data"]>(func: TFn, params: TFnToParams[TFn]["params"], options?: Parameters<typeof useCallQueryBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"], TSelect>>[4] & {
+declare function buildQueryHook<TFnToParams extends FnToParamsBase>(promiseFunction: TPromiseFunction<unknown, unknown>, getTargetService: (machine: string | undefined) => string): <TFn extends keyof TFnToParams, TSelect = TFnToParams[TFn]["data"]>(func: TFn, params: TFnToParams[TFn]["params"], options?: Parameters<typeof useCallQueryBase<TFnToParams, TFnToParams[TFn]["data"], TFnToParams[TFn]["error"], TFnToParams[TFn]["params"], TSelect>>[4] & {
     machine?: string;
 }) => UseQueryResult<TSelect, TFnToParams[TFn]["error"], TFnToParams[TFn]["params"], TSelect, undefined>;
 
@@ -153,6 +220,19 @@ type WithData<TData> = {
 type SubscriptionCoreReturnType<TData, Stateless extends true | undefined> = {
     reSubscribe: () => void;
 } & (Stateless extends true ? {} : WithStatus & WithData<TData>);
+/**
+ * @description `useSubscriptionCore` | This hook handle core subscription logic
+ * and provides a way to subscribe and unsubscribe to a topic via any callback.
+ * The hook expose a handler function. All the consumer code need to do is to
+ * call this handler function with the message received from the topic or pass
+ * it directly to the callback function that is passed to the subscriberFn.
+ *  - `status` - current status of the subscription
+ *  - `data` - the data after the select function is applied to the message
+ *  - `reSubscribe` - function that can be called to re-subscribe to the topic
+ *
+ * An example how this hook works can be found in {@link ./useSubscription.ts}
+ */
+declare function useSubscriptionCore<TData = unknown, TMessage = TData, Stateless extends true | undefined = undefined>(options: SubscriptionCoreOptions<TData, TMessage, Stateless>): SubscriptionCoreReturnType<TData, Stateless>;
 
 type SubscriptionOptions<TData, TMessage = unknown, Stateless extends true | undefined = undefined> = Omit<SubscriptionCoreOptions<TData, TMessage, Stateless>, "subscriberFn"> & {
     service: string;
@@ -169,11 +249,17 @@ declare function useSubscription<TData = unknown, TMessage = TData, Stateless ex
 declare function buildServiceSubscriptionHook(subscriptionHandler: TSubscriptionHandlerFunction<unknown>, targetMachine: (machine: string | undefined) => string): <TData, TMessage = TData, Stateless extends true | undefined = undefined>(options: Omit<SubscriptionOptions<TData, TMessage, Stateless>, "service"> & {
     machine?: string;
 }) => SubscriptionCoreReturnType<TData, Stateless>;
+
 declare function bindClientSocketProxy(socketClientProxy: ZMQProxyWSClient): (opts: {
     service: string;
     name: string;
     callback: (message: unknown) => void;
     maxDownwardDepth?: number;
 }) => () => void;
+declare function bindPromiseFunction(clientSocketProxy: ZMQProxyWSClient): (args: Omit<_pixotope_zmq_client.ZMQClient.Call<unknown, {
+    functionName: string;
+    parameters: unknown;
+    options?: Omit<_pixotope_zmq_client.TSocketServerCallOptions, "toCallIfNoResponse">;
+}>, "id">) => Promise<unknown>;
 
-export { type MutationInfo, type QueryOptions, type SubscriptionOptions, type TSubscriptionHandlerFunction, type UseQueryResult, bindClientSocketProxy, buildMutationHook, buildQueryHook, buildServiceSubscriptionHook, useQuery, useSubscription };
+export { ComparisonFailError, type Connection, type MessageHandler, type MutateOptions, type MutationFunction, type MutationInfo, type MutationOptions, type QueryOptions, type SubscriptionCoreOptions, type SubscriptionCoreReturnType, type SubscriptionOptions, type TPromiseFunction, type TSubscriptionHandlerFunction, type UseQueryResult, bindClientSocketProxy, bindPromiseFunction, buildMutationHook, buildQueryHook, buildServiceSubscriptionHook, useMutation, useQuery, useSubscription, useSubscriptionCore };

package/dist/index.js

@@ -264,6 +264,7 @@ import { useCallback as useCallback2, useEffect, useRef as useRef2, useState as
 function normalizeQueryKey(queryKey) {
   return JSON.stringify(queryKey);
 }
+var getRandomUUID = () => Math.random().toString(36).substring(2, 15);
 var useQuery = (_a) => {
   var _b = _a, {
     queryFn
@@ -285,7 +286,6 @@ var useQuery = (_a) => {
     key: queryKeyPassed
   } = options;
   const queryKey = normalizeQueryKey(queryKeyPassed != null ? queryKeyPassed : []);
-  const promiseResolutionInProgress = useRef2(false);
   const lastFetchedAt = useRef2(null);
   const lastQueryKey = useRef2(void 0);
   const queryFnRef = useRef2(queryFn);
@@ -314,6 +314,7 @@ var useQuery = (_a) => {
     stateless,
     timeout
   };
+  const requestIdRef = useRef2(getRandomUUID());
   const [status, setStatus] = useState2(() => {
     return "idle";
   });
@@ -346,7 +347,9 @@ var useQuery = (_a) => {
   const refetch = useCallback2(
     (params = void 0) => __async(null, null, function* () {
       var _a2, _b2, _c, _d, _e, _f, _g, _h;
-      if (promiseResolutionInProgress.current || !internalOptionsRef.current.enabled) {
+      const requestId = getRandomUUID();
+      requestIdRef.current = requestId;
+      if (!internalOptionsRef.current.enabled) {
         return;
       }
       setStatus("loading");
@@ -363,9 +366,10 @@ var useQuery = (_a) => {
             )
           ] : []
         ];
-        promiseResolutionInProgress.current = true;
         const res = yield Promise.race(promises);
-        promiseResolutionInProgress.current = false;
+        if (requestIdRef.current !== requestId) {
+          return;
+        }
         if (res === "timeout") {
           throw new Error("timeout");
         }
@@ -393,36 +397,17 @@ var useQuery = (_a) => {
     refetch();
   }, [refetch]);
   useEffect(() => {
-    if (enabled) {
-      refetch();
-    }
-  }, [enabled, refetch, queryKey]);
-  useEffect(() => {
-    if (lastQueryKey.current === void 0) {
-      lastQueryKey.current = queryKey;
-      refetch();
-      return;
-    }
-    if (queryKey !== lastQueryKey.current) {
-      lastQueryKey.current = queryKey;
-      refetch();
-    }
-  }, [queryKey, refetch, enabled]);
-  useEffect(() => {
+    const cleanups = [];
     if (refetchOnWindowFocus) {
       const queryHandleFocus = () => {
-        if (shouldRefetch()) {
-          refetch();
-        }
+        refetch();
       };
       window.addEventListener("focus", queryHandleFocus);
-      return () => {
+      cleanups.push(() => {
         window.removeEventListener("focus", queryHandleFocus);
-      };
+      });
     }
-  }, [refetchOnWindowFocus, refetch, shouldRefetch]);
-  useEffect(() => {
-    if (refetchInterval !== 0) {
+    if (refetchInterval > 0) {
       const interval = setInterval(
         () => {
           if (shouldRefetch()) {
@@ -431,11 +416,25 @@ var useQuery = (_a) => {
         },
         Math.max(refetchInterval, 1e3)
       );
-      return () => {
+      cleanups.push(() => {
         clearInterval(interval);
-      };
+      });
+    }
+    if (lastQueryKey.current === void 0 || queryKey !== lastQueryKey.current) {
+      lastQueryKey.current = queryKey;
+      refetch();
     }
-  }, [refetch, refetchInterval, shouldRefetch]);
+    return () => {
+      cleanups.forEach((cleanup) => cleanup());
+    };
+  }, [
+    queryKey,
+    enabled,
+    refetchOnWindowFocus,
+    refetchInterval,
+    shouldRefetch,
+    refetch
+  ]);
   return {
     data: select && data !== void 0 ? select(data) : data,
     error,
@@ -446,7 +445,7 @@ var useQuery = (_a) => {
 };
 
 // src/factories.ts
-var useCallMutationBase = (clientProxy, functionName, service, options) => {
+var useCallMutationBase = (promiseFunc, functionName, service, options) => {
   const _a = useMemo(() => options != null ? options : {}, [options]), {
     avoidTimeout = true,
     customTimeout = void 0
@@ -457,7 +456,7 @@ var useCallMutationBase = (clientProxy, functionName, service, options) => {
   const mutationFn = useCallback3(
     (parameters) => __async(null, null, function* () {
       try {
-        const res = yield clientProxy.callAsync({
+        return yield promiseFunc({
           service,
           functionName: functionName.toString(),
           parameters,
@@ -466,7 +465,6 @@ var useCallMutationBase = (clientProxy, functionName, service, options) => {
             customTimeout
           }
         });
-        return res.message.Result;
       } catch (e) {
         throw e.message;
       }
@@ -477,13 +475,13 @@ var useCallMutationBase = (clientProxy, functionName, service, options) => {
     mutationFn
   }, rest));
 };
-function buildMutationHook(socketClientProxy, genTargetService) {
+function buildMutationHook(promiseFunc, genTargetService) {
   return function useCallMutationBuilder(func, options) {
     const targetService = genTargetService(options == null ? void 0 : options.machine);
-    return useCallMutationBase(socketClientProxy, func, targetService, options);
+    return useCallMutationBase(promiseFunc, func, targetService, options);
   };
 }
-var useCallQueryBase = (clientProxy, functionName, params, service, options) => {
+var useCallQueryBase = (promiseFunction, functionName, params, service, options) => {
   const _a = useMemo(() => options != null ? options : {}, [options]), {
     avoidTimeout = true,
     customTimeout = void 0
@@ -494,7 +492,7 @@ var useCallQueryBase = (clientProxy, functionName, params, service, options) =>
   const queryFn = useCallback3(
     (refetchParams, overrideTargetMachine) => __async(null, null, function* () {
       try {
-        const res = yield clientProxy.callAsync({
+        return yield promiseFunction({
           service: overrideTargetMachine != null ? overrideTargetMachine : service,
           functionName: functionName.toString(),
           parameters: refetchParams != null ? refetchParams : params,
@@ -503,7 +501,6 @@ var useCallQueryBase = (clientProxy, functionName, params, service, options) =>
             customTimeout
           }
         });
-        return res.message.Result;
       } catch (e) {
         if (e instanceof Error) {
           throw e;
@@ -517,10 +514,10 @@ var useCallQueryBase = (clientProxy, functionName, params, service, options) =>
     queryFn
   }, rest));
 };
-function buildQueryHook(clientSocketProxy, getTargetService) {
+function buildQueryHook(promiseFunction, getTargetService) {
   return function useCallQueryBuilder(func, params, options) {
     const targetService = getTargetService(options == null ? void 0 : options.machine);
-    return useCallQueryBase(clientSocketProxy, func, params, targetService, options);
+    return useCallQueryBase(promiseFunction, func, params, targetService, options);
   };
 }
 
@@ -660,15 +657,34 @@ function buildServiceSubscriptionHook(subscriptionHandler, targetMachine) {
     );
   };
 }
+
+// src/proxyBinders.ts
 function bindClientSocketProxy(socketClientProxy) {
-  return (...args) => socketClientProxy.mirror(...args)[0];
+  return (...args) => {
+    const _a = args[0], { callback: cbHook } = _a, rest = __objRest(_a, ["callback"]);
+    return socketClientProxy.mirror(__spreadProps(__spreadValues({}, rest), {
+      callback: (message) => {
+        cbHook(message.message);
+      }
+    }))[0];
+  };
+}
+function bindPromiseFunction(clientSocketProxy) {
+  return (...args) => __async(null, null, function* () {
+    const res = yield clientSocketProxy.callAsync(...args);
+    return res.message.Result;
+  });
 }
 export {
+  ComparisonFailError,
   bindClientSocketProxy,
+  bindPromiseFunction,
   buildMutationHook,
   buildQueryHook,
   buildServiceSubscriptionHook,
+  useMutation,
   useQuery,
-  useSubscription
+  useSubscription,
+  useSubscriptionCore
 };
 //# sourceMappingURL=index.js.map