@trpc/react-query 10.6.0 → 10.8.0

package/src/shared/hooks/types.ts

@@ -0,0 +1,151 @@
+import {
+  DefinedUseQueryResult,
+  DehydratedState,
+  InfiniteQueryObserverSuccessResult,
+  InitialDataFunction,
+  QueryObserverSuccessResult,
+  QueryOptions,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+} from '@tanstack/react-query';
+import {
+  CreateTRPCClientOptions,
+  TRPCClient,
+  TRPCRequestOptions,
+} from '@trpc/client';
+import { AnyRouter } from '@trpc/server';
+import { ReactNode } from 'react';
+import { TRPCContextProps } from '../../internals/context';
+import { TRPCHookResult } from '../../internals/useHookResult';
+
+export type OutputWithCursor<TData, TCursor = any> = {
+  cursor: TCursor | null;
+  data: TData;
+};
+
+export interface TRPCReactRequestOptions
+  // For RQ, we use their internal AbortSignals instead of letting the user pass their own
+  extends Omit<TRPCRequestOptions, 'signal'> {
+  /**
+   * Opt out of SSR for this query by passing `ssr: false`
+   */
+  ssr?: boolean;
+  /**
+   * Opt out or into aborting request on unmount
+   */
+  abortOnUnmount?: boolean;
+}
+
+export interface TRPCUseQueryBaseOptions {
+  /**
+   * tRPC-related options
+   */
+  trpc?: TRPCReactRequestOptions;
+}
+
+export interface UseTRPCQueryOptions<TPath, TInput, TOutput, TData, TError>
+  extends UseQueryOptions<TOutput, TError, TData, [TPath, TInput]>,
+    TRPCUseQueryBaseOptions {}
+
+/** @internal **/
+export interface DefinedUseTRPCQueryOptions<
+  TPath,
+  TInput,
+  TOutput,
+  TData,
+  TError,
+> extends UseTRPCQueryOptions<TPath, TInput, TOutput, TData, TError> {
+  initialData: TOutput | InitialDataFunction<TOutput>;
+}
+
+export interface TRPCQueryOptions<TPath, TInput, TData, TError>
+  extends QueryOptions<TData, TError, TData, [TPath, TInput]>,
+    TRPCUseQueryBaseOptions {}
+
+export interface UseTRPCInfiniteQueryOptions<TPath, TInput, TOutput, TError>
+  extends UseInfiniteQueryOptions<
+      TOutput,
+      TError,
+      TOutput,
+      TOutput,
+      [TPath, TInput]
+    >,
+    TRPCUseQueryBaseOptions {}
+
+export interface UseTRPCMutationOptions<
+  TInput,
+  TError,
+  TOutput,
+  TContext = unknown,
+> extends UseMutationOptions<TOutput, TError, TInput, TContext>,
+    TRPCUseQueryBaseOptions {}
+
+export interface UseTRPCSubscriptionOptions<TOutput, TError> {
+  enabled?: boolean;
+  onStarted?: () => void;
+  onData: (data: TOutput) => void;
+  onError?: (err: TError) => void;
+}
+export interface TRPCProviderProps<TRouter extends AnyRouter, TSSRContext>
+  extends TRPCContextProps<TRouter, TSSRContext> {
+  children: ReactNode;
+}
+
+export type TRPCProvider<TRouter extends AnyRouter, TSSRContext> = (
+  props: TRPCProviderProps<TRouter, TSSRContext>,
+) => JSX.Element;
+
+export type UseDehydratedState<TRouter extends AnyRouter> = (
+  client: TRPCClient<TRouter>,
+  trpcState: DehydratedState | undefined,
+) => DehydratedState | undefined;
+
+export type CreateClient<TRouter extends AnyRouter> = (
+  opts: CreateTRPCClientOptions<TRouter>,
+) => TRPCClient<TRouter>;
+
+/**
+ * @internal
+ */
+export type UseTRPCQueryResult<TData, TError> = UseQueryResult<TData, TError> &
+  TRPCHookResult;
+
+/**
+ * @internal
+ */
+export type DefinedUseTRPCQueryResult<TData, TError> = DefinedUseQueryResult<
+  TData,
+  TError
+> &
+  TRPCHookResult;
+
+/**
+ * @internal
+ */
+export type UseTRPCQuerySuccessResult<TData, TError> =
+  QueryObserverSuccessResult<TData, TError> & TRPCHookResult;
+
+/**
+ * @internal
+ */
+export type UseTRPCInfiniteQueryResult<TData, TError> = UseInfiniteQueryResult<
+  TData,
+  TError
+> &
+  TRPCHookResult;
+
+/**
+ * @internal
+ */
+export type UseTRPCInfiniteQuerySuccessResult<TData, TError> =
+  InfiniteQueryObserverSuccessResult<TData, TError> & TRPCHookResult;
+
+/**
+ * @internal
+ */
+export type UseTRPCMutationResult<TData, TError, TVariables, TContext> =
+  UseMutationResult<TData, TError, TVariables, TContext> & TRPCHookResult;

package/src/shared/index.ts

@@ -9,3 +9,20 @@ export type { TRPCUseQueries } from '../internals/useQueries';
 export * from './hooks/createHooksInternal';
 export * from './queryClient';
 export * from './types';
+export * from './hooks/types';
+
+export {
+  /**
+   * @deprecated this is an internal function
+   */
+  getClientArgs,
+} from '../internals/getClientArgs';
+
+export {
+  /**
+   * @deprecated
+   */
+  TRPCContext,
+} from './../internals/context';
+
+export * from '../internals/context';

package/src/shared/proxy/decorationProxy.ts

@@ -1,5 +1,6 @@
 import { AnyRouter } from '@trpc/server';
 import { createRecursiveProxy } from '@trpc/server/shared';
+import { getArrayQueryKey } from '../../internals/getArrayQueryKey';
 import { getQueryKey } from '../../internals/getQueryKey';
 import { CreateReactQueryHooks } from '../hooks/createHooksInternal';
 
@@ -28,6 +29,12 @@ export function createReactProxyDecoration<
     const [input, ...rest] = args;
 
     const queryKey = getQueryKey(path, input);
+
+    // Expose queryKey helper
+    if (lastArg === 'getQueryKey') {
+      return getArrayQueryKey(queryKey, (rest[0] as any) ?? 'any');
+    }
+
     if (lastArg.startsWith('useSuspense')) {
       const opts = rest[0] || {};
       const fn =

package/src/shared/proxy/utilsProxy.ts

@@ -15,6 +15,7 @@ import {
   AnyRouter,
   Filter,
   ProcedureOptions,
+  ProtectedIntersection,
   inferProcedureInput,
 } from '@trpc/server';
 import {
@@ -24,11 +25,11 @@ import {
 } from '@trpc/server/shared';
 import {
   DecoratedProxyTRPCContextProps,
-  TRPCContextState,
   TRPCFetchInfiniteQueryOptions,
   TRPCFetchQueryOptions,
   contextProps,
 } from '../../internals/context';
+import { TRPCContextState } from '../../internals/context';
 import { getQueryKey } from '../../internals/getQueryKey';
 
 type DecorateProcedure<
@@ -171,6 +172,7 @@ type DecorateRouter = {
    * @link https://react-query.tanstack.com/guides/query-invalidation
    */
   invalidate(
+    input?: undefined,
     filters?: InvalidateQueryFilters,
     options?: InvalidateOptions,
   ): Promise<void>;
@@ -195,8 +197,10 @@ type AnyDecoratedProcedure = DecorateProcedure<any, any>;
 export type CreateReactUtilsProxy<
   TRouter extends AnyRouter,
   TSSRContext,
-> = DecoratedProcedureUtilsRecord<TRouter> &
-  DecoratedProxyTRPCContextProps<TRouter, TSSRContext>;
+> = ProtectedIntersection<
+  DecoratedProxyTRPCContextProps<TRouter, TSSRContext>,
+  DecoratedProcedureUtilsRecord<TRouter>
+>;
 
 /**
  * @internal

package/src/ssg/ssgProxy.ts

@@ -9,6 +9,7 @@ import {
   AnyQueryProcedure,
   AnyRouter,
   Filter,
+  ProtectedIntersection,
   inferHandlerInput,
 } from '@trpc/server';
 import {
@@ -67,10 +68,13 @@ export function createProxySSGHelpers<TRouter extends AnyRouter>(
 ) {
   const helpers = createSSGHelpers(opts);
 
-  type CreateProxySSGHelpers = {
-    queryClient: QueryClient;
-    dehydrate: (opts?: DehydrateOptions) => DehydratedState;
-  } & DecoratedProcedureSSGRecord<TRouter>;
+  type CreateProxySSGHelpers = ProtectedIntersection<
+    {
+      queryClient: QueryClient;
+      dehydrate: (opts?: DehydrateOptions) => DehydratedState;
+    },
+    DecoratedProcedureSSGRecord<TRouter>
+  >;
 
   return createFlatProxy<CreateProxySSGHelpers>((key) => {
     if (key === 'queryClient') {

package/src/utils/inferReactQueryProcedure.ts

@@ -6,7 +6,7 @@ import {
   AnyRouter,
   inferProcedureInput,
 } from '@trpc/server';
-import { inferTransformedProcedureOutput } from '@trpc/server/dist/shared';
+import { inferTransformedProcedureOutput } from '@trpc/server/shared';
 import { UseTRPCMutationOptions, UseTRPCQueryOptions } from '../shared';
 
 type InferQueryOptions<