@trpc/react-query 11.0.0-alpha-tmp-export-from-main.213 → 11.0.0-alpha-tmp-export-from-main.217

package/dist/utils/createUtilityFunctions.mjs

@@ -0,0 +1,92 @@
+import { TRPCUntypedClient, getUntypedClient } from '@trpc/client';
+import { getClientArgs } from '../internals/getClientArgs.mjs';
+
+/**
+ * Creates a set of utility functions that can be used to interact with `react-query`
+ * @param opts the `TRPCClient` and `QueryClient` to use
+ * @returns a set of utility functions that can be used to interact with `react-query`
+ * @internal
+ */ function createUtilityFunctions(opts) {
+    const { client , queryClient  } = opts;
+    const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
+    return {
+        fetchQuery: (queryKey, opts)=>{
+            return queryClient.fetchQuery({
+                ...opts,
+                queryKey,
+                queryFn: ()=>untypedClient.query(...getClientArgs(queryKey, opts))
+            });
+        },
+        fetchInfiniteQuery: (queryKey, opts)=>{
+            return queryClient.fetchInfiniteQuery({
+                ...opts,
+                queryKey,
+                queryFn: ({ pageParam  })=>{
+                    return untypedClient.query(...getClientArgs(queryKey, opts, pageParam));
+                },
+                initialPageParam: opts?.initialCursor ?? null
+            });
+        },
+        prefetchQuery: (queryKey, opts)=>{
+            return queryClient.prefetchQuery({
+                ...opts,
+                queryKey,
+                queryFn: ()=>untypedClient.query(...getClientArgs(queryKey, opts))
+            });
+        },
+        prefetchInfiniteQuery: (queryKey, opts)=>{
+            return queryClient.prefetchInfiniteQuery({
+                ...opts,
+                queryKey,
+                queryFn: ({ pageParam  })=>{
+                    return untypedClient.query(...getClientArgs(queryKey, opts, pageParam));
+                },
+                initialPageParam: opts?.initialCursor ?? null
+            });
+        },
+        ensureQueryData: (queryKey, opts)=>{
+            return queryClient.ensureQueryData({
+                ...opts,
+                queryKey,
+                queryFn: ()=>untypedClient.query(...getClientArgs(queryKey, opts))
+            });
+        },
+        invalidateQueries: (queryKey, filters, options)=>{
+            return queryClient.invalidateQueries({
+                ...filters,
+                queryKey
+            }, options);
+        },
+        resetQueries: (queryKey, filters, options)=>{
+            return queryClient.resetQueries({
+                ...filters,
+                queryKey
+            }, options);
+        },
+        refetchQueries: (queryKey, filters, options)=>{
+            return queryClient.refetchQueries({
+                ...filters,
+                queryKey
+            }, options);
+        },
+        cancelQuery: (queryKey, options)=>{
+            return queryClient.cancelQueries({
+                queryKey
+            }, options);
+        },
+        setQueryData: (queryKey, updater, options)=>{
+            return queryClient.setQueryData(queryKey, updater, options);
+        },
+        getQueryData: (queryKey)=>{
+            return queryClient.getQueryData(queryKey);
+        },
+        setInfiniteQueryData: (queryKey, updater, options)=>{
+            return queryClient.setQueryData(queryKey, updater, options);
+        },
+        getInfiniteQueryData: (queryKey)=>{
+            return queryClient.getQueryData(queryKey);
+        }
+    };
+}
+
+export { createUtilityFunctions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/react-query",
-  "version": "11.0.0-alpha-tmp-export-from-main.213+855f8bc75",
+  "version": "11.0.0-alpha-tmp-export-from-main.217+ef6ef3e1c",
   "description": "The tRPC React library",
   "author": "KATT",
   "license": "MIT",
@@ -72,17 +72,17 @@
     }
   },
   "dependencies": {
-    "@trpc/core": "11.0.0-alpha-tmp-export-from-main.213+855f8bc75"
+    "@trpc/core": "11.0.0-alpha-tmp-export-from-main.217+ef6ef3e1c"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.0.0",
-    "@trpc/client": "11.0.0-alpha-tmp-export-from-main.213+855f8bc75",
+    "@trpc/client": "11.0.0-alpha-tmp-export-from-main.217+ef6ef3e1c",
     "react": ">=18.2.0",
     "react-dom": ">=18.2.0"
   },
   "devDependencies": {
     "@tanstack/react-query": "^5.0.0",
-    "@trpc/client": "11.0.0-alpha-tmp-export-from-main.213+855f8bc75",
+    "@trpc/client": "11.0.0-alpha-tmp-export-from-main.217+ef6ef3e1c",
     "@types/express": "^4.17.17",
     "@types/node": "^20.10.0",
     "@types/react": "^18.2.33",
@@ -91,7 +91,7 @@
     "next": "^14.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "rollup": "^2.79.1",
+    "rollup": "^4.9.5",
     "tsx": "^4.0.0",
     "zod": "^3.0.0"
   },
@@ -101,5 +101,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "855f8bc75d6f11780eabf92376c6297f9edf6107"
+  "gitHead": "ef6ef3e1c3a4966d30335864d6edf9c94f096717"
 }

package/src/internals/getQueryKey.ts

@@ -32,10 +32,28 @@ export function getQueryKeyInternal(
   // some parts of the path may be dot-separated, split them up
   const splitPath = path.flatMap((part) => part.split('.'));
 
-  if (!input && (!type || type === 'any'))
+  if (!input && (!type || type === 'any')) {
     // for `utils.invalidate()` to match all queries (including vanilla react-query)
     // we don't want nested array if path is empty, i.e. `[]` instead of `[[]]`
     return splitPath.length ? [splitPath] : ([] as unknown as TRPCQueryKey);
+  }
+
+  if (
+    type === 'infinite' &&
+    input &&
+    typeof input === 'object' &&
+    'cursor' in input
+  ) {
+    const { cursor: _, ...inputWithoutCursor } = input;
+
+    return [
+      splitPath,
+      {
+        input: inputWithoutCursor,
+        type: 'infinite',
+      },
+    ];
+  }
   return [
     splitPath,
     {

package/dist/createHooksInternal-4285c71a.js

@@ -1,470 +0,0 @@
-import { createRecursiveProxy } from '@trpc/core';
-import { useQuery, useSuspenseQuery, useQueryClient, useMutation, hashKey, useInfiniteQuery, useSuspenseInfiniteQuery, useQueries, useSuspenseQueries } from '@tanstack/react-query';
-import { TRPCUntypedClient, getUntypedClient, createTRPCUntypedClient } from '@trpc/client';
-import * as React from 'react';
-import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-ff357a62.js';
-
-/**
- * Create proxy for decorating procedures
- * @internal
- */
-function createReactDecoration(name, hooks) {
-    return createRecursiveProxy(({ path, args }) => {
-        const pathCopy = [name, ...path];
-        // The last arg is for instance `.useMutation` or `.useQuery()`
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const lastArg = pathCopy.pop();
-        if (lastArg === 'useMutation') {
-            return hooks[lastArg](pathCopy, ...args);
-        }
-        if (lastArg === '_def') {
-            return {
-                path: pathCopy,
-            };
-        }
-        const [input, ...rest] = args;
-        const opts = rest[0] || {};
-        return hooks[lastArg](pathCopy, input, opts);
-    });
-}
-
-/**
- * Create proxy for `useQueries` options
- * @internal
- */
-function createUseQueries(client) {
-    return createRecursiveProxy((opts) => {
-        const arrayPath = opts.path;
-        const dotPath = arrayPath.join('.');
-        const [input, _opts] = opts.args;
-        const options = {
-            queryKey: getQueryKeyInternal(arrayPath, input, 'query'),
-            queryFn: () => {
-                return client.query(dotPath, input, _opts?.trpc);
-            },
-            ..._opts,
-        };
-        return options;
-    });
-}
-
-/**
- * @internal
- */
-function getClientArgs(queryKey, opts, pageParam) {
-    const path = queryKey[0];
-    const input = queryKey[1]?.input;
-    if (pageParam)
-        input.cursor = pageParam;
-    return [path.join('.'), input, opts?.trpc];
-}
-
-/**
- * Makes a stable reference of the `trpc` prop
- */
-function useHookResult(value) {
-    const ref = React.useRef(value);
-    ref.current.path = value.path;
-    return ref.current;
-}
-
-/**
- * Creates a set of utility functions that can be used to interact with `react-query`
- * @param opts the `TRPCClient` and `QueryClient` to use
- * @returns a set of utility functions that can be used to interact with `react-query`
- * @internal
- */
-function createUtilityFunctions(opts) {
-    const { client, queryClient } = opts;
-    const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
-    return {
-        fetchQuery: (queryKey, opts) => {
-            return queryClient.fetchQuery({
-                ...opts,
-                queryKey,
-                queryFn: () => untypedClient.query(...getClientArgs(queryKey, opts)),
-            });
-        },
-        fetchInfiniteQuery: (queryKey, opts) => {
-            return queryClient.fetchInfiniteQuery({
-                ...opts,
-                queryKey,
-                queryFn: ({ pageParam }) => {
-                    return untypedClient.query(...getClientArgs(queryKey, opts, pageParam));
-                },
-                initialPageParam: opts?.initialCursor ?? null,
-            });
-        },
-        prefetchQuery: (queryKey, opts) => {
-            return queryClient.prefetchQuery({
-                ...opts,
-                queryKey,
-                queryFn: () => untypedClient.query(...getClientArgs(queryKey, opts)),
-            });
-        },
-        prefetchInfiniteQuery: (queryKey, opts) => {
-            return queryClient.prefetchInfiniteQuery({
-                ...opts,
-                queryKey,
-                queryFn: ({ pageParam }) => {
-                    return untypedClient.query(...getClientArgs(queryKey, opts, pageParam));
-                },
-                initialPageParam: opts?.initialCursor ?? null,
-            });
-        },
-        ensureQueryData: (queryKey, opts) => {
-            return queryClient.ensureQueryData({
-                ...opts,
-                queryKey,
-                queryFn: () => untypedClient.query(...getClientArgs(queryKey, opts)),
-            });
-        },
-        invalidateQueries: (queryKey, filters, options) => {
-            return queryClient.invalidateQueries({
-                ...filters,
-                queryKey,
-            }, options);
-        },
-        resetQueries: (queryKey, filters, options) => {
-            return queryClient.resetQueries({
-                ...filters,
-                queryKey,
-            }, options);
-        },
-        refetchQueries: (queryKey, filters, options) => {
-            return queryClient.refetchQueries({
-                ...filters,
-                queryKey,
-            }, options);
-        },
-        cancelQuery: (queryKey, options) => {
-            return queryClient.cancelQueries({
-                queryKey,
-            }, options);
-        },
-        setQueryData: (queryKey, updater, options) => {
-            return queryClient.setQueryData(queryKey, updater, options);
-        },
-        getQueryData: (queryKey) => {
-            return queryClient.getQueryData(queryKey);
-        },
-        setInfiniteQueryData: (queryKey, updater, options) => {
-            return queryClient.setQueryData(queryKey, updater, options);
-        },
-        getInfiniteQueryData: (queryKey) => {
-            return queryClient.getQueryData(queryKey);
-        },
-    };
-}
-
-/**
- * @internal
- */
-function createRootHooks(config) {
-    const mutationSuccessOverride = config?.overrides?.useMutation?.onSuccess ??
-        ((options) => options.originalFn());
-    const Context = (config?.context ??
-        TRPCContext);
-    const createClient = (opts) => {
-        return createTRPCUntypedClient(opts);
-    };
-    const TRPCProvider = (props) => {
-        const { abortOnUnmount = false, client, queryClient, ssrContext } = props;
-        const [ssrState, setSSRState] = React.useState(props.ssrState ?? false);
-        const fns = React.useMemo(() => createUtilityFunctions({
-            client,
-            queryClient,
-        }), [client, queryClient]);
-        const contextValue = React.useMemo(() => ({
-            abortOnUnmount,
-            queryClient,
-            client,
-            ssrContext: ssrContext ?? null,
-            ssrState,
-            ...fns,
-        }), [abortOnUnmount, client, fns, queryClient, ssrContext, ssrState]);
-        React.useEffect(() => {
-            // Only updating state to `mounted` if we are using SSR.
-            // This makes it so we don't have an unnecessary re-render when opting out of SSR.
-            setSSRState((state) => (state ? 'mounted' : false));
-        }, []);
-        return (React.createElement(Context.Provider, { value: contextValue }, props.children));
-    };
-    function useContext() {
-        const context = React.useContext(Context);
-        if (!context) {
-            throw new Error('Unable to find tRPC Context. Did you forget to wrap your App inside `withTRPC` HoC?');
-        }
-        return context;
-    }
-    /**
-     * Hack to make sure errors return `status`='error` when doing SSR
-     * @link https://github.com/trpc/trpc/pull/1645
-     */
-    function useSSRQueryOptionsIfNeeded(queryKey, opts) {
-        const { queryClient, ssrState } = useContext();
-        return ssrState &&
-            ssrState !== 'mounted' &&
-            queryClient.getQueryCache().find({ queryKey })?.state.status === 'error'
-            ? {
-                retryOnMount: false,
-                ...opts,
-            }
-            : opts;
-    }
-    function useQuery$1(path, input, opts) {
-        const context = useContext();
-        const { abortOnUnmount, client, ssrState, queryClient, prefetchQuery } = context;
-        const queryKey = getQueryKeyInternal(path, input, 'query');
-        const defaultOpts = queryClient.getQueryDefaults(queryKey);
-        if (typeof window === 'undefined' &&
-            ssrState === 'prepass' &&
-            opts?.trpc?.ssr !== false &&
-            (opts?.enabled ?? defaultOpts?.enabled) !== false &&
-            !queryClient.getQueryCache().find({ queryKey })) {
-            void prefetchQuery(queryKey, opts);
-        }
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts,
-        });
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? abortOnUnmount;
-        const hook = useQuery({
-            ...ssrOpts,
-            queryKey: queryKey,
-            queryFn: (queryFunctionContext) => {
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...(shouldAbortOnUnmount
-                            ? { signal: queryFunctionContext.signal }
-                            : {}),
-                    },
-                };
-                return client.query(...getClientArgs(queryKey, actualOpts));
-            },
-        }, queryClient);
-        hook.trpc = useHookResult({
-            path: path.join('.'),
-        });
-        return hook;
-    }
-    function useSuspenseQuery$1(path, input, opts) {
-        const context = useContext();
-        const queryKey = getQueryKeyInternal(path, input, 'query');
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ??
-            config?.abortOnUnmount ??
-            context.abortOnUnmount;
-        const hook = useSuspenseQuery({
-            ...opts,
-            queryKey: queryKey,
-            queryFn: (queryFunctionContext) => {
-                const actualOpts = {
-                    trpc: {
-                        ...(shouldAbortOnUnmount
-                            ? { signal: queryFunctionContext.signal }
-                            : {}),
-                    },
-                };
-                return context.client.query(...getClientArgs(queryKey, actualOpts));
-            },
-        }, context.queryClient);
-        hook.trpc = useHookResult({
-            path: path.join('.'),
-        });
-        return [hook.data, hook];
-    }
-    function useMutation$1(path, opts) {
-        const { client } = useContext();
-        const queryClient = useQueryClient();
-        const mutationKey = [path];
-        const defaultOpts = queryClient.getMutationDefaults(mutationKey);
-        const hook = useMutation({
-            ...opts,
-            mutationKey: mutationKey,
-            mutationFn: (input) => {
-                return client.mutation(...getClientArgs([path, { input }], opts));
-            },
-            onSuccess(...args) {
-                const originalFn = () => opts?.onSuccess?.(...args) ?? defaultOpts?.onSuccess?.(...args);
-                return mutationSuccessOverride({
-                    originalFn,
-                    queryClient,
-                    meta: opts?.meta ?? defaultOpts?.meta ?? {},
-                });
-            },
-        }, queryClient);
-        hook.trpc = useHookResult({
-            path: path.join('.'),
-        });
-        return hook;
-    }
-    /* istanbul ignore next -- @preserve */
-    function useSubscription(path, input, opts) {
-        const enabled = opts?.enabled ?? true;
-        const queryKey = hashKey(getQueryKeyInternal(path, input, 'any'));
-        const { client } = useContext();
-        const optsRef = React.useRef(opts);
-        optsRef.current = opts;
-        React.useEffect(() => {
-            if (!enabled) {
-                return;
-            }
-            let isStopped = false;
-            const subscription = client.subscription(path.join('.'), input ?? undefined, {
-                onStarted: () => {
-                    if (!isStopped) {
-                        optsRef.current.onStarted?.();
-                    }
-                },
-                onData: (data) => {
-                    if (!isStopped) {
-                        opts.onData(data);
-                    }
-                },
-                onError: (err) => {
-                    if (!isStopped) {
-                        optsRef.current.onError?.(err);
-                    }
-                },
-            });
-            return () => {
-                isStopped = true;
-                subscription.unsubscribe();
-            };
-            // eslint-disable-next-line react-hooks/exhaustive-deps
-        }, [queryKey, enabled]);
-    }
-    function useInfiniteQuery$1(path, input, opts) {
-        const { client, ssrState, prefetchInfiniteQuery, queryClient, abortOnUnmount, } = useContext();
-        const queryKey = getQueryKeyInternal(path, input, 'infinite');
-        const defaultOpts = queryClient.getQueryDefaults(queryKey);
-        if (typeof window === 'undefined' &&
-            ssrState === 'prepass' &&
-            opts?.trpc?.ssr !== false &&
-            (opts?.enabled ?? defaultOpts?.enabled) !== false &&
-            !queryClient.getQueryCache().find({ queryKey })) {
-            void prefetchInfiniteQuery(queryKey, { ...defaultOpts, ...opts });
-        }
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts,
-        });
-        // request option should take priority over global
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
-        const hook = useInfiniteQuery({
-            ...ssrOpts,
-            initialPageParam: opts.initialCursor ?? null,
-            persister: opts.persister,
-            queryKey: queryKey,
-            queryFn: (queryFunctionContext) => {
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...(shouldAbortOnUnmount
-                            ? { signal: queryFunctionContext.signal }
-                            : {}),
-                    },
-                };
-                return client.query(...getClientArgs(queryKey, actualOpts, queryFunctionContext.pageParam ?? opts.initialCursor));
-            },
-        }, queryClient);
-        hook.trpc = useHookResult({
-            path: path.join('.'),
-        });
-        return hook;
-    }
-    function useSuspenseInfiniteQuery$1(path, input, opts) {
-        const context = useContext();
-        const queryKey = getQueryKeyInternal(path, input, 'infinite');
-        const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts,
-        });
-        // request option should take priority over global
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
-        const hook = useSuspenseInfiniteQuery({
-            ...opts,
-            initialPageParam: opts.initialCursor ?? null,
-            queryKey,
-            queryFn: (queryFunctionContext) => {
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...(shouldAbortOnUnmount
-                            ? { signal: queryFunctionContext.signal }
-                            : {}),
-                    },
-                };
-                return context.client.query(...getClientArgs(queryKey, actualOpts, queryFunctionContext.pageParam ?? opts.initialCursor));
-            },
-        }, context.queryClient);
-        hook.trpc = useHookResult({
-            path: path.join('.'),
-        });
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return [hook.data, hook];
-    }
-    const useQueries$1 = (queriesCallback) => {
-        const { ssrState, queryClient, prefetchQuery, client } = useContext();
-        const proxy = createUseQueries(client);
-        const queries = queriesCallback(proxy);
-        if (typeof window === 'undefined' && ssrState === 'prepass') {
-            for (const query of queries) {
-                const queryOption = query;
-                if (queryOption.trpc?.ssr !== false &&
-                    !queryClient.getQueryCache().find({ queryKey: queryOption.queryKey })) {
-                    void prefetchQuery(queryOption.queryKey, queryOption);
-                }
-            }
-        }
-        return useQueries({
-            queries: queries.map((query) => ({
-                ...query,
-                queryKey: query.queryKey,
-            })),
-        }, queryClient);
-    };
-    const useSuspenseQueries$1 = (queriesCallback) => {
-        const { queryClient, client } = useContext();
-        const proxy = createUseQueries(client);
-        const queries = queriesCallback(proxy);
-        const hook = useSuspenseQueries({
-            queries: queries.map((query) => ({
-                ...query,
-                queryKey: query.queryKey,
-            })),
-        }, queryClient);
-        return [hook.map((h) => h.data), hook];
-    };
-    const useDehydratedState = (client, trpcState) => {
-        const transformed = React.useMemo(() => {
-            if (!trpcState) {
-                return trpcState;
-            }
-            return client.runtime.transformer.deserialize(trpcState);
-        }, [trpcState, client]);
-        return transformed;
-    };
-    return {
-        Provider: TRPCProvider,
-        createClient,
-        useContext,
-        useUtils: useContext,
-        useQuery: useQuery$1,
-        useSuspenseQuery: useSuspenseQuery$1,
-        useQueries: useQueries$1,
-        useSuspenseQueries: useSuspenseQueries$1,
-        useMutation: useMutation$1,
-        useSubscription,
-        useDehydratedState,
-        useInfiniteQuery: useInfiniteQuery$1,
-        useSuspenseInfiniteQuery: useSuspenseInfiniteQuery$1,
-    };
-}
-
-export { createReactDecoration as a, createUtilityFunctions as b, createRootHooks as c, createUseQueries as d, getClientArgs as g };

package/dist/queryClient-1c8d7d8a.js

@@ -1,8 +0,0 @@
-import { QueryClient } from '@tanstack/react-query';
-
-/**
- * @internal
- */
-const getQueryClient = (config) => config.queryClient ?? new QueryClient(config.queryClientConfig);
-
-export { getQueryClient as g };