feat: hoist createContext one level up

examples/.experimental/next-app-dir/src/trpc/server-http.ts

@@ -7,12 +7,12 @@ import { getUrl } from './shared';
 import { createContext } from './shared-server';
 
 export const api = experimental_createTRPCNextAppDirServer<AppRouter>({
-  createContext,
   config() {
     return {
+      createContext,
       links: [
         loggerLink({
-          enabled: (op) => true,
+          enabled: (_op) => true,
         }),
         httpBatchLink({
           url: getUrl(),

examples/.experimental/next-app-dir/src/trpc/server-invoker.ts

@@ -9,9 +9,9 @@ import { createContext } from './shared-server';
  * This client invokes procedures directly on the server without fetching over HTTP.
  */
 export const api = experimental_createTRPCNextAppDirServer<typeof appRouter>({
-  createContext,
   config() {
     return {
+      createContext,
       links: [
         loggerLink({
           enabled: (op) => true,
@@ -23,7 +23,6 @@ export const api = experimental_createTRPCNextAppDirServer<typeof appRouter>({
           transformer: superjson,
           // include the user id in the cache key
           cacheContext: (ctx) => [ctx.session?.user.id],
-          createContext,
         }),
       ],
     };

packages/client/src/TRPCClientError.ts

@@ -11,7 +11,7 @@ import {
 } from '@trpc/server/unstable-core-do-not-import';
 
 type inferErrorShape<TInferrable extends InferrableClientTypes> =
-  inferClientTypes<TInferrable>['errorShape'];
+inferClientTypes<TInferrable>['errorShape'];
 export interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
   readonly message: string;
   readonly shape: Maybe<TShape>;
@@ -86,6 +86,7 @@ export class TRPCClientError<TRouterOrProcedure extends InferrableClientTypes>
   ): TRPCClientError<TRouterOrProcedure> {
     const cause = _cause as unknown;
 
+
     if (isTRPCClientError(cause)) {
       if (opts.meta) {
         // Decorate with meta error data

packages/client/src/createTRPCClient.ts

@@ -34,6 +34,7 @@ type ResolverDef = {
   output: any;
   transformer: boolean;
   errorShape: any;
+  ctx: any;
 };
 
 /** @internal */
@@ -86,6 +87,7 @@ type DecoratedProcedureRecord<
               inferClientTypes<TRouter>,
               $Value
             >;
+            ctx: inferClientTypes<TRouter>['ctx'];
             errorShape: inferClientTypes<TRouter>['errorShape'];
             transformer: inferClientTypes<TRouter>['transformer'];
           }

packages/client/src/internals/TRPCUntypedClient.ts

@@ -5,6 +5,7 @@ import type {
 import { observableToPromise, share } from '@trpc/server/observable';
 import type {
   AnyRouter,
+  inferClientTypes,
   InferrableClientTypes,
   TypeError,
 } from '@trpc/server/unstable-core-do-not-import';
@@ -35,8 +36,9 @@ export interface TRPCSubscriptionObserver<TValue, TError> {
 }
 
 /** @internal */
-export type CreateTRPCClientOptions<TRouter extends InferrableClientTypes> = {
-  links: TRPCLink<TRouter>[];
+export type CreateTRPCClientOptions<TInferrable extends InferrableClientTypes> = {
+  links: TRPCLink<TInferrable>[];
+  createContext?: () => Promise<inferClientTypes<TInferrable>['ctx']>;
   transformer?: TypeError<'The transformer property has moved to httpLink/httpBatchLink/wsLink'>;
 };
 
@@ -53,13 +55,13 @@ export type UntypedClientProperties =
 
 export class TRPCUntypedClient<TRouter extends AnyRouter> {
   private readonly links: OperationLink<AnyRouter>[];
-  public readonly runtime: TRPCClientRuntime;
+  public readonly runtime: TRPCClientRuntime<TRouter>;
   private requestId: number;
 
   constructor(opts: CreateTRPCClientOptions<TRouter>) {
     this.requestId = 0;
 
-    this.runtime = {};
+    this.runtime = {createContext: opts.createContext};
 
     // Initialize the links
     this.links = opts.links.map((link) => link(this.runtime));

packages/client/src/links/internals/createHTTPBatchLink.ts

@@ -23,7 +23,7 @@ import { getUrl, resolveHTTPLinkOptions } from './httpUtils';
  */
 export type RequesterFn<TOptions extends HTTPBatchLinkOptions<AnyRootTypes>> = (
   requesterOpts: ResolvedHTTPLinkOptions & {
-    runtime: TRPCClientRuntime;
+    runtime: TRPCClientRuntime<AnyRouter>;
     type: ProcedureType;
     opts: TOptions;
   },

packages/client/src/links/types.ts

@@ -3,6 +3,7 @@ import type {
   InferrableClientTypes,
   TRPCResultMessage,
   TRPCSuccessResponse,
+  inferClientTypes,
 } from '@trpc/server/unstable-core-do-not-import';
 import type { ResponseEsque } from '../internals/types';
 import type { TRPCClientError } from '../TRPCClientError';
@@ -56,8 +57,8 @@ export type TRPCFetch = (
   options?: RequestInit,
 ) => Promise<ResponseEsque>;
 
-export interface TRPCClientRuntime {
-  // nothing here anymore
+export interface TRPCClientRuntime<TInferrable extends InferrableClientTypes> {
+  createContext?: () => Promise<inferClientTypes<TInferrable>['ctx']>
 }
 
 /**
@@ -104,5 +105,5 @@ export type OperationLink<
  * @public
  */
 export type TRPCLink<TInferrable extends InferrableClientTypes> = (
-  opts: TRPCClientRuntime,
+  opts: TRPCClientRuntime<TInferrable>,
 ) => OperationLink<TInferrable>;

packages/next/src/app-dir/links/nextCache.ts

@@ -23,7 +23,6 @@ type NextCacheLinkOptions<TRouter extends AnyRouter> = {
    * key
    */
   cacheContext: ((ctx: inferRouterContext<TRouter>) => any[]) | undefined;
-  createContext: () => Promise<inferRouterContext<TRouter>>;
   /** how many seconds the cache should hold before revalidating */
   revalidate?: number | false;
 } & TransformerOptions<inferClientTypes<TRouter>>;
@@ -33,8 +32,11 @@ export function experimental_nextCacheLink<TRouter extends AnyRouter>(
   opts: NextCacheLinkOptions<TRouter>,
 ): TRPCLink<TRouter> {
   const transformer = getTransformer(opts.transformer);
-  return () =>
-    ({ op }) =>
+  return ({createContext}) =>{
+    if (!createContext) 
+    throw new Error('\`createContext\` is required to be passed to use \`experimental_nextCacheLink\`.')
+
+    return ({ op }) =>
       observable((observer) => {
         const { path, input, type, context } = op;
 
@@ -46,8 +48,7 @@ export function experimental_nextCacheLink<TRouter extends AnyRouter>(
             : undefined;
         const revalidate = requestRevalidate ?? opts.revalidate ?? false;
 
-        const promise = opts
-          .createContext()
+        const promise = createContext()
           .then(async (ctx) => {
             const cacheTag = await generateCacheTag(
               path,
@@ -94,4 +95,5 @@ export function experimental_nextCacheLink<TRouter extends AnyRouter>(
             observer.error(TRPCClientError.from(cause));
           });
       });
+    }
 }

packages/next/src/app-dir/server.ts

@@ -51,10 +51,11 @@ export function experimental_createTRPCNextAppDirServer<
     const procedurePath = pathCopy.join('.');
     const procedureType = clientCallTypeToProcedureType(action);
 
+
     const cacheTag = await generateCacheTag(
       procedurePath,
       callOpts.args[0],
-      await opts.createContext(),
+      await client.runtime.createContext?.(),
     );
 
     if (action === 'revalidate') {

packages/next/src/app-dir/shared.ts

@@ -10,7 +10,6 @@ import type {
   AnyRootTypes,
   AnyRouter,
   inferProcedureInput,
-  inferRouterContext,
   inferTransformedProcedureOutput,
   ProtectedIntersection,
   RouterRecord,
@@ -33,6 +32,7 @@ export type UseProcedureRecord<
           output: inferTransformedProcedureOutput<TRoot, $Value>;
           errorShape: TRoot['errorShape'];
           transformer: TRoot['transformer'];
+          ctx: TRoot['ctx'];
         }>
       : never
     : never;
@@ -88,7 +88,6 @@ export type CreateTRPCNextAppRouter<TRouter extends AnyRouter> =
  */
 export interface CreateTRPCNextAppRouterOptions<TRouter extends AnyRouter> {
   config: () => CreateTRPCClientOptions<TRouter>;
-  createContext: () => Promise<inferRouterContext<TRouter>>;
 }
 
 /**

packages/next/src/app-dir/types.ts

@@ -13,6 +13,7 @@ type ResolverDef = {
   output: any;
   transformer: boolean;
   errorShape: any;
+  ctx: any;
 };
 
 export type DecorateProcedureServer<
@@ -52,6 +53,7 @@ export type NextAppDirDecorateRouterRecord<
             output: inferTransformedProcedureOutput<TRoot, $Value>;
             errorShape: TRoot['errorShape'];
             transformer: TRoot['transformer'];
+            ctx: TRoot['ctx'];
           }
         >
       : never

packages/next/src/ssrPrepass.ts

@@ -16,10 +16,11 @@ import type {
 } from '@trpc/server/unstable-core-do-not-import';
 import type {
   AppContextType,
+  NextComponentType,
   NextPageContext,
 } from 'next/dist/shared/lib/utils';
 import { createElement } from 'react';
-import type { TRPCPrepassHelper, TRPCPrepassProps } from './withTRPC';
+import type { TRPCPrepassHelper, TRPCPrepassProps, WithTRPCSSROptions } from './withTRPC';
 
 function transformQueryOrMutationCacheErrors<
   TState extends
@@ -44,9 +45,13 @@ function transformQueryOrMutationCacheErrors<
   return result;
 }
 
-export const ssrPrepass: TRPCPrepassHelper = (opts) => {
+export const ssrPrepass: TRPCPrepassHelper = <TRouter extends AnyRouter>(opts: {
+  parent: WithTRPCSSROptions<TRouter>;
+  WithTRPC: NextComponentType<any, any, any>;
+  AppOrPage: NextComponentType<any, any, any>;
+}) => {
   const { parent, WithTRPC, AppOrPage } = opts;
-  type $PrepassProps = TRPCPrepassProps<AnyRouter, any>;
+  type $PrepassProps= TRPCPrepassProps<TRouter, any>;
 
   const transformer = getTransformer(
     (parent as CoercedTransformerParameters).transformer,
@@ -166,7 +171,7 @@ export const ssrPrepass: TRPCPrepassHelper = (opts) => {
           .map((v) => v.state.error)
           .flatMap((err) =>
             err instanceof Error && err.name === 'TRPCClientError'
-              ? [err as TRPCClientError<AnyRouter>]
+              ? [err as TRPCClientError<TRouter>]
               : [],
           ),
       }) ?? {};

packages/next/src/withTRPC.tsx

@@ -40,8 +40,8 @@ type WithTRPCOptions<TRouter extends AnyRouter> =
     config: (info: { ctx?: NextPageContext }) => WithTRPCConfig<TRouter>;
   } & TransformerOptions<inferClientTypes<TRouter>>;
 
-export type TRPCPrepassHelper = (opts: {
-  parent: WithTRPCSSROptions<AnyRouter>;
+export type TRPCPrepassHelper = <TRouter extends AnyRouter>(opts: {
+  parent: WithTRPCSSROptions<TRouter>;
   WithTRPC: NextComponentType<any, any, any>;
   AppOrPage: NextComponentType<any, any, any>;
 }) => void;

packages/react-query/src/createTRPCReact.tsx

@@ -43,6 +43,7 @@ type ResolverDef = {
   output: any;
   transformer: boolean;
   errorShape: any;
+  ctx: any;
 };
 /**
  * @internal
@@ -56,6 +57,7 @@ export interface ProcedureUseQuery<TDef extends ResolverDef> {
       TRPCClientErrorLike<{
         errorShape: TDef['errorShape'];
         transformer: TDef['transformer'];
+        ctx: TDef['ctx'];
       }>,
       TDef['output']
     >,
@@ -64,6 +66,7 @@ export interface ProcedureUseQuery<TDef extends ResolverDef> {
     TRPCClientErrorLike<{
       errorShape: TDef['errorShape'];
       transformer: TDef['transformer'];
+        ctx: TDef['ctx'];
     }>
   >;
 
@@ -215,6 +218,7 @@ export type DecorateRouterRecord<
             output: inferTransformedProcedureOutput<TRoot, $Value>;
             transformer: TRoot['transformer'];
             errorShape: TRoot['errorShape'];
+        ctx: TRoot['ctx'];
           }
         >
       : never

packages/server/src/unstable-core-do-not-import/clientish/inferrable.ts

@@ -1,6 +1,6 @@
 import type { AnyRootTypes } from '../rootConfig';
 
-export type AnyClientTypes = Pick<AnyRootTypes, 'errorShape' | 'transformer'>;
+export type AnyClientTypes = Pick<AnyRootTypes, 'errorShape' | 'transformer' | 'ctx'>;
 
 /**
  * Result of `initTRPC.create()`