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

package/dist/server/index.mjs

@@ -1,103 +1 @@
-import { dehydrate } from '@tanstack/react-query';
-import { TRPCUntypedClient, getUntypedClient } from '@trpc/client';
-import { callProcedure, createFlatProxy, createRecursiveProxy } from '@trpc/core';
-import { b as getQueryKeyInternal, d as getQueryType } from '../utilsProxy-61a4601f.mjs';
-import 'react';
-import { g as getQueryClient } from '../queryClient-4d766c0c.mjs';
-
-/**
- * Create functions you can use for server-side rendering / static generation
- * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
- */ function createServerSideHelpers(opts) {
-    const queryClient = getQueryClient(opts);
-    const resolvedOpts = (()=>{
-        if ('router' in opts) {
-            const { transformer , ctx , router  } = opts;
-            return {
-                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
-                query: (queryOpts)=>{
-                    return callProcedure({
-                        procedures: router._def.procedures,
-                        path: queryOpts.path,
-                        getRawInput: async ()=>queryOpts.input,
-                        ctx,
-                        type: 'query'
-                    });
-                }
-            };
-        }
-        const { client  } = opts;
-        const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
-        return {
-            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
-            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
-        };
-    })();
-    function _dehydrate(opts = {
-        shouldDehydrateQuery () {
-            // makes sure to serialize errors
-            return true;
-        }
-    }) {
-        const before = dehydrate(queryClient, opts);
-        const after = resolvedOpts.serialize(before);
-        return after;
-    }
-    return createFlatProxy((key)=>{
-        if (key === 'queryClient') return queryClient;
-        if (key === 'dehydrate') return _dehydrate;
-        return createRecursiveProxy((opts)=>{
-            const args = opts.args;
-            const input = args[0];
-            const arrayPath = [
-                key,
-                ...opts.path
-            ];
-            const utilName = arrayPath.pop();
-            const queryFn = ()=>resolvedOpts.query({
-                    path: arrayPath.join('.'),
-                    input
-                });
-            const queryKey = getQueryKeyInternal(arrayPath, input, getQueryType(utilName));
-            const helperMap = {
-                fetch: ()=>{
-                    const args1 = args[1];
-                    return queryClient.fetchQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn
-                    });
-                },
-                fetchInfinite: ()=>{
-                    const args1 = args[1];
-                    return queryClient.fetchInfiniteQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn,
-                        initialPageParam: args1?.initialCursor ?? null
-                    });
-                },
-                prefetch: ()=>{
-                    const args1 = args[1];
-                    return queryClient.prefetchQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn
-                    });
-                },
-                prefetchInfinite: ()=>{
-                    const args1 = args[1];
-                    return queryClient.prefetchInfiniteQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn,
-                        initialPageParam: args1?.initialCursor ?? null
-                    });
-                }
-            };
-            return helperMap[utilName]();
-        });
-    });
-}
-
-export { createServerSideHelpers };
+export { createServerSideHelpers } from './ssgProxy.mjs';

package/dist/server/ssgProxy.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var client = require('@trpc/client');
+var core = require('@trpc/core');
+var getQueryKey = require('../internals/getQueryKey.js');
+var utilsProxy = require('../shared/proxy/utilsProxy.js');
+require('react');
+require('../internals/context.js');
+var queryClient = require('../shared/queryClient.js');
+
+/**
+ * Create functions you can use for server-side rendering / static generation
+ * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
+ */ function createServerSideHelpers(opts) {
+    const queryClient$1 = queryClient.getQueryClient(opts);
+    const resolvedOpts = (()=>{
+        if ('router' in opts) {
+            const { transformer , ctx , router  } = opts;
+            return {
+                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
+                query: (queryOpts)=>{
+                    return core.callProcedure({
+                        procedures: router._def.procedures,
+                        path: queryOpts.path,
+                        getRawInput: async ()=>queryOpts.input,
+                        ctx,
+                        type: 'query'
+                    });
+                }
+            };
+        }
+        const { client: client$1  } = opts;
+        const untypedClient = client$1 instanceof client.TRPCUntypedClient ? client$1 : client.getUntypedClient(client$1);
+        return {
+            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
+            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
+        };
+    })();
+    function _dehydrate(opts = {
+        shouldDehydrateQuery () {
+            // makes sure to serialize errors
+            return true;
+        }
+    }) {
+        const before = reactQuery.dehydrate(queryClient$1, opts);
+        const after = resolvedOpts.serialize(before);
+        return after;
+    }
+    return core.createFlatProxy((key)=>{
+        if (key === 'queryClient') return queryClient$1;
+        if (key === 'dehydrate') return _dehydrate;
+        return core.createRecursiveProxy((opts)=>{
+            const args = opts.args;
+            const input = args[0];
+            const arrayPath = [
+                key,
+                ...opts.path
+            ];
+            const utilName = arrayPath.pop();
+            const queryFn = ()=>resolvedOpts.query({
+                    path: arrayPath.join('.'),
+                    input
+                });
+            const queryKey = getQueryKey.getQueryKeyInternal(arrayPath, input, utilsProxy.getQueryType(utilName));
+            const helperMap = {
+                fetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.fetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                fetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.fetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                },
+                prefetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.prefetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                prefetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.prefetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                }
+            };
+            return helperMap[utilName]();
+        });
+    });
+}
+
+exports.createServerSideHelpers = createServerSideHelpers;

package/dist/server/ssgProxy.mjs

@@ -0,0 +1,105 @@
+import { dehydrate } from '@tanstack/react-query';
+import { TRPCUntypedClient, getUntypedClient } from '@trpc/client';
+import { callProcedure, createFlatProxy, createRecursiveProxy } from '@trpc/core';
+import { getQueryKeyInternal } from '../internals/getQueryKey.mjs';
+import { getQueryType } from '../shared/proxy/utilsProxy.mjs';
+import 'react';
+import '../internals/context.mjs';
+import { getQueryClient } from '../shared/queryClient.mjs';
+
+/**
+ * Create functions you can use for server-side rendering / static generation
+ * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
+ */ function createServerSideHelpers(opts) {
+    const queryClient = getQueryClient(opts);
+    const resolvedOpts = (()=>{
+        if ('router' in opts) {
+            const { transformer , ctx , router  } = opts;
+            return {
+                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
+                query: (queryOpts)=>{
+                    return callProcedure({
+                        procedures: router._def.procedures,
+                        path: queryOpts.path,
+                        getRawInput: async ()=>queryOpts.input,
+                        ctx,
+                        type: 'query'
+                    });
+                }
+            };
+        }
+        const { client  } = opts;
+        const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
+        return {
+            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
+            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
+        };
+    })();
+    function _dehydrate(opts = {
+        shouldDehydrateQuery () {
+            // makes sure to serialize errors
+            return true;
+        }
+    }) {
+        const before = dehydrate(queryClient, opts);
+        const after = resolvedOpts.serialize(before);
+        return after;
+    }
+    return createFlatProxy((key)=>{
+        if (key === 'queryClient') return queryClient;
+        if (key === 'dehydrate') return _dehydrate;
+        return createRecursiveProxy((opts)=>{
+            const args = opts.args;
+            const input = args[0];
+            const arrayPath = [
+                key,
+                ...opts.path
+            ];
+            const utilName = arrayPath.pop();
+            const queryFn = ()=>resolvedOpts.query({
+                    path: arrayPath.join('.'),
+                    input
+                });
+            const queryKey = getQueryKeyInternal(arrayPath, input, getQueryType(utilName));
+            const helperMap = {
+                fetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient.fetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                fetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient.fetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                },
+                prefetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient.prefetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                prefetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient.prefetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                }
+            };
+            return helperMap[utilName]();
+        });
+    });
+}
+
+export { createServerSideHelpers };

package/dist/{createHooksInternal-5d2fa367.js → shared/hooks/createHooksInternal.js}

@@ -1,13 +1,16 @@
 'use strict';
 
-var core = require('@trpc/core');
 var reactQuery = require('@tanstack/react-query');
 var client = require('@trpc/client');
 var React = require('react');
-var utilsProxy = require('./utilsProxy-0b88c1e3.js');
+var context = require('../../internals/context.js');
+var getClientArgs = require('../../internals/getClientArgs.js');
+var getQueryKey = require('../../internals/getQueryKey.js');
+var useHookResult = require('../../internals/useHookResult.js');
+var createUtilityFunctions = require('../../utils/createUtilityFunctions.js');
+var useQueriesProxy = require('../proxy/useQueriesProxy.js');
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
     Object.keys(e).forEach(function (k) {
@@ -20,178 +23,24 @@ function _interopNamespace(e) {
       }
     });
   }
-  n["default"] = e;
+  n.default = e;
   return Object.freeze(n);
 }
 
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
-
-/**
- * Create proxy for decorating procedures
- * @internal
- */ function createReactDecoration(name, hooks) {
-    return core.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 core.createRecursiveProxy((opts)=>{
-        const arrayPath = opts.path;
-        const dotPath = arrayPath.join('.');
-        const [input, _opts] = opts.args;
-        const options = {
-            queryKey: utilsProxy.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__namespace.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: client$1 , queryClient  } = opts;
-    const untypedClient = client$1 instanceof client.TRPCUntypedClient ? client$1 : client.getUntypedClient(client$1);
-    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);
-        }
-    };
-}
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
 /**
  * @internal
  */ function createRootHooks(config) {
     const mutationSuccessOverride = config?.overrides?.useMutation?.onSuccess ?? ((options)=>options.originalFn());
-    const Context = config?.context ?? utilsProxy.TRPCContext;
+    const Context = config?.context ?? context.TRPCContext;
     const createClient = (opts)=>{
         return client.createTRPCUntypedClient(opts);
     };
     const TRPCProvider = (props)=>{
         const { abortOnUnmount =false , client , queryClient , ssrContext  } = props;
         const [ssrState, setSSRState] = React__namespace.useState(props.ssrState ?? false);
-        const fns = React__namespace.useMemo(()=>createUtilityFunctions({
+        const fns = React__namespace.useMemo(()=>createUtilityFunctions.createUtilityFunctions({
                 client,
                 queryClient
             }), [
@@ -244,7 +93,7 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
     function useQuery(path, input, opts) {
         const context = useContext();
         const { abortOnUnmount , client , ssrState , queryClient , prefetchQuery  } = context;
-        const queryKey = utilsProxy.getQueryKeyInternal(path, input, 'query');
+        const queryKey = getQueryKey.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
@@ -269,17 +118,17 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
                         } : {}
                     }
                 };
-                return client.query(...getClientArgs(queryKey, actualOpts));
+                return client.query(...getClientArgs.getClientArgs(queryKey, actualOpts));
             }
         }, queryClient);
-        hook.trpc = useHookResult({
+        hook.trpc = useHookResult.useHookResult({
             path: path.join('.')
         });
         return hook;
     }
     function useSuspenseQuery(path, input, opts) {
         const context = useContext();
-        const queryKey = utilsProxy.getQueryKeyInternal(path, input, 'query');
+        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'query');
         const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
         const hook = reactQuery.useSuspenseQuery({
             ...opts,
@@ -292,10 +141,10 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
                         } : {}
                     }
                 };
-                return context.client.query(...getClientArgs(queryKey, actualOpts));
+                return context.client.query(...getClientArgs.getClientArgs(queryKey, actualOpts));
             }
         }, context.queryClient);
-        hook.trpc = useHookResult({
+        hook.trpc = useHookResult.useHookResult({
             path: path.join('.')
         });
         return [
@@ -314,7 +163,7 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
             ...opts,
             mutationKey: mutationKey,
             mutationFn: (input)=>{
-                return client.mutation(...getClientArgs([
+                return client.mutation(...getClientArgs.getClientArgs([
                     path,
                     {
                         input
@@ -330,14 +179,14 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
                 });
             }
         }, queryClient);
-        hook.trpc = useHookResult({
+        hook.trpc = useHookResult.useHookResult({
             path: path.join('.')
         });
         return hook;
     }
     /* istanbul ignore next -- @preserve */ function useSubscription(path, input, opts) {
         const enabled = opts?.enabled ?? true;
-        const queryKey = reactQuery.hashKey(utilsProxy.getQueryKeyInternal(path, input, 'any'));
+        const queryKey = reactQuery.hashKey(getQueryKey.getQueryKeyInternal(path, input, 'any'));
         const { client  } = useContext();
         const optsRef = React__namespace.useRef(opts);
         optsRef.current = opts;
@@ -375,7 +224,7 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
     }
     function useInfiniteQuery(path, input, opts) {
         const { client , ssrState , prefetchInfiniteQuery , queryClient , abortOnUnmount ,  } = useContext();
-        const queryKey = utilsProxy.getQueryKeyInternal(path, input, 'infinite');
+        const queryKey = getQueryKey.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
@@ -406,17 +255,17 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
                         } : {}
                     }
                 };
-                return client.query(...getClientArgs(queryKey, actualOpts, queryFunctionContext.pageParam ?? opts.initialCursor));
+                return client.query(...getClientArgs.getClientArgs(queryKey, actualOpts, queryFunctionContext.pageParam ?? opts.initialCursor));
             }
         }, queryClient);
-        hook.trpc = useHookResult({
+        hook.trpc = useHookResult.useHookResult({
             path: path.join('.')
         });
         return hook;
     }
     function useSuspenseInfiniteQuery(path, input, opts) {
         const context = useContext();
-        const queryKey = utilsProxy.getQueryKeyInternal(path, input, 'infinite');
+        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'infinite');
         const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
         const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
             ...defaultOpts,
@@ -438,10 +287,10 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
                         } : {}
                     }
                 };
-                return context.client.query(...getClientArgs(queryKey, actualOpts, queryFunctionContext.pageParam ?? opts.initialCursor));
+                return context.client.query(...getClientArgs.getClientArgs(queryKey, actualOpts, queryFunctionContext.pageParam ?? opts.initialCursor));
             }
         }, context.queryClient);
-        hook.trpc = useHookResult({
+        hook.trpc = useHookResult.useHookResult({
             path: path.join('.')
         });
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -452,7 +301,7 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
     }
     const useQueries = (queriesCallback)=>{
         const { ssrState , queryClient , prefetchQuery , client  } = useContext();
-        const proxy = createUseQueries(client);
+        const proxy = useQueriesProxy.createUseQueries(client);
         const queries = queriesCallback(proxy);
         if (typeof window === 'undefined' && ssrState === 'prepass') {
             for (const query of queries){
@@ -473,7 +322,7 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
     };
     const useSuspenseQueries = (queriesCallback)=>{
         const { queryClient , client  } = useContext();
-        const proxy = createUseQueries(client);
+        const proxy = useQueriesProxy.createUseQueries(client);
         const queries = queriesCallback(proxy);
         const hook = reactQuery.useSuspenseQueries({
             queries: queries.map((query)=>({
@@ -515,8 +364,4 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
     };
 }
 
-exports.createReactDecoration = createReactDecoration;
 exports.createRootHooks = createRootHooks;
-exports.createUseQueries = createUseQueries;
-exports.createUtilityFunctions = createUtilityFunctions;
-exports.getClientArgs = getClientArgs;