@trpc/tanstack-react-query 0.0.0-alpha.0

package/src/internals/createOptionsProxy.ts

@@ -0,0 +1,309 @@
+import { type QueryClient, type QueryFilters } from '@tanstack/react-query';
+import {
+  getUntypedClient,
+  TRPCUntypedClient,
+  type CreateTRPCClient,
+  type TRPCRequestOptions,
+} from '@trpc/client';
+import {
+  callProcedure,
+  type AnyProcedure,
+  type inferProcedureInput,
+  type inferRouterContext,
+  type inferTransformedProcedureOutput,
+  type ProcedureType,
+} from '@trpc/server';
+import { createRecursiveProxy } from '@trpc/server/unstable-core-do-not-import';
+import type {
+  AnyRootTypes,
+  AnyRouter,
+  MaybePromise,
+  RouterRecord,
+} from '@trpc/server/unstable-core-do-not-import';
+import {
+  trpcInfiniteQueryOptions,
+  type TRPCInfiniteQueryOptions,
+} from './infiniteQueryOptions';
+import type { MutationOptionsOverride } from './mutationOptions';
+import {
+  trpcMutationOptions,
+  type TRPCMutationOptions,
+} from './mutationOptions';
+import { trpcQueryOptions, type TRPCQueryOptions } from './queryOptions';
+import {
+  trpcSubscriptionOptions,
+  type TRPCSubscriptionOptions,
+} from './subscriptionOptions';
+import type {
+  QueryType,
+  ResolverDef,
+  TRPCMutationKey,
+  TRPCQueryKey,
+} from './types';
+import {
+  getMutationKeyInternal,
+  getQueryKeyInternal,
+  unwrapLazyArg,
+} from './utils';
+
+export interface DecorateQueryKeyable {
+  /**
+   * Calculate the Tanstack Query Key for a Route
+   *
+   * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-keys
+   */
+  queryKey: () => TRPCQueryKey;
+
+  /**
+   * Calculate a Tanstack Query Filter for a Route
+   *
+   * @see https://tanstack.com/query/latest/docs/framework/react/guides/filters
+   */
+  queryFilter: () => QueryFilters;
+}
+
+export type InferInput<
+  TProcedure extends
+    | DecorateQueryProcedure<any>
+    | DecorateMutationProcedure<any>,
+> = TProcedure['~types']['input'];
+
+export type InferOutput<
+  TProcedure extends
+    | DecorateQueryProcedure<any>
+    | DecorateMutationProcedure<any>,
+> = TProcedure['~types']['output'];
+
+export interface DecorateQueryProcedure<TDef extends ResolverDef> {
+  /**
+   * @internal prefer using InferInput and InferOutput to access types
+   */
+  '~types': {
+    input: TDef['input'];
+    output: TDef['output'];
+  };
+
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/queryOptions#queryoptions
+   */
+  queryOptions: TRPCQueryOptions<TDef>;
+
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/infiniteQueryOptions#infinitequeryoptions
+   */
+  infiniteQueryOptions: TRPCInfiniteQueryOptions<TDef>;
+
+  /**
+   * Calculate the Tanstack Query Key for a Query Procedure
+   *
+   * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-keys
+   */
+  queryKey: (input?: TDef['input']) => TRPCQueryKey;
+
+  /**
+   * Calculate a Tanstack Query Filter for a Query Procedure
+   *
+   * @see https://tanstack.com/query/latest/docs/framework/react/guides/filters
+   */
+  queryFilter: (input?: TDef['input']) => QueryFilters;
+}
+
+export interface DecorateMutationProcedure<TDef extends ResolverDef> {
+  /**
+   * @internal prefer using InferInput and InferOutput to access types
+   */
+  '~types': {
+    input: TDef['input'];
+    output: TDef['output'];
+  };
+
+  /**
+   * @see
+   */
+  mutationOptions: TRPCMutationOptions<TDef>;
+
+  /**
+   * Calculate the Tanstack Mutation Key for a Mutation Procedure
+   */
+  mutationKey: () => TRPCMutationKey;
+}
+
+export interface DecorateSubscriptionProcedure<TDef extends ResolverDef> {
+  /**
+   * @see
+   */
+  subscriptionOptions: TRPCSubscriptionOptions<TDef>;
+}
+
+export type DecorateProcedure<
+  TType extends ProcedureType,
+  TDef extends ResolverDef,
+> = TType extends 'query'
+  ? DecorateQueryProcedure<TDef>
+  : TType extends 'mutation'
+    ? DecorateMutationProcedure<TDef>
+    : TType extends 'subscription'
+      ? DecorateSubscriptionProcedure<TDef>
+      : never;
+
+/**
+ * @internal
+ */
+export type DecoratedProcedureUtilsRecord<
+  TRoot extends AnyRootTypes,
+  TRecord extends RouterRecord,
+> = {
+  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
+    ? $Value extends RouterRecord
+      ? DecoratedProcedureUtilsRecord<TRoot, $Value> & DecorateQueryKeyable
+      : $Value extends AnyProcedure
+        ? DecorateProcedure<
+            $Value['_def']['type'],
+            {
+              input: inferProcedureInput<$Value>;
+              output: inferTransformedProcedureOutput<TRoot, $Value>;
+              transformer: TRoot['transformer'];
+              errorShape: TRoot['errorShape'];
+            }
+          >
+        : never
+    : never;
+};
+
+export type TRPCOptionsProxy<TRouter extends AnyRouter> =
+  DecoratedProcedureUtilsRecord<
+    TRouter['_def']['_config']['$types'],
+    TRouter['_def']['record']
+  > &
+    DecorateQueryKeyable;
+
+export interface TRPCOptionsProxyOptionsBase {
+  queryClient: QueryClient | (() => QueryClient);
+  overrides?: {
+    mutations?: MutationOptionsOverride;
+  };
+}
+
+export interface TRPCOptionsProxyOptionsInternal<TRouter extends AnyRouter> {
+  router: TRouter;
+  ctx:
+    | inferRouterContext<TRouter>
+    | (() => MaybePromise<inferRouterContext<TRouter>>);
+}
+
+export interface TRPCOptionsProxyOptionsExternal<TRouter extends AnyRouter> {
+  client: TRPCUntypedClient<TRouter> | CreateTRPCClient<TRouter>;
+}
+
+export type TRPCOptionsProxyOptions<TRouter extends AnyRouter> =
+  TRPCOptionsProxyOptionsBase &
+    (
+      | TRPCOptionsProxyOptionsInternal<TRouter>
+      | TRPCOptionsProxyOptionsExternal<TRouter>
+    );
+
+type UtilsMethods =
+  | keyof DecorateQueryProcedure<any>
+  | keyof DecorateMutationProcedure<any>
+  | keyof DecorateSubscriptionProcedure<any>;
+
+function getQueryType(method: UtilsMethods) {
+  const map: Partial<Record<UtilsMethods, QueryType>> = {
+    queryOptions: 'query',
+    infiniteQueryOptions: 'infinite',
+    subscriptionOptions: 'any',
+    mutationOptions: 'any',
+  };
+
+  return map[method];
+}
+
+export function createTRPCOptionsProxy<TRouter extends AnyRouter>(
+  opts: TRPCOptionsProxyOptions<TRouter>,
+): TRPCOptionsProxy<TRouter> {
+  const callIt = (type: ProcedureType): any => {
+    return (path: string, input: unknown, trpcOpts: TRPCRequestOptions) => {
+      if ('router' in opts) {
+        return Promise.resolve(unwrapLazyArg(opts.ctx)).then((ctx) =>
+          callProcedure({
+            procedures: opts.router._def.procedures,
+            path: path,
+            getRawInput: async () => input,
+            ctx: ctx,
+            type: type,
+            signal: undefined,
+          }),
+        );
+      }
+
+      const untypedClient =
+        opts.client instanceof TRPCUntypedClient
+          ? opts.client
+          : getUntypedClient(opts.client);
+
+      return untypedClient[type](path, input, trpcOpts);
+    };
+  };
+
+  return createRecursiveProxy(({ args, path: _path }) => {
+    const path = [..._path];
+    const utilName = path.pop() as UtilsMethods;
+    const [arg1, arg2] = args as any[];
+
+    const queryType = getQueryType(utilName);
+    const queryKey = getQueryKeyInternal(path, arg1, queryType ?? 'any');
+
+    const contextMap: Record<UtilsMethods, () => unknown> = {
+      '~types': undefined as any,
+
+      mutationKey: () => {
+        return getMutationKeyInternal(path);
+      },
+      queryKey: () => {
+        return queryKey;
+      },
+      queryFilter: (): QueryFilters => {
+        return {
+          queryKey: queryKey,
+        };
+      },
+      infiniteQueryOptions: () => {
+        return trpcInfiniteQueryOptions({
+          opts: arg2,
+          path,
+          queryClient: opts.queryClient,
+          queryKey: queryKey,
+          query: callIt('query'),
+        });
+      },
+      queryOptions: () => {
+        return trpcQueryOptions({
+          opts: arg2,
+          path,
+          queryClient: opts.queryClient,
+          queryKey: queryKey,
+          query: callIt('query'),
+        });
+      },
+      mutationOptions: () => {
+        return trpcMutationOptions({
+          opts: arg1,
+          path,
+          queryClient: opts.queryClient,
+          mutate: callIt('mutation'),
+          overrides: opts.overrides?.mutations,
+        });
+      },
+      subscriptionOptions: () => {
+        return trpcSubscriptionOptions({
+          opts: arg2,
+          path,
+          queryKey: queryKey,
+          subscribe: callIt('subscription'),
+        });
+      },
+    };
+
+    return contextMap[utilName]();
+  });
+}

package/src/internals/infiniteQueryOptions.ts

@@ -0,0 +1,233 @@
+import type {
+  DataTag,
+  DefinedInitialDataInfiniteOptions,
+  InfiniteData,
+  QueryFunction,
+  UndefinedInitialDataInfiniteOptions,
+  UnusedSkipTokenInfiniteOptions,
+} from '@tanstack/react-query';
+import {
+  infiniteQueryOptions,
+  skipToken,
+  type QueryClient,
+  type 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 {
+  ExtractCursorType,
+  ResolverDef,
+  TRPCQueryBaseOptions,
+  TRPCQueryKey,
+  TRPCQueryOptionsResult,
+} from './types';
+import { createTRPCOptionsResult, getClientArgs } from './utils';
+
+type ReservedOptions =
+  | 'queryKey'
+  | 'queryFn'
+  | 'queryHashFn'
+  | 'queryHash'
+  | 'initialPageParam';
+
+interface UndefinedTRPCInfiniteQueryOptionsIn<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UndefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      ReservedOptions
+    >,
+    TRPCQueryBaseOptions {
+  initialCursor?: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+interface UndefinedTRPCInfiniteQueryOptionsOut<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UndefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      'initialPageParam'
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, TData>;
+  initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+interface DefinedTRPCInfiniteQueryOptionsIn<TInput, TQueryFnData, TData, TError>
+  extends DistributiveOmit<
+      DefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      ReservedOptions
+    >,
+    TRPCQueryBaseOptions {
+  initialCursor?: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+interface DefinedTRPCInfiniteQueryOptionsOut<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      DefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      'initialPageParam'
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, TData>;
+  initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+interface UnusedSkipTokenTRPCInfiniteQueryOptionsIn<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UnusedSkipTokenInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      ReservedOptions
+    >,
+    TRPCQueryBaseOptions {
+  initialCursor?: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+interface UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UnusedSkipTokenInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      'initialPageParam'
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, TData>;
+  initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+export interface TRPCInfiniteQueryOptions<TDef extends ResolverDef> {
+  <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
+    input: TDef['input'] | SkipToken,
+    opts: DefinedTRPCInfiniteQueryOptionsIn<
+      TDef['input'],
+      TQueryFnData,
+      TData,
+      TRPCClientErrorLike<TDef>
+    >,
+  ): DefinedTRPCInfiniteQueryOptionsOut<
+    TDef['input'],
+    TQueryFnData,
+    TData,
+    TRPCClientErrorLike<TDef>
+  >;
+  <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
+    input: TDef['input'],
+    opts: UnusedSkipTokenTRPCInfiniteQueryOptionsIn<
+      TDef['input'],
+      TQueryFnData,
+      TData,
+      TRPCClientErrorLike<TDef>
+    >,
+  ): UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
+    TDef['input'],
+    TQueryFnData,
+    TData,
+    TRPCClientErrorLike<TDef>
+  >;
+  <TQueryFnData extends TDef['output'], TData = TQueryFnData>(
+    input: TDef['input'] | SkipToken,
+    opts?: UndefinedTRPCInfiniteQueryOptionsIn<
+      TDef['input'],
+      TQueryFnData,
+      TData,
+      TRPCClientErrorLike<TDef>
+    >,
+  ): UndefinedTRPCInfiniteQueryOptionsOut<
+    TDef['input'],
+    TQueryFnData,
+    TData,
+    TRPCClientErrorLike<TDef>
+  >;
+}
+
+export function trpcInfiniteQueryOptions(args: {
+  query: typeof TRPCUntypedClient.prototype.query;
+  queryClient: QueryClient | (() => QueryClient);
+  path: readonly string[];
+  queryKey: TRPCQueryKey;
+  opts: UndefinedTRPCInfiniteQueryOptionsIn<unknown, unknown, unknown, unknown>;
+}) {
+  const { query, path, queryKey, opts } = args;
+  const inputIsSkipToken = queryKey[1]?.input === skipToken;
+
+  const queryFn: QueryFunction<unknown, TRPCQueryKey, unknown> = async (
+    queryFnContext,
+  ) => {
+    const actualOpts = {
+      ...opts,
+      trpc: {
+        ...opts?.trpc,
+        ...(opts?.trpc?.abortOnUnmount
+          ? { signal: queryFnContext.signal }
+          : { signal: null }),
+      },
+    };
+
+    const result = await query(
+      ...getClientArgs(queryKey, actualOpts, {
+        direction: queryFnContext.direction,
+        pageParam: queryFnContext.pageParam,
+      }),
+    );
+
+    return result;
+  };
+
+  return Object.assign(
+    infiniteQueryOptions({
+      ...opts,
+      queryKey,
+      queryFn: inputIsSkipToken ? skipToken : queryFn,
+      initialPageParam: opts?.initialCursor ?? null,
+    }),
+    { trpc: createTRPCOptionsResult({ path }) },
+  );
+}

package/src/internals/mutationOptions.ts

@@ -0,0 +1,113 @@
+import type { MutationFunction } from '@tanstack/react-query';
+import {
+  type QueryClient,
+  type UseMutationOptions,
+} from '@tanstack/react-query';
+import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
+import type {
+  DistributiveOmit,
+  MaybePromise,
+} from '@trpc/server/unstable-core-do-not-import';
+import type {
+  ResolverDef,
+  TRPCMutationKey,
+  TRPCQueryBaseOptions,
+  TRPCQueryOptionsResult,
+} from './types';
+import {
+  createTRPCOptionsResult,
+  getClientArgs,
+  getMutationKeyInternal,
+  unwrapLazyArg,
+} from './utils';
+
+type ReservedOptions = 'mutationKey' | 'mutationFn';
+
+interface TRPCMutationOptionsIn<TInput, TError, TOutput, TContext>
+  extends DistributiveOmit<
+      UseMutationOptions<TOutput, TError, TInput, TContext>,
+      ReservedOptions
+    >,
+    TRPCQueryBaseOptions {}
+
+interface TRPCMutationOptionsOut<TInput, TError, TOutput, TContext>
+  extends UseMutationOptions<TOutput, TError, TInput, TContext>,
+    TRPCQueryOptionsResult {
+  mutationKey: TRPCMutationKey;
+}
+
+export interface TRPCMutationOptions<TDef extends ResolverDef> {
+  <TContext = unknown>(
+    opts?: TRPCMutationOptionsIn<
+      TDef['input'],
+      TRPCClientErrorLike<TDef>,
+      TDef['output'],
+      TContext
+    >,
+  ): TRPCMutationOptionsOut<
+    TDef['input'],
+    TRPCClientErrorLike<TDef>,
+    TDef['output'],
+    TContext
+  >;
+}
+
+/**
+ * @internal
+ */
+export interface MutationOptionsOverride {
+  onSuccess: (opts: {
+    /**
+     * Calls the original function that was defined in the query's `onSuccess` option
+     */
+    originalFn: () => MaybePromise<unknown>;
+    queryClient: QueryClient;
+    /**
+     * Meta data passed in from the `useMutation()` hook
+     */
+    meta: Record<string, unknown>;
+  }) => MaybePromise<unknown>;
+}
+
+export function trpcMutationOptions(args: {
+  mutate: typeof TRPCUntypedClient.prototype.mutation;
+  queryClient: QueryClient | (() => QueryClient);
+  path: readonly string[];
+  opts: TRPCMutationOptionsIn<unknown, unknown, unknown, unknown> | undefined;
+  overrides: MutationOptionsOverride | undefined;
+}): TRPCMutationOptionsOut<unknown, unknown, unknown, unknown> {
+  const { mutate, path, opts, overrides } = args;
+  const queryClient = unwrapLazyArg(args.queryClient);
+
+  const mutationKey = getMutationKeyInternal(path);
+
+  const defaultOpts = queryClient.defaultMutationOptions(
+    queryClient.getMutationDefaults(mutationKey),
+  );
+
+  const mutationSuccessOverride: MutationOptionsOverride['onSuccess'] =
+    overrides?.onSuccess ?? ((options) => options.originalFn());
+
+  const mutationFn: MutationFunction = async (input) => {
+    const result = await mutate(...getClientArgs([path, { input }], opts));
+
+    return result;
+  };
+
+  return {
+    ...opts,
+    mutationKey: mutationKey,
+    mutationFn,
+    onSuccess(...args) {
+      const originalFn = () =>
+        opts?.onSuccess?.(...args) ?? defaultOpts?.onSuccess?.(...args);
+
+      return mutationSuccessOverride({
+        originalFn,
+        queryClient,
+        meta: opts?.meta ?? defaultOpts?.meta ?? {},
+      });
+    },
+    trpc: createTRPCOptionsResult({ path }),
+  };
+}