@trpc/tanstack-react-query 11.0.0-rc.768 → 11.0.0-rc.781

package/src/internals/infiniteQueryOptions.ts

@@ -2,16 +2,13 @@ import type {
   DataTag,
   DefinedInitialDataInfiniteOptions,
   InfiniteData,
+  QueryClient,
   QueryFunction,
+  SkipToken,
   UndefinedInitialDataInfiniteOptions,
   UnusedSkipTokenInfiniteOptions,
 } from '@tanstack/react-query';
-import {
-  infiniteQueryOptions,
-  skipToken,
-  type QueryClient,
-  type SkipToken,
-} from '@tanstack/react-query';
+import { infiniteQueryOptions, skipToken } from '@tanstack/react-query';
 import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
 import type { DistributiveOmit } from '@trpc/server/unstable-core-do-not-import';
 import type {
@@ -188,13 +185,33 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
   >;
 }
 
+type AnyTRPCInfiniteQueryOptionsIn =
+  | DefinedTRPCInfiniteQueryOptionsIn<unknown, unknown, unknown, unknown>
+  | UnusedSkipTokenTRPCInfiniteQueryOptionsIn<
+      unknown,
+      unknown,
+      unknown,
+      unknown
+    >
+  | UndefinedTRPCInfiniteQueryOptionsIn<unknown, unknown, unknown, unknown>;
+
+type AnyTRPCInfiniteQueryOptionsOut =
+  | DefinedTRPCInfiniteQueryOptionsOut<unknown, unknown, unknown, unknown>
+  | UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
+      unknown,
+      unknown,
+      unknown,
+      unknown
+    >
+  | UndefinedTRPCInfiniteQueryOptionsOut<unknown, unknown, unknown, unknown>;
+
 export function trpcInfiniteQueryOptions(args: {
   query: typeof TRPCUntypedClient.prototype.query;
   queryClient: QueryClient | (() => QueryClient);
   path: readonly string[];
   queryKey: TRPCQueryKey;
-  opts: UndefinedTRPCInfiniteQueryOptionsIn<unknown, unknown, unknown, unknown>;
-}) {
+  opts: AnyTRPCInfiniteQueryOptionsIn;
+}): AnyTRPCInfiniteQueryOptionsOut {
   const { query, path, queryKey, opts } = args;
   const inputIsSkipToken = queryKey[1]?.input === skipToken;
 

package/src/internals/mutationOptions.ts

@@ -1,7 +1,7 @@
-import type { MutationFunction } from '@tanstack/react-query';
-import {
-  type QueryClient,
-  type UseMutationOptions,
+import type {
+  MutationFunction,
+  QueryClient,
+  UseMutationOptions,
 } from '@tanstack/react-query';
 import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
 import type {
@@ -69,13 +69,30 @@ export interface MutationOptionsOverride {
   }) => MaybePromise<unknown>;
 }
 
+type AnyTRPCMutationOptionsIn = TRPCMutationOptionsIn<
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+type AnyTRPCMutationOptionsOut = TRPCMutationOptionsOut<
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+/**
+ * @internal
+ */
 export function trpcMutationOptions(args: {
   mutate: typeof TRPCUntypedClient.prototype.mutation;
   queryClient: QueryClient | (() => QueryClient);
   path: readonly string[];
-  opts: TRPCMutationOptionsIn<unknown, unknown, unknown, unknown> | undefined;
+  opts: AnyTRPCMutationOptionsIn;
   overrides: MutationOptionsOverride | undefined;
-}): TRPCMutationOptionsOut<unknown, unknown, unknown, unknown> {
+}): AnyTRPCMutationOptionsOut {
   const { mutate, path, opts, overrides } = args;
   const queryClient = unwrapLazyArg(args.queryClient);
 

package/src/internals/queryOptions.ts

@@ -3,10 +3,11 @@ import type {
   DefinedInitialDataOptions,
   QueryClient,
   QueryFunction,
+  SkipToken,
   UndefinedInitialDataOptions,
   UnusedSkipTokenOptions,
 } from '@tanstack/react-query';
-import { queryOptions, skipToken, type SkipToken } from '@tanstack/react-query';
+import { queryOptions, skipToken } from '@tanstack/react-query';
 import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
 import type {
   coerceAsyncIterableToArray,
@@ -154,13 +155,26 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
   >;
 }
 
+type AnyTRPCQueryOptionsIn =
+  | DefinedTRPCQueryOptionsIn<unknown, unknown, unknown>
+  | UnusedSkipTokenTRPCQueryOptionsIn<unknown, unknown, unknown>
+  | UndefinedTRPCQueryOptionsIn<unknown, unknown, unknown>;
+
+type AnyTRPCQueryOptionsOut =
+  | DefinedTRPCQueryOptionsOut<unknown, unknown, unknown>
+  | UnusedSkipTokenTRPCQueryOptionsOut<unknown, unknown, unknown>
+  | UndefinedTRPCQueryOptionsOut<unknown, unknown, unknown>;
+
+/**
+ * @internal
+ */
 export function trpcQueryOptions(args: {
   query: typeof TRPCUntypedClient.prototype.query;
   queryClient: QueryClient | (() => QueryClient);
   path: readonly string[];
   queryKey: TRPCQueryKey;
-  opts: UndefinedTRPCQueryOptionsIn<unknown, unknown, unknown>;
-}) {
+  opts: AnyTRPCQueryOptionsIn;
+}): AnyTRPCQueryOptionsOut {
   const { query, path, queryKey, opts } = args;
   const queryClient = unwrapLazyArg(args.queryClient);
 

package/src/internals/subscriptionOptions.ts

@@ -1,4 +1,5 @@
-import { hashKey, skipToken, type SkipToken } from '@tanstack/react-query';
+import type { SkipToken } from '@tanstack/react-query';
+import { hashKey, skipToken } from '@tanstack/react-query';
 import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
 import type { TRPCConnectionState } from '@trpc/client/unstable-internals';
 import type { Unsubscribable } from '@trpc/server/observable';
@@ -14,15 +15,16 @@ import { createTRPCOptionsResult } from './utils';
 interface BaseTRPCSubscriptionOptionsIn<TOutput, TError> {
   enabled?: boolean;
   onStarted?: () => void;
-  onData: (data: inferAsyncIterableYield<TOutput>) => void;
+  onData?: (data: inferAsyncIterableYield<TOutput>) => void;
   onError?: (err: TError) => void;
+  onConnectionStateChange?: (state: TRPCConnectionState<TError>) => void;
 }
 
 interface UnusedSkipTokenTRPCSubscriptionOptionsIn<TOutput, TError> {
   onStarted?: () => void;
-  onData: (data: inferAsyncIterableYield<TOutput>) => void;
+  onData?: (data: inferAsyncIterableYield<TOutput>) => void;
   onError?: (err: TError) => void;
-  onConnectionStateChange: (state: TRPCConnectionState<TError>) => void;
+  onConnectionStateChange?: (state: TRPCConnectionState<TError>) => void;
 }
 
 interface TRPCSubscriptionOptionsOut<TOutput, TError>
@@ -107,15 +109,27 @@ export type TRPCSubscriptionResult<TOutput, TError> =
   | TRPCSubscriptionErrorResult<TOutput, TError>
   | TRPCSubscriptionPendingResult<TOutput>;
 
+type AnyTRPCSubscriptionOptionsIn =
+  | BaseTRPCSubscriptionOptionsIn<unknown, unknown>
+  | UnusedSkipTokenTRPCSubscriptionOptionsIn<unknown, unknown>;
+
+type AnyTRPCSubscriptionOptionsOut = TRPCSubscriptionOptionsOut<
+  unknown,
+  unknown
+>;
+
+/**
+ * @internal
+ */
 export const trpcSubscriptionOptions = (args: {
   subscribe: typeof TRPCUntypedClient.prototype.subscription;
   path: readonly string[];
   queryKey: TRPCQueryKey;
-  opts: BaseTRPCSubscriptionOptionsIn<unknown, unknown> | undefined;
-}) => {
+  opts: AnyTRPCSubscriptionOptionsIn;
+}): AnyTRPCSubscriptionOptionsOut => {
   const { subscribe, path, queryKey, opts } = args;
   const input = queryKey[1]?.input;
-  const enabled = opts?.enabled ?? input !== skipToken;
+  const enabled = 'enabled' in opts ? !!opts.enabled : input !== skipToken;
 
   const _subscribe: ReturnType<TRPCSubscriptionOptions<any>>['subscribe'] = (
     innerOpts,
@@ -147,7 +161,9 @@ export function useSubscription<TOutput, TError>(
   }, []);
 
   type Unsubscribe = () => void;
-  const currentSubscriptionRef = React.useRef<Unsubscribe>();
+  const currentSubscriptionRef = React.useRef<Unsubscribe>(() => {
+    // noop
+  });
 
   const reset = React.useCallback((): void => {
     // unsubscribe from the previous subscription

package/src/internals/types.ts

@@ -1,5 +1,8 @@
 import type { TRPCRequestOptions } from '@trpc/client';
 
+/**
+ * @internal
+ */
 export type ResolverDef = {
   input: any;
   output: any;
@@ -7,10 +10,16 @@ export type ResolverDef = {
   errorShape: any;
 };
 
+/**
+ * @internal
+ */
 export type ExtractCursorType<TInput> = TInput extends { cursor?: any }
   ? TInput['cursor']
   : unknown;
 
+/**
+ * @public
+ */
 export interface TRPCReactRequestOptions
   // For RQ, we use their internal AbortSignals instead of letting the user pass their own
   extends Omit<TRPCRequestOptions, 'signal'> {
@@ -24,6 +33,9 @@ export interface TRPCReactRequestOptions
   abortOnUnmount?: boolean;
 }
 
+/**
+ * @public
+ */
 export interface TRPCQueryBaseOptions {
   /**
    * tRPC-related options
@@ -31,17 +43,29 @@ export interface TRPCQueryBaseOptions {
   trpc?: TRPCReactRequestOptions;
 }
 
+/**
+ * @public
+ */
 export interface TRPCQueryOptionsResult {
   trpc: {
     path: string;
   };
 }
 
+/**
+ * @public
+ */
 export type QueryType = 'any' | 'infinite' | 'query';
 
+/**
+ * @public
+ */
 export type TRPCQueryKey = [
   readonly string[],
   { input?: unknown; type?: Exclude<QueryType, 'any'> }?,
 ];
 
+/**
+ * @public
+ */
 export type TRPCMutationKey = [readonly string[]]; // = [TRPCQueryKey[0]]

package/src/internals/utils.ts

@@ -1,4 +1,5 @@
-import { skipToken, type QueryClient } from '@tanstack/react-query';
+import type { QueryClient } from '@tanstack/react-query';
+import { skipToken } from '@tanstack/react-query';
 import { isFunction, isObject } from '@trpc/server/unstable-core-do-not-import';
 import type {
   QueryType,
@@ -77,7 +78,9 @@ export async function buildQueryFromAsyncIterable(
  * To allow easy interactions with groups of related queries, such as
  * invalidating all queries of a router, we use an array as the path when
  * storing in tanstack query.
- **/
+ *
+ * @internal
+ */
 export function getQueryKeyInternal(
   path: readonly string[],
   input: unknown,
@@ -126,6 +129,9 @@ export function getQueryKeyInternal(
   ];
 }
 
+/**
+ * @internal
+ */
 export function getMutationKeyInternal(
   path: readonly string[],
 ): TRPCMutationKey {
@@ -135,6 +141,9 @@ export function getMutationKeyInternal(
   return splitPath.length ? [splitPath] : ([] as unknown as TRPCMutationKey);
 }
 
+/**
+ * @internal
+ */
 export function unwrapLazyArg<T>(valueOrLazy: T | (() => T)): T {
   return (isFunction(valueOrLazy) ? valueOrLazy() : valueOrLazy) as T;
 }