@trpc/react-query 10.8.1 → 10.8.2

package/dist/{createHooksInternal-d8e5577b.js → createHooksInternal-57a3cf21.js}

@@ -143,7 +143,7 @@ const TRPCContext = /*#__PURE__*/ React.createContext(null);
             queryFn: ()=>{
                 return client.query(path, input);
             },
-            ...rest[1]
+            ...rest[0]
         };
         return options;
     });
@@ -199,69 +199,95 @@ function getClientArgs(pathAndInput, opts) {
                 ssrContext: ssrContext || null,
                 ssrState,
                 fetchQuery: React.useCallback((pathAndInput, opts)=>{
-                    return queryClient.fetchQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'), ()=>client.query(...getClientArgs(pathAndInput, opts)), opts);
+                    return queryClient.fetchQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'),
+                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
                 fetchInfiniteQuery: React.useCallback((pathAndInput, opts)=>{
-                    return queryClient.fetchInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'), ({ pageParam  })=>{
-                        const [path, input] = pathAndInput;
-                        const actualInput = {
-                            ...input,
-                            cursor: pageParam
-                        };
-                        return client.query(...getClientArgs([
-                            path,
-                            actualInput
-                        ], opts));
-                    }, opts);
+                    return queryClient.fetchInfiniteQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'),
+                        queryFn: ({ pageParam  })=>{
+                            const [path, input] = pathAndInput;
+                            const actualInput = {
+                                ...input,
+                                cursor: pageParam
+                            };
+                            return client.query(...getClientArgs([
+                                path,
+                                actualInput
+                            ], opts));
+                        }
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
                 prefetchQuery: React.useCallback((pathAndInput, opts)=>{
-                    return queryClient.prefetchQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'), ()=>client.query(...getClientArgs(pathAndInput, opts)), opts);
+                    return queryClient.prefetchQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'),
+                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
                 prefetchInfiniteQuery: React.useCallback((pathAndInput, opts)=>{
-                    return queryClient.prefetchInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'), ({ pageParam  })=>{
-                        const [path, input] = pathAndInput;
-                        const actualInput = {
-                            ...input,
-                            cursor: pageParam
-                        };
-                        return client.query(...getClientArgs([
-                            path,
-                            actualInput
-                        ], opts));
-                    }, opts);
+                    return queryClient.prefetchInfiniteQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'),
+                        queryFn: ({ pageParam  })=>{
+                            const [path, input] = pathAndInput;
+                            const actualInput = {
+                                ...input,
+                                cursor: pageParam
+                            };
+                            return client.query(...getClientArgs([
+                                path,
+                                actualInput
+                            ], opts));
+                        }
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
-                invalidateQueries: React.useCallback((...args)=>{
-                    const [queryKey, ...rest] = args;
-                    return queryClient.invalidateQueries(getArrayQueryKey.getArrayQueryKey(queryKey, 'any'), ...rest);
+                invalidateQueries: React.useCallback((queryKey, filters, options)=>{
+                    return queryClient.invalidateQueries({
+                        ...filters,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(queryKey, 'any')
+                    }, options);
                 }, [
                     queryClient
                 ]),
                 resetQueries: React.useCallback((...args)=>{
-                    const [queryKey, ...rest] = args;
-                    return queryClient.resetQueries(getArrayQueryKey.getArrayQueryKey(queryKey, 'any'), ...rest);
+                    const [queryKey, filters, options] = args;
+                    return queryClient.resetQueries({
+                        ...filters,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(queryKey, 'any')
+                    }, options);
                 }, [
                     queryClient
                 ]),
                 refetchQueries: React.useCallback((...args)=>{
-                    const [queryKey, ...rest] = args;
-                    return queryClient.refetchQueries(getArrayQueryKey.getArrayQueryKey(queryKey, 'any'), ...rest);
+                    const [queryKey, filters, options] = args;
+                    return queryClient.refetchQueries({
+                        ...filters,
+                        queryKey: getArrayQueryKey.getArrayQueryKey(queryKey, 'any')
+                    }, options);
                 }, [
                     queryClient
                 ]),
                 cancelQuery: React.useCallback((pathAndInput)=>{
-                    return queryClient.cancelQueries(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'any'));
+                    return queryClient.cancelQueries({
+                        queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'any')
+                    });
                 }, [
                     queryClient
                 ]),
@@ -314,20 +340,22 @@ function getClientArgs(pathAndInput, opts) {
         const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, 'query', opts);
         // request option should take priority over global
         const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
-        const hook = reactQuery.useQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'), (queryFunctionContext)=>{
-            const actualOpts = {
-                ...ssrOpts,
-                trpc: {
-                    ...ssrOpts?.trpc,
-                    ...shouldAbortOnUnmount ? {
-                        signal: queryFunctionContext.signal
-                    } : {}
-                }
-            };
-            return client.query(...getClientArgs(pathAndInput, actualOpts));
-        }, {
-            context: ReactQueryContext,
-            ...ssrOpts
+        const hook = reactQuery.useQuery({
+            ...ssrOpts,
+            queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'),
+            queryFn: (queryFunctionContext)=>{
+                const actualOpts = {
+                    ...ssrOpts,
+                    trpc: {
+                        ...ssrOpts?.trpc,
+                        ...shouldAbortOnUnmount ? {
+                            signal: queryFunctionContext.signal
+                        } : {}
+                    }
+                };
+                return client.query(...getClientArgs(pathAndInput, actualOpts));
+            },
+            context: ReactQueryContext
         });
         hook.trpc = useHookResult({
             path: pathAndInput[0]
@@ -340,15 +368,16 @@ function getClientArgs(pathAndInput, opts) {
         const queryClient = reactQuery.useQueryClient({
             context: ReactQueryContext
         });
-        const hook = reactQuery.useMutation((input)=>{
-            const actualPath = Array.isArray(path) ? path[0] : path;
-            return client.mutation(...getClientArgs([
-                actualPath,
-                input
-            ], opts));
-        }, {
-            context: ReactQueryContext,
+        const hook = reactQuery.useMutation({
             ...opts,
+            mutationFn: (input)=>{
+                const actualPath = Array.isArray(path) ? path[0] : path;
+                return client.mutation(...getClientArgs([
+                    actualPath,
+                    input
+                ], opts));
+            },
+            context: ReactQueryContext,
             onSuccess (...args) {
                 const originalFn = ()=>opts?.onSuccess?.(...args);
                 return mutationSuccessOverride({
@@ -410,28 +439,30 @@ function getClientArgs(pathAndInput, opts) {
         const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, 'infinite', opts);
         // request option should take priority over global
         const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
-        const hook = reactQuery.useInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'), (queryFunctionContext)=>{
-            const actualOpts = {
-                ...ssrOpts,
-                trpc: {
-                    ...ssrOpts?.trpc,
-                    ...shouldAbortOnUnmount ? {
-                        signal: queryFunctionContext.signal
-                    } : {}
-                }
-            };
-            const actualInput = {
-                ...input ?? {},
-                cursor: queryFunctionContext.pageParam
-            };
-            // FIXME as any shouldn't be needed as client should be untyped too
-            return client.query(...getClientArgs([
-                path,
-                actualInput
-            ], actualOpts));
-        }, {
-            context: ReactQueryContext,
-            ...ssrOpts
+        const hook = reactQuery.useInfiniteQuery({
+            ...ssrOpts,
+            queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'),
+            queryFn: (queryFunctionContext)=>{
+                const actualOpts = {
+                    ...ssrOpts,
+                    trpc: {
+                        ...ssrOpts?.trpc,
+                        ...shouldAbortOnUnmount ? {
+                            signal: queryFunctionContext.signal
+                        } : {}
+                    }
+                };
+                const actualInput = {
+                    ...input ?? {},
+                    cursor: queryFunctionContext.pageParam
+                };
+                // FIXME as any shouldn't be needed as client should be untyped too
+                return client.query(...getClientArgs([
+                    path,
+                    actualInput
+                ], actualOpts));
+            },
+            context: ReactQueryContext
         });
         hook.trpc = useHookResult({
             path

package/dist/{createHooksInternal-9c1f8ad9.mjs → createHooksInternal-b83f2ee6.mjs}

@@ -137,7 +137,7 @@ const TRPCContext = /*#__PURE__*/ createContext(null);
             queryFn: ()=>{
                 return client.query(path, input);
             },
-            ...rest[1]
+            ...rest[0]
         };
         return options;
     });
@@ -193,69 +193,95 @@ function getClientArgs(pathAndInput, opts) {
                 ssrContext: ssrContext || null,
                 ssrState,
                 fetchQuery: useCallback((pathAndInput, opts)=>{
-                    return queryClient.fetchQuery(getArrayQueryKey(pathAndInput, 'query'), ()=>client.query(...getClientArgs(pathAndInput, opts)), opts);
+                    return queryClient.fetchQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey(pathAndInput, 'query'),
+                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
                 fetchInfiniteQuery: useCallback((pathAndInput, opts)=>{
-                    return queryClient.fetchInfiniteQuery(getArrayQueryKey(pathAndInput, 'infinite'), ({ pageParam  })=>{
-                        const [path, input] = pathAndInput;
-                        const actualInput = {
-                            ...input,
-                            cursor: pageParam
-                        };
-                        return client.query(...getClientArgs([
-                            path,
-                            actualInput
-                        ], opts));
-                    }, opts);
+                    return queryClient.fetchInfiniteQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+                        queryFn: ({ pageParam  })=>{
+                            const [path, input] = pathAndInput;
+                            const actualInput = {
+                                ...input,
+                                cursor: pageParam
+                            };
+                            return client.query(...getClientArgs([
+                                path,
+                                actualInput
+                            ], opts));
+                        }
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
                 prefetchQuery: useCallback((pathAndInput, opts)=>{
-                    return queryClient.prefetchQuery(getArrayQueryKey(pathAndInput, 'query'), ()=>client.query(...getClientArgs(pathAndInput, opts)), opts);
+                    return queryClient.prefetchQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey(pathAndInput, 'query'),
+                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
                 prefetchInfiniteQuery: useCallback((pathAndInput, opts)=>{
-                    return queryClient.prefetchInfiniteQuery(getArrayQueryKey(pathAndInput, 'infinite'), ({ pageParam  })=>{
-                        const [path, input] = pathAndInput;
-                        const actualInput = {
-                            ...input,
-                            cursor: pageParam
-                        };
-                        return client.query(...getClientArgs([
-                            path,
-                            actualInput
-                        ], opts));
-                    }, opts);
+                    return queryClient.prefetchInfiniteQuery({
+                        ...opts,
+                        queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+                        queryFn: ({ pageParam  })=>{
+                            const [path, input] = pathAndInput;
+                            const actualInput = {
+                                ...input,
+                                cursor: pageParam
+                            };
+                            return client.query(...getClientArgs([
+                                path,
+                                actualInput
+                            ], opts));
+                        }
+                    });
                 }, [
                     client,
                     queryClient
                 ]),
-                invalidateQueries: useCallback((...args)=>{
-                    const [queryKey, ...rest] = args;
-                    return queryClient.invalidateQueries(getArrayQueryKey(queryKey, 'any'), ...rest);
+                invalidateQueries: useCallback((queryKey, filters, options)=>{
+                    return queryClient.invalidateQueries({
+                        ...filters,
+                        queryKey: getArrayQueryKey(queryKey, 'any')
+                    }, options);
                 }, [
                     queryClient
                 ]),
                 resetQueries: useCallback((...args)=>{
-                    const [queryKey, ...rest] = args;
-                    return queryClient.resetQueries(getArrayQueryKey(queryKey, 'any'), ...rest);
+                    const [queryKey, filters, options] = args;
+                    return queryClient.resetQueries({
+                        ...filters,
+                        queryKey: getArrayQueryKey(queryKey, 'any')
+                    }, options);
                 }, [
                     queryClient
                 ]),
                 refetchQueries: useCallback((...args)=>{
-                    const [queryKey, ...rest] = args;
-                    return queryClient.refetchQueries(getArrayQueryKey(queryKey, 'any'), ...rest);
+                    const [queryKey, filters, options] = args;
+                    return queryClient.refetchQueries({
+                        ...filters,
+                        queryKey: getArrayQueryKey(queryKey, 'any')
+                    }, options);
                 }, [
                     queryClient
                 ]),
                 cancelQuery: useCallback((pathAndInput)=>{
-                    return queryClient.cancelQueries(getArrayQueryKey(pathAndInput, 'any'));
+                    return queryClient.cancelQueries({
+                        queryKey: getArrayQueryKey(pathAndInput, 'any')
+                    });
                 }, [
                     queryClient
                 ]),
@@ -308,20 +334,22 @@ function getClientArgs(pathAndInput, opts) {
         const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, 'query', opts);
         // request option should take priority over global
         const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
-        const hook = useQuery(getArrayQueryKey(pathAndInput, 'query'), (queryFunctionContext)=>{
-            const actualOpts = {
-                ...ssrOpts,
-                trpc: {
-                    ...ssrOpts?.trpc,
-                    ...shouldAbortOnUnmount ? {
-                        signal: queryFunctionContext.signal
-                    } : {}
-                }
-            };
-            return client.query(...getClientArgs(pathAndInput, actualOpts));
-        }, {
-            context: ReactQueryContext,
-            ...ssrOpts
+        const hook = useQuery({
+            ...ssrOpts,
+            queryKey: getArrayQueryKey(pathAndInput, 'query'),
+            queryFn: (queryFunctionContext)=>{
+                const actualOpts = {
+                    ...ssrOpts,
+                    trpc: {
+                        ...ssrOpts?.trpc,
+                        ...shouldAbortOnUnmount ? {
+                            signal: queryFunctionContext.signal
+                        } : {}
+                    }
+                };
+                return client.query(...getClientArgs(pathAndInput, actualOpts));
+            },
+            context: ReactQueryContext
         });
         hook.trpc = useHookResult({
             path: pathAndInput[0]
@@ -334,15 +362,16 @@ function getClientArgs(pathAndInput, opts) {
         const queryClient = useQueryClient({
             context: ReactQueryContext
         });
-        const hook = useMutation((input)=>{
-            const actualPath = Array.isArray(path) ? path[0] : path;
-            return client.mutation(...getClientArgs([
-                actualPath,
-                input
-            ], opts));
-        }, {
-            context: ReactQueryContext,
+        const hook = useMutation({
             ...opts,
+            mutationFn: (input)=>{
+                const actualPath = Array.isArray(path) ? path[0] : path;
+                return client.mutation(...getClientArgs([
+                    actualPath,
+                    input
+                ], opts));
+            },
+            context: ReactQueryContext,
             onSuccess (...args) {
                 const originalFn = ()=>opts?.onSuccess?.(...args);
                 return mutationSuccessOverride({
@@ -404,28 +433,30 @@ function getClientArgs(pathAndInput, opts) {
         const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, 'infinite', opts);
         // request option should take priority over global
         const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
-        const hook = useInfiniteQuery(getArrayQueryKey(pathAndInput, 'infinite'), (queryFunctionContext)=>{
-            const actualOpts = {
-                ...ssrOpts,
-                trpc: {
-                    ...ssrOpts?.trpc,
-                    ...shouldAbortOnUnmount ? {
-                        signal: queryFunctionContext.signal
-                    } : {}
-                }
-            };
-            const actualInput = {
-                ...input ?? {},
-                cursor: queryFunctionContext.pageParam
-            };
-            // FIXME as any shouldn't be needed as client should be untyped too
-            return client.query(...getClientArgs([
-                path,
-                actualInput
-            ], actualOpts));
-        }, {
-            context: ReactQueryContext,
-            ...ssrOpts
+        const hook = useInfiniteQuery({
+            ...ssrOpts,
+            queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+            queryFn: (queryFunctionContext)=>{
+                const actualOpts = {
+                    ...ssrOpts,
+                    trpc: {
+                        ...ssrOpts?.trpc,
+                        ...shouldAbortOnUnmount ? {
+                            signal: queryFunctionContext.signal
+                        } : {}
+                    }
+                };
+                const actualInput = {
+                    ...input ?? {},
+                    cursor: queryFunctionContext.pageParam
+                };
+                // FIXME as any shouldn't be needed as client should be untyped too
+                return client.query(...getClientArgs([
+                    path,
+                    actualInput
+                ], actualOpts));
+            },
+            context: ReactQueryContext
         });
         hook.trpc = useHookResult({
             path

package/dist/index.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var client = require('@trpc/client');
 var shared = require('@trpc/server/shared');
 var React = require('react');
-var createHooksInternal = require('./createHooksInternal-d8e5577b.js');
+var createHooksInternal = require('./createHooksInternal-57a3cf21.js');
 require('@tanstack/react-query');
 require('./getArrayQueryKey-4bdb5cc2.js');
 

package/dist/index.mjs

@@ -1,7 +1,7 @@
 export * from '@trpc/client';
 import { createFlatProxy } from '@trpc/server/shared';
 import { useMemo } from 'react';
-import { c as createHooksInternal, a as createReactQueryUtilsProxy, b as createReactProxyDecoration } from './createHooksInternal-9c1f8ad9.mjs';
+import { c as createHooksInternal, a as createReactQueryUtilsProxy, b as createReactProxyDecoration } from './createHooksInternal-b83f2ee6.mjs';
 import '@tanstack/react-query';
 import './getArrayQueryKey-86134f8b.mjs';
 

package/dist/shared/hooks/createHooksInternal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createHooksInternal.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/createHooksInternal.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,mBAAmB,EAAoB,MAAM,cAAc,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAI3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,sBAAsB,EAAuB,MAAM,UAAU,CAAC;AACvE,OAAO,EACL,YAAY,EACZ,YAAY,EAEZ,kBAAkB,EAClB,2BAA2B,EAC3B,0BAA0B,EAC1B,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,SAAS,SAAS,EACzB,WAAW,GAAG,OAAO,EACrB,MAAM,CAAC,EAAE,sBAAsB,CAAC,OAAO,CAAC;;;;6BAiNxB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,CAAC;;wBA+C1C,MAAM,GAAG,CAAC,MAAM,CAAC;oCAsCT;QAEZ,IAAI,EAAE,MAAM;QACZ,GAAG,IAAI,EAAE,OAAO,EAAE;KACnB;;qCA4Ca;QAEZ,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC;KAC5B;EAoHJ;AAED;;;GAGG;AACH,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"createHooksInternal.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/createHooksInternal.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,mBAAmB,EAAoB,MAAM,cAAc,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAI3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,sBAAsB,EAAuB,MAAM,UAAU,CAAC;AACvE,OAAO,EACL,YAAY,EACZ,YAAY,EAEZ,kBAAkB,EAClB,2BAA2B,EAC3B,0BAA0B,EAC1B,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,SAAS,SAAS,EACzB,WAAW,GAAG,OAAO,EACrB,MAAM,CAAC,EAAE,sBAAsB,CAAC,OAAO,CAAC;;;;6BAwNxB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,CAAC;;wBAiD1C,MAAM,GAAG,CAAC,MAAM,CAAC;oCAoCT;QAEZ,IAAI,EAAE,MAAM;QACZ,GAAG,IAAI,EAAE,OAAO,EAAE;KACnB;;qCA4Ca;QAEZ,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC;KAC5B;EAqHJ;AAED;;;GAGG;AACH,cAAc,kCAAkC,CAAC"}

package/dist/shared/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var createHooksInternal = require('../createHooksInternal-d8e5577b.js');
+var createHooksInternal = require('../createHooksInternal-57a3cf21.js');
 var queryClient = require('../queryClient-358a9a75.js');
 require('@trpc/server/shared');
 require('../getArrayQueryKey-4bdb5cc2.js');

package/dist/shared/index.mjs

@@ -1,4 +1,4 @@
-export { T as TRPCContext, f as contextProps, c as createHooksInternal, b as createReactProxyDecoration, a as createReactQueryUtilsProxy, e as createRootHooks, d as createUseQueriesProxy, g as getClientArgs } from '../createHooksInternal-9c1f8ad9.mjs';
+export { T as TRPCContext, f as contextProps, c as createHooksInternal, b as createReactProxyDecoration, a as createReactQueryUtilsProxy, e as createRootHooks, d as createUseQueriesProxy, g as getClientArgs } from '../createHooksInternal-b83f2ee6.mjs';
 export { g as getQueryClient } from '../queryClient-4d766c0c.mjs';
 import '@trpc/server/shared';
 import '../getArrayQueryKey-86134f8b.mjs';

package/dist/ssg/index.js

@@ -18,47 +18,59 @@ var queryClient = require('../queryClient-358a9a75.js');
     const queryClient$1 = queryClient.getQueryClient(opts);
     const serialize = transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj;
     const prefetchQuery = async (...pathAndInput)=>{
-        return queryClient$1.prefetchQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'), ()=>{
-            return server.callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient$1.prefetchQuery({
+            queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'),
+            queryFn: ()=>{
+                return server.callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     const prefetchInfiniteQuery = async (...pathAndInput)=>{
-        return queryClient$1.prefetchInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'), ()=>{
-            return server.callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient$1.prefetchInfiniteQuery({
+            queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'),
+            queryFn: ()=>{
+                return server.callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     const fetchQuery = async (...pathAndInput)=>{
-        return queryClient$1.fetchQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'), ()=>{
-            return server.callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient$1.fetchQuery({
+            queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'query'),
+            queryFn: ()=>{
+                return server.callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     const fetchInfiniteQuery = async (...pathAndInput)=>{
-        return queryClient$1.fetchInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'), ()=>{
-            return server.callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient$1.fetchInfiniteQuery({
+            queryKey: getArrayQueryKey.getArrayQueryKey(pathAndInput, 'infinite'),
+            queryFn: ()=>{
+                return server.callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     function _dehydrate(opts = {

package/dist/ssg/index.mjs

@@ -14,47 +14,59 @@ import { g as getQueryClient } from '../queryClient-4d766c0c.mjs';
     const queryClient = getQueryClient(opts);
     const serialize = transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj;
     const prefetchQuery = async (...pathAndInput)=>{
-        return queryClient.prefetchQuery(getArrayQueryKey(pathAndInput, 'query'), ()=>{
-            return callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient.prefetchQuery({
+            queryKey: getArrayQueryKey(pathAndInput, 'query'),
+            queryFn: ()=>{
+                return callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     const prefetchInfiniteQuery = async (...pathAndInput)=>{
-        return queryClient.prefetchInfiniteQuery(getArrayQueryKey(pathAndInput, 'infinite'), ()=>{
-            return callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient.prefetchInfiniteQuery({
+            queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+            queryFn: ()=>{
+                return callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     const fetchQuery = async (...pathAndInput)=>{
-        return queryClient.fetchQuery(getArrayQueryKey(pathAndInput, 'query'), ()=>{
-            return callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient.fetchQuery({
+            queryKey: getArrayQueryKey(pathAndInput, 'query'),
+            queryFn: ()=>{
+                return callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     const fetchInfiniteQuery = async (...pathAndInput)=>{
-        return queryClient.fetchInfiniteQuery(getArrayQueryKey(pathAndInput, 'infinite'), ()=>{
-            return callProcedure({
-                procedures: router._def.procedures,
-                path: pathAndInput[0],
-                rawInput: pathAndInput[1],
-                ctx,
-                type: 'query'
-            });
+        return queryClient.fetchInfiniteQuery({
+            queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+            queryFn: ()=>{
+                return callProcedure({
+                    procedures: router._def.procedures,
+                    path: pathAndInput[0],
+                    rawInput: pathAndInput[1],
+                    ctx,
+                    type: 'query'
+                });
+            }
         });
     };
     function _dehydrate(opts = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/react-query",
-  "version": "10.8.1",
+  "version": "10.8.2",
   "description": "tRPC React lib",
   "author": "KATT",
   "license": "MIT",
@@ -55,15 +55,15 @@
   },
   "peerDependencies": {
     "@tanstack/react-query": "^4.3.8",
-    "@trpc/client": "10.8.1",
-    "@trpc/server": "10.8.1",
+    "@trpc/client": "10.8.2",
+    "@trpc/server": "10.8.2",
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0"
   },
   "devDependencies": {
     "@tanstack/react-query": "^4.3.8",
-    "@trpc/client": "10.8.1",
-    "@trpc/server": "10.8.1",
+    "@trpc/client": "10.8.2",
+    "@trpc/server": "10.8.2",
     "@types/express": "^4.17.12",
     "@types/node": "^18.7.20",
     "eslint": "^8.30.0",
@@ -78,5 +78,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2a130c7cac7557ee740a687bade81a3f5747cf56"
+  "gitHead": "2be6d09a08fc3a32b86286271ab8b4881b6bc98b"
 }

package/src/shared/hooks/createHooksInternal.tsx

@@ -78,96 +78,103 @@ export function createRootHooks<
           ssrState,
           fetchQuery: useCallback(
             (pathAndInput, opts) => {
-              return queryClient.fetchQuery(
-                getArrayQueryKey(pathAndInput, 'query'),
-                () =>
+              return queryClient.fetchQuery({
+                ...opts,
+                queryKey: getArrayQueryKey(pathAndInput, 'query'),
+                queryFn: () =>
                   (client as any).query(...getClientArgs(pathAndInput, opts)),
-                opts,
-              );
+              });
             },
             [client, queryClient],
           ),
           fetchInfiniteQuery: useCallback(
             (pathAndInput, opts) => {
-              return queryClient.fetchInfiniteQuery(
-                getArrayQueryKey(pathAndInput, 'infinite'),
-                ({ pageParam }) => {
+              return queryClient.fetchInfiniteQuery({
+                ...opts,
+                queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+                queryFn: ({ pageParam }) => {
                   const [path, input] = pathAndInput;
-                  const actualInput = { ...(input as any), cursor: pageParam };
+                  const actualInput = { ...input, cursor: pageParam };
                   return (client as any).query(
                     ...getClientArgs([path, actualInput], opts),
                   );
                 },
-                opts,
-              );
+              });
             },
             [client, queryClient],
           ),
           prefetchQuery: useCallback(
             (pathAndInput, opts) => {
-              return queryClient.prefetchQuery(
-                getArrayQueryKey(pathAndInput, 'query'),
-                () =>
+              return queryClient.prefetchQuery({
+                ...opts,
+                queryKey: getArrayQueryKey(pathAndInput, 'query'),
+                queryFn: () =>
                   (client as any).query(...getClientArgs(pathAndInput, opts)),
-                opts,
-              );
+              });
             },
             [client, queryClient],
           ),
           prefetchInfiniteQuery: useCallback(
             (pathAndInput, opts) => {
-              return queryClient.prefetchInfiniteQuery(
-                getArrayQueryKey(pathAndInput, 'infinite'),
-                ({ pageParam }) => {
+              return queryClient.prefetchInfiniteQuery({
+                ...opts,
+                queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+                queryFn: ({ pageParam }) => {
                   const [path, input] = pathAndInput;
-                  const actualInput = { ...(input as any), cursor: pageParam };
+                  const actualInput = { ...input, cursor: pageParam };
                   return (client as any).query(
                     ...getClientArgs([path, actualInput], opts),
                   );
                 },
-                opts,
-              );
+              });
             },
             [client, queryClient],
           ),
           invalidateQueries: useCallback(
-            (...args: any[]) => {
-              const [queryKey, ...rest] = args;
-
+            (queryKey, filters, options) => {
               return queryClient.invalidateQueries(
-                getArrayQueryKey(queryKey, 'any'),
-                ...rest,
+                {
+                  ...filters,
+                  queryKey: getArrayQueryKey(queryKey as any, 'any'),
+                },
+                options,
               );
             },
             [queryClient],
           ),
           resetQueries: useCallback(
             (...args: any[]) => {
-              const [queryKey, ...rest] = args;
+              const [queryKey, filters, options] = args;
 
               return queryClient.resetQueries(
-                getArrayQueryKey(queryKey, 'any'),
-                ...rest,
+                {
+                  ...filters,
+                  queryKey: getArrayQueryKey(queryKey, 'any'),
+                },
+                options,
               );
             },
             [queryClient],
           ),
           refetchQueries: useCallback(
             (...args: any[]) => {
-              const [queryKey, ...rest] = args;
+              const [queryKey, filters, options] = args;
 
               return queryClient.refetchQueries(
-                getArrayQueryKey(queryKey, 'any'),
-                ...rest,
+                {
+                  ...filters,
+                  queryKey: getArrayQueryKey(queryKey, 'any'),
+                },
+                options,
               );
             },
             [queryClient],
           ),
           cancelQuery: useCallback(
             (pathAndInput) => {
-              return queryClient.cancelQueries(
-                getArrayQueryKey(pathAndInput, 'any'),
-              );
+              return queryClient.cancelQueries({
+                queryKey: getArrayQueryKey(pathAndInput, 'any'),
+              });
             },
             [queryClient],
           ),
@@ -269,9 +276,10 @@ export function createRootHooks<
     // request option should take priority over global
     const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
 
-    const hook = __useQuery(
-      getArrayQueryKey(pathAndInput, 'query') as any,
-      (queryFunctionContext) => {
+    const hook = __useQuery({
+      ...ssrOpts,
+      queryKey: getArrayQueryKey(pathAndInput, 'query') as any,
+      queryFn: (queryFunctionContext) => {
         const actualOpts = {
           ...ssrOpts,
           trpc: {
@@ -286,8 +294,9 @@ export function createRootHooks<
           ...getClientArgs(pathAndInput, actualOpts),
         );
       },
-      { context: ReactQueryContext, ...ssrOpts },
-    ) as UseTRPCQueryResult<unknown, TError>;
+      context: ReactQueryContext,
+    }) as UseTRPCQueryResult<unknown, TError>;
+
     hook.trpc = useHookResult({
       path: pathAndInput[0],
     });
@@ -303,28 +312,26 @@ export function createRootHooks<
     const { client } = useContext();
     const queryClient = useQueryClient({ context: ReactQueryContext });
 
-    const hook = __useMutation(
-      (input) => {
+    const hook = __useMutation({
+      ...opts,
+      mutationFn: (input) => {
         const actualPath = Array.isArray(path) ? path[0] : path;
 
         return (client.mutation as any)(
           ...getClientArgs([actualPath, input], opts),
         );
       },
-      {
-        context: ReactQueryContext,
-        ...opts,
-        onSuccess(...args) {
-          const originalFn = () => opts?.onSuccess?.(...args);
-
-          return mutationSuccessOverride({
-            originalFn,
-            queryClient,
-            meta: opts?.meta ?? {},
-          });
-        },
+      context: ReactQueryContext,
+      onSuccess(...args) {
+        const originalFn = () => opts?.onSuccess?.(...args);
+
+        return mutationSuccessOverride({
+          originalFn,
+          queryClient,
+          meta: opts?.meta ?? {},
+        });
       },
-    ) as UseTRPCMutationResult<unknown, TError, unknown, unknown>;
+    }) as UseTRPCMutationResult<unknown, TError, unknown, unknown>;
 
     hook.trpc = useHookResult({
       path: Array.isArray(path) ? path[0] : path,
@@ -416,9 +423,10 @@ export function createRootHooks<
     // request option should take priority over global
     const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
 
-    const hook = __useInfiniteQuery(
-      getArrayQueryKey(pathAndInput, 'infinite') as any,
-      (queryFunctionContext) => {
+    const hook = __useInfiniteQuery({
+      ...ssrOpts,
+      queryKey: getArrayQueryKey(pathAndInput, 'infinite') as any,
+      queryFn: (queryFunctionContext) => {
         const actualOpts = {
           ...ssrOpts,
           trpc: {
@@ -439,8 +447,8 @@ export function createRootHooks<
           ...getClientArgs([path, actualInput], actualOpts),
         );
       },
-      { context: ReactQueryContext, ...ssrOpts },
-    ) as UseTRPCInfiniteQueryResult<unknown, TError>;
+      context: ReactQueryContext,
+    }) as UseTRPCInfiniteQueryResult<unknown, TError>;
 
     hook.trpc = useHookResult({
       path,

package/src/shared/proxy/useQueriesProxy.ts

@@ -75,7 +75,7 @@ export function createUseQueriesProxy<TRouter extends AnyRouter>(
       queryFn: () => {
         return client.query(path, input);
       },
-      ...(rest[1] as any),
+      ...(rest[0] as any),
     };
 
     return options;

package/src/ssg/ssg.ts

@@ -44,9 +44,9 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
   >(
     ...pathAndInput: [path: TPath, ...args: inferHandlerInput<TProcedure>]
   ) => {
-    return queryClient.prefetchQuery(
-      getArrayQueryKey(pathAndInput, 'query'),
-      () => {
+    return queryClient.prefetchQuery({
+      queryKey: getArrayQueryKey(pathAndInput, 'query'),
+      queryFn: () => {
         return callProcedure({
           procedures: router._def.procedures,
           path: pathAndInput[0],
@@ -55,7 +55,7 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
           type: 'query',
         });
       },
-    );
+    });
   };
 
   const prefetchInfiniteQuery = async <
@@ -64,9 +64,9 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
   >(
     ...pathAndInput: [path: TPath, ...args: inferHandlerInput<TProcedure>]
   ) => {
-    return queryClient.prefetchInfiniteQuery(
-      getArrayQueryKey(pathAndInput, 'infinite'),
-      () => {
+    return queryClient.prefetchInfiniteQuery({
+      queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+      queryFn: () => {
         return callProcedure({
           procedures: router._def.procedures,
           path: pathAndInput[0],
@@ -75,7 +75,7 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
           type: 'query',
         });
       },
-    );
+    });
   };
 
   const fetchQuery = async <
@@ -85,9 +85,9 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
   >(
     ...pathAndInput: [path: TPath, ...args: inferHandlerInput<TProcedure>]
   ): Promise<TOutput> => {
-    return queryClient.fetchQuery(
-      getArrayQueryKey(pathAndInput, 'query'),
-      () => {
+    return queryClient.fetchQuery({
+      queryKey: getArrayQueryKey(pathAndInput, 'query'),
+      queryFn: () => {
         return callProcedure({
           procedures: router._def.procedures,
           path: pathAndInput[0],
@@ -96,7 +96,7 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
           type: 'query',
         });
       },
-    );
+    });
   };
 
   const fetchInfiniteQuery = async <
@@ -106,9 +106,9 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
   >(
     ...pathAndInput: [path: TPath, ...args: inferHandlerInput<TProcedure>]
   ): Promise<InfiniteData<TOutput>> => {
-    return queryClient.fetchInfiniteQuery(
-      getArrayQueryKey(pathAndInput, 'infinite'),
-      () => {
+    return queryClient.fetchInfiniteQuery({
+      queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
+      queryFn: () => {
         return callProcedure({
           procedures: router._def.procedures,
           path: pathAndInput[0],
@@ -117,7 +117,7 @@ export function createSSGHelpers<TRouter extends AnyRouter>(
           type: 'query',
         });
       },
-    );
+    });
   };
 
   function _dehydrate(