@trpc/tanstack-react-query 11.6.1-canary.5 → 11.7.0

package/src/internals/infiniteQueryOptions.ts

@@ -12,6 +12,7 @@ import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
 import type { DistributiveOmit } from '@trpc/server/unstable-core-do-not-import';
 import type {
   ExtractCursorType,
+  FeatureFlags,
   ResolverDef,
   TRPCInfiniteData,
   TRPCQueryBaseOptions,
@@ -32,12 +33,13 @@ interface UndefinedTRPCInfiniteQueryOptionsIn<
   TQueryFnData,
   TData,
   TError,
+  TFeatureFlags extends FeatureFlags,
 > extends DistributiveOmit<
       UndefinedInitialDataInfiniteOptions<
         TQueryFnData,
         TError,
         TRPCInfiniteData<TInput, TData>,
-        TRPCQueryKey,
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>,
         NonNullable<ExtractCursorType<TInput>> | null
       >,
       ReservedOptions
@@ -51,28 +53,38 @@ interface UndefinedTRPCInfiniteQueryOptionsOut<
   TQueryFnData,
   TData,
   TError,
+  TFeatureFlags extends FeatureFlags,
 > extends DistributiveOmit<
       UndefinedInitialDataInfiniteOptions<
         TQueryFnData,
         TError,
         TRPCInfiniteData<TInput, TData>,
-        TRPCQueryKey,
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>,
         NonNullable<ExtractCursorType<TInput>> | null
       >,
       'initialPageParam'
     >,
     TRPCQueryOptionsResult {
-  queryKey: DataTag<TRPCQueryKey, TRPCInfiniteData<TInput, TData>, TError>;
+  queryKey: DataTag<
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    TRPCInfiniteData<TInput, TData>,
+    TError
+  >;
   initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
 }
 
-interface DefinedTRPCInfiniteQueryOptionsIn<TInput, TQueryFnData, TData, TError>
-  extends DistributiveOmit<
+interface DefinedTRPCInfiniteQueryOptionsIn<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends DistributiveOmit<
       DefinedInitialDataInfiniteOptions<
         TQueryFnData,
         TError,
         TRPCInfiniteData<TInput, TData>,
-        TRPCQueryKey,
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>,
         NonNullable<ExtractCursorType<TInput>> | null
       >,
       ReservedOptions
@@ -86,18 +98,23 @@ interface DefinedTRPCInfiniteQueryOptionsOut<
   TQueryFnData,
   TData,
   TError,
+  TFeatureFlags extends FeatureFlags,
 > extends DistributiveOmit<
       DefinedInitialDataInfiniteOptions<
         TQueryFnData,
         TError,
         TRPCInfiniteData<TInput, TData>,
-        TRPCQueryKey,
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>,
         NonNullable<ExtractCursorType<TInput>> | null
       >,
       'initialPageParam'
     >,
     TRPCQueryOptionsResult {
-  queryKey: DataTag<TRPCQueryKey, TRPCInfiniteData<TInput, TData>, TError>;
+  queryKey: DataTag<
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    TRPCInfiniteData<TInput, TData>,
+    TError
+  >;
   initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
 }
 
@@ -106,12 +123,13 @@ interface UnusedSkipTokenTRPCInfiniteQueryOptionsIn<
   TQueryFnData,
   TData,
   TError,
+  TFeatureFlags extends FeatureFlags,
 > extends DistributiveOmit<
       UnusedSkipTokenInfiniteOptions<
         TQueryFnData,
         TError,
         TRPCInfiniteData<TInput, TData>,
-        TRPCQueryKey,
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>,
         NonNullable<ExtractCursorType<TInput>> | null
       >,
       ReservedOptions
@@ -125,18 +143,23 @@ interface UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
   TQueryFnData,
   TData,
   TError,
+  TFeatureFlags extends FeatureFlags,
 > extends DistributiveOmit<
       UnusedSkipTokenInfiniteOptions<
         TQueryFnData,
         TError,
         TRPCInfiniteData<TInput, TData>,
-        TRPCQueryKey,
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>,
         NonNullable<ExtractCursorType<TInput>> | null
       >,
       'initialPageParam'
     >,
     TRPCQueryOptionsResult {
-  queryKey: DataTag<TRPCQueryKey, TRPCInfiniteData<TInput, TData>, TError>;
+  queryKey: DataTag<
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    TRPCInfiniteData<TInput, TData>,
+    TError
+  >;
   initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
 }
 
@@ -150,7 +173,8 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         transformer: TDef['transformer'];
         errorShape: TDef['errorShape'];
-      }>
+      }>,
+      TDef['featureFlags']
     >,
   ): DefinedTRPCInfiniteQueryOptionsOut<
     TDef['input'],
@@ -159,7 +183,8 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       transformer: TDef['transformer'];
       errorShape: TDef['errorShape'];
-    }>
+    }>,
+    TDef['featureFlags']
   >;
   <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
     input: TDef['input'],
@@ -170,7 +195,8 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         transformer: TDef['transformer'];
         errorShape: TDef['errorShape'];
-      }>
+      }>,
+      TDef['featureFlags']
     >,
   ): UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
     TDef['input'],
@@ -179,7 +205,8 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       transformer: TDef['transformer'];
       errorShape: TDef['errorShape'];
-    }>
+    }>,
+    TDef['featureFlags']
   >;
   <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
     input: TDef['input'] | SkipToken,
@@ -190,7 +217,8 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         transformer: TDef['transformer'];
         errorShape: TDef['errorShape'];
-      }>
+      }>,
+      TDef['featureFlags']
     >,
   ): UndefinedTRPCInfiniteQueryOptionsOut<
     TDef['input'],
@@ -199,34 +227,45 @@ export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       transformer: TDef['transformer'];
       errorShape: TDef['errorShape'];
-    }>
+    }>,
+    TDef['featureFlags']
   >;
 }
 
-type AnyTRPCInfiniteQueryOptionsIn =
-  | DefinedTRPCInfiniteQueryOptionsIn<any, any, any, any>
-  | UnusedSkipTokenTRPCInfiniteQueryOptionsIn<any, any, any, any>
-  | UndefinedTRPCInfiniteQueryOptionsIn<any, any, any, any>;
+type AnyTRPCInfiniteQueryOptionsIn<TFeatureFlags extends FeatureFlags> =
+  | DefinedTRPCInfiniteQueryOptionsIn<any, any, any, any, TFeatureFlags>
+  | UnusedSkipTokenTRPCInfiniteQueryOptionsIn<any, any, any, any, TFeatureFlags>
+  | UndefinedTRPCInfiniteQueryOptionsIn<any, any, any, any, TFeatureFlags>;
 
-type AnyTRPCInfiniteQueryOptionsOut =
-  | DefinedTRPCInfiniteQueryOptionsOut<any, any, any, any>
-  | UnusedSkipTokenTRPCInfiniteQueryOptionsOut<any, any, any, any>
-  | UndefinedTRPCInfiniteQueryOptionsOut<any, any, any, any>;
+type AnyTRPCInfiniteQueryOptionsOut<TFeatureFlags extends FeatureFlags> =
+  | DefinedTRPCInfiniteQueryOptionsOut<any, any, any, any, TFeatureFlags>
+  | UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
+      any,
+      any,
+      any,
+      any,
+      TFeatureFlags
+    >
+  | UndefinedTRPCInfiniteQueryOptionsOut<any, any, any, any, TFeatureFlags>;
 
-export function trpcInfiniteQueryOptions(args: {
+export function trpcInfiniteQueryOptions<
+  TFeatureFlags extends FeatureFlags,
+>(args: {
   input: unknown;
   query: typeof TRPCUntypedClient.prototype.query;
   queryClient: QueryClient | (() => QueryClient);
-  path: readonly string[];
-  queryKey: TRPCQueryKey;
-  opts: AnyTRPCInfiniteQueryOptionsIn;
-}): AnyTRPCInfiniteQueryOptionsOut {
+  path: string[];
+  queryKey: TRPCQueryKey<TFeatureFlags['keyPrefix']>;
+  opts: AnyTRPCInfiniteQueryOptionsIn<TFeatureFlags>;
+}): AnyTRPCInfiniteQueryOptionsOut<TFeatureFlags> {
   const { input, query, path, queryKey, opts } = args;
   const inputIsSkipToken = input === skipToken;
 
-  const queryFn: QueryFunction<unknown, TRPCQueryKey, unknown> = async (
-    queryFnContext,
-  ) => {
+  const queryFn: QueryFunction<
+    unknown,
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    unknown
+  > = async (queryFnContext) => {
     const actualOpts = {
       ...opts,
       trpc: {

package/src/internals/mutationOptions.ts

@@ -9,6 +9,9 @@ import type {
   MaybePromise,
 } from '@trpc/server/unstable-core-do-not-import';
 import type {
+  DefaultFeatureFlags,
+  FeatureFlags,
+  KeyPrefixOptions,
   ResolverDef,
   TRPCMutationKey,
   TRPCQueryBaseOptions,
@@ -23,32 +26,48 @@ import {
 
 type ReservedOptions = 'mutationKey' | 'mutationFn';
 
-interface TRPCMutationOptionsIn<TInput, TError, TOutput, TContext>
-  extends DistributiveOmit<
-      UseMutationOptions<TOutput, TError, TInput, TContext>,
-      ReservedOptions
-    >,
-    TRPCQueryBaseOptions {}
+type TRPCMutationOptionsIn<
+  TInput,
+  TError,
+  TOutput,
+  TContext,
+  TFeatureFlags extends FeatureFlags,
+> = DistributiveOmit<
+  UseMutationOptions<TOutput, TError, TInput, TContext>,
+  ReservedOptions
+> &
+  TRPCQueryBaseOptions &
+  KeyPrefixOptions<TFeatureFlags>;
 
-interface TRPCMutationOptionsOut<TInput, TError, TOutput, TContext>
-  extends UseMutationOptions<TOutput, TError, TInput, TContext>,
+interface TRPCMutationOptionsOut<
+  TInput,
+  TError,
+  TOutput,
+  TContext,
+  TFeatureFlags extends FeatureFlags,
+> extends UseMutationOptions<TOutput, TError, TInput, TContext>,
     TRPCQueryOptionsResult {
-  mutationKey: TRPCMutationKey;
+  mutationKey: TRPCMutationKey<TFeatureFlags['keyPrefix']>;
 }
 
-export interface TRPCMutationOptions<TDef extends ResolverDef> {
+export interface TRPCMutationOptions<
+  TDef extends ResolverDef,
+  TFeatureFlags extends FeatureFlags = DefaultFeatureFlags,
+> {
   <TContext = unknown>(
     opts?: TRPCMutationOptionsIn<
       TDef['input'],
       TRPCClientErrorLike<TDef>,
       TDef['output'],
-      TContext
+      TContext,
+      TFeatureFlags
     >,
   ): TRPCMutationOptionsOut<
     TDef['input'],
     TRPCClientErrorLike<TDef>,
     TDef['output'],
-    TContext
+    TContext,
+    TFeatureFlags
   >;
 }
 
@@ -69,34 +88,29 @@ export interface MutationOptionsOverride {
   }) => MaybePromise<void>;
 }
 
-type AnyTRPCMutationOptionsIn = TRPCMutationOptionsIn<
-  unknown,
-  unknown,
-  unknown,
-  unknown
->;
+type AnyTRPCMutationOptionsIn<TFeatureFlags extends FeatureFlags> =
+  TRPCMutationOptionsIn<unknown, unknown, unknown, unknown, TFeatureFlags>;
 
-type AnyTRPCMutationOptionsOut = TRPCMutationOptionsOut<
-  unknown,
-  unknown,
-  unknown,
-  unknown
->;
+type AnyTRPCMutationOptionsOut<TFeatureFlags extends FeatureFlags> =
+  TRPCMutationOptionsOut<unknown, unknown, unknown, unknown, TFeatureFlags>;
 
 /**
  * @internal
  */
-export function trpcMutationOptions(args: {
+export function trpcMutationOptions<TFeatureFlags extends FeatureFlags>(args: {
   mutate: typeof TRPCUntypedClient.prototype.mutation;
   queryClient: QueryClient | (() => QueryClient);
-  path: readonly string[];
-  opts: AnyTRPCMutationOptionsIn;
+  path: string[];
+  opts: AnyTRPCMutationOptionsIn<TFeatureFlags>;
   overrides: MutationOptionsOverride | undefined;
-}): AnyTRPCMutationOptionsOut {
+}): AnyTRPCMutationOptionsOut<TFeatureFlags> {
   const { mutate, path, opts, overrides } = args;
   const queryClient = unwrapLazyArg(args.queryClient);
 
-  const mutationKey = getMutationKeyInternal(path);
+  const mutationKey = getMutationKeyInternal({
+    path,
+    prefix: opts.keyPrefix,
+  }) as TRPCMutationKey<TFeatureFlags['keyPrefix']>;
 
   const defaultOpts = queryClient.defaultMutationOptions(
     queryClient.getMutationDefaults(mutationKey),
@@ -106,14 +120,16 @@ export function trpcMutationOptions(args: {
     overrides?.onSuccess ?? ((options) => options.originalFn());
 
   const mutationFn: MutationFunction = async (input) => {
-    const result = await mutate(...getClientArgs([path, { input }], opts));
+    const result = await mutate(
+      ...getClientArgs([...mutationKey, { input }] as any, opts),
+    );
 
     return result;
   };
 
   return {
     ...opts,
-    mutationKey: mutationKey,
+    mutationKey,
     mutationFn,
     onSuccess(...args) {
       const originalFn = () =>

package/src/internals/queryOptions.ts

@@ -15,6 +15,8 @@ import type {
 } from '@trpc/server/unstable-core-do-not-import';
 import { isAsyncIterable } from '@trpc/server/unstable-core-do-not-import';
 import type {
+  DefaultFeatureFlags,
+  FeatureFlags,
   ResolverDef,
   TRPCQueryBaseOptions,
   TRPCQueryKey,
@@ -29,76 +31,115 @@ import {
 
 type ReservedOptions = 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash';
 
-interface UndefinedTRPCQueryOptionsIn<TQueryFnData, TData, TError>
-  extends DistributiveOmit<
+interface UndefinedTRPCQueryOptionsIn<
+  TQueryFnData,
+  TData,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends DistributiveOmit<
       UndefinedInitialDataOptions<
         coerceAsyncIterableToArray<TQueryFnData>,
         TError,
         coerceAsyncIterableToArray<TData>,
-        TRPCQueryKey
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>
       >,
       ReservedOptions
     >,
     TRPCQueryBaseOptions {}
 
-interface UndefinedTRPCQueryOptionsOut<TQueryFnData, TOutput, TError>
-  extends UndefinedInitialDataOptions<
+interface UndefinedTRPCQueryOptionsOut<
+  TQueryFnData,
+  TOutput,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends UndefinedInitialDataOptions<
       coerceAsyncIterableToArray<TQueryFnData>,
       TError,
       coerceAsyncIterableToArray<TOutput>,
-      TRPCQueryKey
+      TRPCQueryKey<TFeatureFlags['keyPrefix']>
     >,
     TRPCQueryOptionsResult {
-  queryKey: DataTag<TRPCQueryKey, coerceAsyncIterableToArray<TOutput>, TError>;
+  queryKey: DataTag<
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    coerceAsyncIterableToArray<TOutput>,
+    TError
+  >;
 }
 
-interface DefinedTRPCQueryOptionsIn<TQueryFnData, TData, TError>
-  extends DistributiveOmit<
+interface DefinedTRPCQueryOptionsIn<
+  TQueryFnData,
+  TData,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends DistributiveOmit<
       DefinedInitialDataOptions<
         coerceAsyncIterableToArray<NoInfer<TQueryFnData>>,
         TError,
         coerceAsyncIterableToArray<TData>,
-        TRPCQueryKey
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>
       >,
       ReservedOptions
     >,
     TRPCQueryBaseOptions {}
 
-interface DefinedTRPCQueryOptionsOut<TQueryFnData, TData, TError>
-  extends DefinedInitialDataOptions<
+interface DefinedTRPCQueryOptionsOut<
+  TQueryFnData,
+  TData,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends DefinedInitialDataOptions<
       coerceAsyncIterableToArray<TQueryFnData>,
       TError,
       coerceAsyncIterableToArray<TData>,
-      TRPCQueryKey
+      TRPCQueryKey<TFeatureFlags['keyPrefix']>
     >,
     TRPCQueryOptionsResult {
-  queryKey: DataTag<TRPCQueryKey, coerceAsyncIterableToArray<TData>, TError>;
+  queryKey: DataTag<
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    coerceAsyncIterableToArray<TData>,
+    TError
+  >;
 }
 
-interface UnusedSkipTokenTRPCQueryOptionsIn<TQueryFnData, TData, TError>
-  extends DistributiveOmit<
+interface UnusedSkipTokenTRPCQueryOptionsIn<
+  TQueryFnData,
+  TData,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends DistributiveOmit<
       UnusedSkipTokenOptions<
         coerceAsyncIterableToArray<TQueryFnData>,
         TError,
         coerceAsyncIterableToArray<TData>,
-        TRPCQueryKey
+        TRPCQueryKey<TFeatureFlags['keyPrefix']>
       >,
       ReservedOptions
     >,
     TRPCQueryBaseOptions {}
 
-interface UnusedSkipTokenTRPCQueryOptionsOut<TQueryFnData, TOutput, TError>
-  extends UnusedSkipTokenOptions<
+interface UnusedSkipTokenTRPCQueryOptionsOut<
+  TQueryFnData,
+  TOutput,
+  TError,
+  TFeatureFlags extends FeatureFlags,
+> extends UnusedSkipTokenOptions<
       coerceAsyncIterableToArray<TQueryFnData>,
       TError,
       coerceAsyncIterableToArray<TOutput>,
-      TRPCQueryKey
+      TRPCQueryKey<TFeatureFlags['keyPrefix']>
     >,
     TRPCQueryOptionsResult {
-  queryKey: DataTag<TRPCQueryKey, coerceAsyncIterableToArray<TOutput>, TError>;
+  queryKey: DataTag<
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>,
+    coerceAsyncIterableToArray<TOutput>,
+    TError
+  >;
 }
 
-export interface TRPCQueryOptions<TDef extends ResolverDef> {
+export interface TRPCQueryOptions<
+  TDef extends ResolverDef,
+  TFeatureFlags extends FeatureFlags = DefaultFeatureFlags,
+> {
   <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
     input: TDef['input'] | SkipToken,
     opts: DefinedTRPCQueryOptionsIn<
@@ -107,7 +148,8 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         transformer: TDef['transformer'];
         errorShape: TDef['errorShape'];
-      }>
+      }>,
+      TFeatureFlags
     >,
   ): DefinedTRPCQueryOptionsOut<
     TQueryFnData,
@@ -115,7 +157,8 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       transformer: TDef['transformer'];
       errorShape: TDef['errorShape'];
-    }>
+    }>,
+    TFeatureFlags
   >;
   <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
     input: TDef['input'],
@@ -125,7 +168,8 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         transformer: TDef['transformer'];
         errorShape: TDef['errorShape'];
-      }>
+      }>,
+      TFeatureFlags
     >,
   ): UnusedSkipTokenTRPCQueryOptionsOut<
     TQueryFnData,
@@ -133,7 +177,8 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       transformer: TDef['transformer'];
       errorShape: TDef['errorShape'];
-    }>
+    }>,
+    TFeatureFlags
   >;
   <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
     input: TDef['input'] | SkipToken,
@@ -143,7 +188,8 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         transformer: TDef['transformer'];
         errorShape: TDef['errorShape'];
-      }>
+      }>,
+      TFeatureFlags
     >,
   ): UndefinedTRPCQueryOptionsOut<
     TQueryFnData,
@@ -151,39 +197,43 @@ export interface TRPCQueryOptions<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       transformer: TDef['transformer'];
       errorShape: TDef['errorShape'];
-    }>
+    }>,
+    TFeatureFlags
   >;
 }
 
-type AnyTRPCQueryOptionsIn =
-  | DefinedTRPCQueryOptionsIn<unknown, unknown, unknown>
-  | UnusedSkipTokenTRPCQueryOptionsIn<unknown, unknown, unknown>
-  | UndefinedTRPCQueryOptionsIn<unknown, unknown, unknown>;
+type AnyTRPCQueryOptionsIn<TFeatureFlags extends FeatureFlags> =
+  | DefinedTRPCQueryOptionsIn<unknown, unknown, unknown, TFeatureFlags>
+  | UnusedSkipTokenTRPCQueryOptionsIn<unknown, unknown, unknown, TFeatureFlags>
+  | UndefinedTRPCQueryOptionsIn<unknown, unknown, unknown, TFeatureFlags>;
 
-type AnyTRPCQueryOptionsOut =
-  | DefinedTRPCQueryOptionsOut<unknown, unknown, unknown>
-  | UnusedSkipTokenTRPCQueryOptionsOut<unknown, unknown, unknown>
-  | UndefinedTRPCQueryOptionsOut<unknown, unknown, unknown>;
+type AnyTRPCQueryOptionsOut<
+  TFeatureFlags extends FeatureFlags = DefaultFeatureFlags,
+> =
+  | DefinedTRPCQueryOptionsOut<unknown, unknown, unknown, TFeatureFlags>
+  | UnusedSkipTokenTRPCQueryOptionsOut<unknown, unknown, unknown, TFeatureFlags>
+  | UndefinedTRPCQueryOptionsOut<unknown, unknown, unknown, TFeatureFlags>;
 
 /**
  * @internal
  */
-export function trpcQueryOptions(args: {
+export function trpcQueryOptions<TFeatureFlags extends FeatureFlags>(args: {
   input: unknown;
   query: typeof TRPCUntypedClient.prototype.query;
   queryClient: QueryClient | (() => QueryClient);
-  path: readonly string[];
-  queryKey: TRPCQueryKey;
-  opts: AnyTRPCQueryOptionsIn;
-}): AnyTRPCQueryOptionsOut {
+  path: string[];
+  queryKey: TRPCQueryKey<TFeatureFlags['keyPrefix']>;
+  opts: AnyTRPCQueryOptionsIn<TFeatureFlags>;
+}): AnyTRPCQueryOptionsOut<TFeatureFlags> {
   const { input, query, path, queryKey, opts } = args;
   const queryClient = unwrapLazyArg(args.queryClient);
 
   const inputIsSkipToken = input === skipToken;
 
-  const queryFn: QueryFunction<unknown, TRPCQueryKey> = async (
-    queryFnContext,
-  ) => {
+  const queryFn: QueryFunction<
+    unknown,
+    TRPCQueryKey<TFeatureFlags['keyPrefix']>
+  > = async (queryFnContext) => {
     const actualOpts = {
       ...opts,
       trpc: {
@@ -207,7 +257,7 @@ export function trpcQueryOptions(args: {
   return Object.assign(
     queryOptions({
       ...opts,
-      queryKey,
+      queryKey: queryKey,
       queryFn: inputIsSkipToken ? skipToken : queryFn,
     }),
     { trpc: createTRPCOptionsResult({ path }) },