@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.667

package/src/unstable-core-do-not-import/http/resolveResponse.ts

@@ -15,7 +15,7 @@ import type { TRPCResponse } from '../rpc';
 import { isPromise, jsonlStreamProducer } from '../stream/jsonl';
 import { sseHeaders, sseStreamProducer } from '../stream/sse';
 import { transformTRPCResponse } from '../transformer';
-import { isAsyncIterable, isObject } from '../utils';
+import { isAsyncIterable, isObject, run } from '../utils';
 import { getRequestInfo } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
 import type {
@@ -24,6 +24,11 @@ import type {
   TRPCRequestInfo,
 } from './types';
 
+function errorToAsyncIterable(err: TRPCError): AsyncIterable<never> {
+  return run(async function* () {
+    throw err;
+  });
+}
 type HTTPMethods =
   | 'GET'
   | 'POST'
@@ -85,8 +90,8 @@ function initResponse<TRouter extends AnyRouter, TRequest>(initOpts: {
   const data = eagerGeneration
     ? []
     : Array.isArray(untransformedJSON)
-    ? untransformedJSON
-    : [untransformedJSON];
+      ? untransformedJSON
+      : [untransformedJSON];
 
   const meta =
     responseMeta?.({
@@ -194,6 +199,8 @@ function isDataStream(v: unknown) {
   );
 }
 
+type ResultTuple<T> = [undefined, T] | [TRPCError, undefined];
+
 export async function resolveResponse<TRouter extends AnyRouter>(
   opts: ResolveHTTPRequestOptions<TRouter>,
 ): Promise<Response> {
@@ -213,8 +220,64 @@ export async function resolveResponse<TRouter extends AnyRouter>(
   const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
   const allowMethodOverride =
     (opts.allowMethodOverride ?? false) && req.method === 'POST';
-  let ctx: inferRouterContext<TRouter> | undefined = undefined;
-  let info: TRPCRequestInfo | undefined = undefined;
+
+  type $Context = inferRouterContext<TRouter>;
+
+  const infoTuple: ResultTuple<TRPCRequestInfo> = run(() => {
+    try {
+      return [
+        undefined,
+        getRequestInfo({
+          req,
+          path: decodeURIComponent(opts.path),
+          router,
+          searchParams: url.searchParams,
+          headers: opts.req.headers,
+        }),
+      ];
+    } catch (cause) {
+      return [getTRPCErrorFromUnknown(cause), undefined];
+    }
+  });
+
+  interface ContextManager {
+    valueOrUndefined: () => $Context | undefined;
+    value: () => $Context;
+    create: (info: TRPCRequestInfo) => Promise<void>;
+  }
+  const ctxManager: ContextManager = run(() => {
+    let result: ResultTuple<$Context> | undefined = undefined;
+    return {
+      valueOrUndefined: () => {
+        if (!result) {
+          return undefined;
+        }
+        return result[1];
+      },
+      value: () => {
+        const [err, ctx] = result!;
+        if (err) {
+          throw err;
+        }
+        return ctx;
+      },
+      create: async (info) => {
+        if (result) {
+          throw new Error(
+            'This should only be called once - report a bug in tRPC',
+          );
+        }
+        try {
+          const ctx = await opts.createContext({
+            info,
+          });
+          result = [undefined, ctx];
+        } catch (cause) {
+          result = [getTRPCErrorFromUnknown(cause), undefined];
+        }
+      },
+    };
+  });
 
   const methodMapper = allowMethodOverride
     ? TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE
@@ -226,25 +289,12 @@ export async function resolveResponse<TRouter extends AnyRouter>(
   const isStreamCall = req.headers.get('trpc-accept') === 'application/jsonl';
 
   const experimentalIterablesAndDeferreds =
-    router._def._config.experimental?.iterablesAndDeferreds ?? true;
-  const experimentalSSE =
-    router._def._config.experimental?.sseSubscriptions?.enabled ?? true;
+    config.iterablesAndDeferreds ?? true;
+  const experimentalSSE = config.sse?.enabled ?? true;
   try {
-    info = getRequestInfo({
-      req,
-      path: decodeURIComponent(opts.path),
-      router,
-      searchParams: url.searchParams,
-      headers: opts.req.headers,
-    });
-
-    // we create context early so that error handlers may access context information
-    ctx = await opts.createContext({
-      info,
-    });
-
-    if (opts.error) {
-      throw opts.error;
+    const [infoError, info] = infoTuple;
+    if (infoError) {
+      throw infoError;
     }
     if (info.isBatchCall && !allowBatching) {
       throw new TRPCError({
@@ -259,13 +309,19 @@ export async function resolveResponse<TRouter extends AnyRouter>(
         code: 'BAD_REQUEST',
       });
     }
+    await ctxManager.create(info);
 
-    type RPCResult =
-      | [result: null, error: TRPCError]
-      | [result: unknown, error?: never];
+    interface RPCResultOk {
+      data: unknown;
+    }
+    type RPCResult = ResultTuple<RPCResultOk>;
     const rpcCalls = info.calls.map(async (call): Promise<RPCResult> => {
       const proc = call.procedure;
       try {
+        if (opts.error) {
+          throw opts.error;
+        }
+
         if (!proc) {
           throw new TRPCError({
             code: 'NOT_FOUND',
@@ -279,20 +335,24 @@ export async function resolveResponse<TRouter extends AnyRouter>(
             message: `Unsupported ${req.method}-request to ${proc._def.type} procedure at path "${call.path}"`,
           });
         }
-        /* istanbul ignore if -- @preserve */
-        if (proc._def.type === 'subscription' && info!.isBatchCall) {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `Cannot batch subscription calls`,
-          });
+
+        if (proc._def.type === 'subscription') {
+          /* istanbul ignore if -- @preserve */
+          if (info.isBatchCall) {
+            throw new TRPCError({
+              code: 'BAD_REQUEST',
+              message: `Cannot batch subscription calls`,
+            });
+          }
         }
         const data: unknown = await proc({
           path: call.path,
           getRawInput: call.getRawInput,
-          ctx,
+          ctx: ctxManager.value(),
           type: proc._def.type,
+          signal: opts.req.signal,
         });
-        return [data];
+        return [undefined, { data }];
       } catch (cause) {
         const error = getTRPCErrorFromUnknown(cause);
         const input = call.result();
@@ -301,19 +361,19 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           error,
           path: call.path,
           input,
-          ctx,
+          ctx: ctxManager.valueOrUndefined(),
           type: call.procedure?._def.type ?? 'unknown',
           req: opts.req,
         });
 
-        return [null, error];
+        return [error, undefined];
       }
     });
 
     // ----------- response handlers -----------
     if (!info.isBatchCall) {
       const [call] = info.calls;
-      const [data, error] = await rpcCalls[0]!;
+      const [error, result] = await rpcCalls[0]!;
 
       switch (info.type) {
         case 'unknown':
@@ -322,7 +382,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           // httpLink
           headers.set('content-type', 'application/json');
 
-          if (isDataStream(data)) {
+          if (isDataStream(result?.data)) {
             throw new TRPCError({
               code: 'UNSUPPORTED_MEDIA_TYPE',
               message:
@@ -333,17 +393,17 @@ export async function resolveResponse<TRouter extends AnyRouter>(
             ? {
                 error: getErrorShape({
                   config,
-                  ctx,
+                  ctx: ctxManager.valueOrUndefined(),
                   error,
                   input: call!.result(),
                   path: call!.path,
                   type: info.type,
                 }),
               }
-            : { result: { data } };
+            : { result: { data: result.data } };
 
           const headResponse = initResponse({
-            ctx,
+            ctx: ctxManager.valueOrUndefined(),
             info,
             responseMeta: opts.responseMeta,
             errors: error ? [error] : [],
@@ -361,36 +421,61 @@ export async function resolveResponse<TRouter extends AnyRouter>(
         case 'subscription': {
           // httpSubscriptionLink
 
-          if (!experimentalSSE) {
-            throw new TRPCError({
-              code: 'METHOD_NOT_SUPPORTED',
-              message: 'Missing experimental flag "sseSubscriptions"',
-            });
-          }
+          const iterable: AsyncIterable<unknown> = run(() => {
+            if (error) {
+              return errorToAsyncIterable(error);
+            }
+            if (!experimentalSSE) {
+              return errorToAsyncIterable(
+                new TRPCError({
+                  code: 'METHOD_NOT_SUPPORTED',
+                  message: 'Missing experimental flag "sseSubscriptions"',
+                }),
+              );
+            }
+
+            if (!isObservable(result.data) && !isAsyncIterable(result.data)) {
+              return errorToAsyncIterable(
+                new TRPCError({
+                  message: `Subscription ${
+                    call!.path
+                  } did not return an observable or a AsyncGenerator`,
+                  code: 'INTERNAL_SERVER_ERROR',
+                }),
+              );
+            }
+            const dataAsIterable = isObservable(result.data)
+              ? observableToAsyncIterable(result.data, opts.req.signal)
+              : result.data;
+            return dataAsIterable;
+          });
 
-          if (!isObservable(data) && !isAsyncIterable(data)) {
-            throw new TRPCError({
-              message: `Subscription ${
-                call!.path
-              } did not return an observable or a AsyncGenerator`,
-              code: 'INTERNAL_SERVER_ERROR',
-            });
-          }
-          const dataAsIterable = isObservable(data)
-            ? observableToAsyncIterable(data)
-            : data;
           const stream = sseStreamProducer({
-            ...config.experimental?.sseSubscriptions,
-            data: dataAsIterable,
+            ...config.sse,
+            data: iterable,
             serialize: (v) => config.transformer.output.serialize(v),
             formatError(errorOpts) {
+              const error = getTRPCErrorFromUnknown(errorOpts.error);
+              const input = call?.result();
+              const path = call?.path;
+              const type = call?.procedure?._def.type ?? 'unknown';
+
+              opts.onError?.({
+                error,
+                path,
+                input,
+                ctx: ctxManager.valueOrUndefined(),
+                req: opts.req,
+                type,
+              });
+
               const shape = getErrorShape({
                 config,
-                ctx,
-                error: getTRPCErrorFromUnknown(errorOpts.error),
-                input: call?.result(),
-                path: call?.path,
-                type: call?.procedure?._def.type ?? 'unknown',
+                ctx: ctxManager.valueOrUndefined(),
+                error,
+                input,
+                path,
+                type,
               });
 
               return shape;
@@ -401,7 +486,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           }
 
           const headResponse = initResponse({
-            ctx,
+            ctx: ctxManager.valueOrUndefined(),
             info,
             responseMeta: opts.responseMeta,
             errors: [],
@@ -423,7 +508,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
       headers.set('content-type', 'application/json');
       headers.set('transfer-encoding', 'chunked');
       const headResponse = initResponse({
-        ctx,
+        ctx: ctxManager.valueOrUndefined(),
         info,
         responseMeta: opts.responseMeta,
         errors: [],
@@ -446,14 +531,15 @@ export async function resolveResponse<TRouter extends AnyRouter>(
          */
         maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
         data: rpcCalls.map(async (res) => {
-          const [result, error] = await res;
+          const [error, result] = await res;
+
+          const call = info.calls[0];
 
-          const call = info!.calls[0];
           if (error) {
             return {
               error: getErrorShape({
                 config,
-                ctx,
+                ctx: ctxManager.valueOrUndefined(),
                 error,
                 input: call!.result(),
                 path: call!.path,
@@ -466,12 +552,12 @@ export async function resolveResponse<TRouter extends AnyRouter>(
            * Not very pretty, but we need to wrap nested data in promises
            * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
            */
-          const data = isObservable(result)
-            ? observableToAsyncIterable(result)
-            : Promise.resolve(result);
+          const iterable = isObservable(result.data)
+            ? observableToAsyncIterable(result.data, opts.req.signal)
+            : Promise.resolve(result.data);
           return {
             result: Promise.resolve({
-              data,
+              data: iterable,
             }),
           };
         }),
@@ -481,7 +567,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
             error: getTRPCErrorFromUnknown(cause),
             path: undefined,
             input: undefined,
-            ctx,
+            ctx: ctxManager.valueOrUndefined(),
             req: opts.req,
             type: info?.type ?? 'unknown',
           });
@@ -490,13 +576,20 @@ export async function resolveResponse<TRouter extends AnyRouter>(
         formatError(errorOpts) {
           const call = info?.calls[errorOpts.path[0] as any];
 
+          const error = getTRPCErrorFromUnknown(errorOpts.error);
+          const input = call?.result();
+          const path = call?.path;
+          const type = call?.procedure?._def.type ?? 'unknown';
+
+          // no need to call `onError` here as it will be propagated through the stream itself
+
           const shape = getErrorShape({
             config,
-            ctx,
-            error: getTRPCErrorFromUnknown(errorOpts.error),
-            input: call?.result(),
-            path: call?.path,
-            type: call?.procedure?._def.type ?? 'unknown',
+            ctx: ctxManager.valueOrUndefined(),
+            error,
+            input,
+            path,
+            type,
           });
 
           return shape;
@@ -519,19 +612,19 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     headers.set('content-type', 'application/json');
     const results: RPCResult[] = (await Promise.all(rpcCalls)).map(
       (res): RPCResult => {
-        const [data, error] = res;
+        const [error, result] = res;
         if (error) {
           return res;
         }
 
-        if (isDataStream(data)) {
+        if (isDataStream(result.data)) {
           return [
-            null,
             new TRPCError({
               code: 'UNSUPPORTED_MEDIA_TYPE',
               message:
                 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink',
             }),
+            undefined,
           ];
         }
         return res;
@@ -539,15 +632,15 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     );
     const resultAsRPCResponse = results.map(
       (
-        [data, error],
+        [error, result],
         index,
       ): TRPCResponse<unknown, inferRouterError<TRouter>> => {
-        const call = info!.calls[index]!;
+        const call = info.calls[index]!;
         if (error) {
           return {
             error: getErrorShape({
               config,
-              ctx,
+              ctx: ctxManager.valueOrUndefined(),
               error,
               input: call.result(),
               path: call.path,
@@ -556,17 +649,17 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           };
         }
         return {
-          result: { data },
+          result: { data: result.data },
         };
       },
     );
 
     const errors = results
-      .map(([_, error]) => error)
+      .map(([error]) => error)
       .filter(Boolean) as TRPCError[];
 
     const headResponse = initResponse({
-      ctx,
+      ctx: ctxManager.valueOrUndefined(),
       info,
       responseMeta: opts.responseMeta,
       untransformedJSON: resultAsRPCResponse,
@@ -582,6 +675,8 @@ export async function resolveResponse<TRouter extends AnyRouter>(
       },
     );
   } catch (cause) {
+    const [_infoError, info] = infoTuple;
+    const ctx = ctxManager.valueOrUndefined();
     // we get here if
     // - batching is called when it's not enabled
     // - `createContext()` throws
@@ -591,7 +686,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     // - `errorFormatter` return value is malformed
     const { error, untransformedJSON, body } = caughtErrorToData(cause, {
       opts,
-      ctx,
+      ctx: ctxManager.valueOrUndefined(),
       type: info?.type ?? 'unknown',
     });
 

package/src/unstable-core-do-not-import/http/types.ts

@@ -50,7 +50,7 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
   /**
    * Add handler to be called before response is sent to the user
    * Useful for setting cache headers
-   * @link https://trpc.io/docs/v11/caching
+   * @see https://trpc.io/docs/v11/caching
    */
   responseMeta?: ResponseMetaFn<TRouter>;
 }

package/src/unstable-core-do-not-import/initTRPC.ts

@@ -16,12 +16,8 @@ import type { DataTransformerOptions } from './transformer';
 import { defaultTransformer, getDataTransformer } from './transformer';
 import type { Unwrap, ValidateShape } from './types';
 
-type inferErrorFormatterShape<TType> = TType extends ErrorFormatter<
-  any,
-  infer TShape
->
-  ? TShape
-  : DefaultErrorShape;
+type inferErrorFormatterShape<TType> =
+  TType extends ErrorFormatter<any, infer TShape> ? TShape : DefaultErrorShape;
 interface RuntimeConfigOptions<TContext extends object, TMeta extends object>
   extends Partial<
     Omit<
@@ -36,7 +32,7 @@ interface RuntimeConfigOptions<TContext extends object, TMeta extends object>
   > {
   /**
    * Use a data transformer
-   * @link https://trpc.io/docs/v11/data-transformers
+   * @see https://trpc.io/docs/v11/data-transformers
    */
   transformer?: DataTransformerOptions;
 }
@@ -46,7 +42,7 @@ type ContextCallback = (...args: any[]) => object | Promise<object>;
 class TRPCBuilder<TContext extends object, TMeta extends object> {
   /**
    * Add a context shape as a generic to the root object
-   * @link https://trpc.io/docs/v11/server/context
+   * @see https://trpc.io/docs/v11/server/context
    */
   context<TNewContext extends object | ContextCallback>() {
     return new TRPCBuilder<
@@ -57,7 +53,7 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
 
   /**
    * Add a meta shape as a generic to the root object
-   * @link https://trpc.io/docs/v11/quickstart
+   * @see https://trpc.io/docs/v11/quickstart
    */
   meta<TNewMeta extends object>() {
     return new TRPCBuilder<TContext, TNewMeta>();
@@ -65,12 +61,10 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
 
   /**
    * Create the root object
-   * @link https://trpc.io/docs/v11/server/routers#initialize-trpc
+   * @see https://trpc.io/docs/v11/server/routers#initialize-trpc
    */
   create<TOptions extends RuntimeConfigOptions<TContext, TMeta>>(
-    opts?:
-      | ValidateShape<TOptions, RuntimeConfigOptions<TContext, TMeta>>
-      | undefined,
+    opts?: ValidateShape<TOptions, RuntimeConfigOptions<TContext, TMeta>>,
   ) {
     type $Root = CreateRootTypes<{
       ctx: TContext;
@@ -82,6 +76,7 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
     }>;
 
     const config: RootConfig<$Root> = {
+      ...opts,
       transformer: getDataTransformer(opts?.transformer ?? defaultTransformer),
       isDev:
         opts?.isDev ??
@@ -95,7 +90,6 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
        * @internal
        */
       $types: null as any,
-      experimental: opts?.experimental ?? {},
     };
 
     {
@@ -116,29 +110,29 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
       _config: config,
       /**
        * Builder object for creating procedures
-       * @link https://trpc.io/docs/v11/server/procedures
+       * @see https://trpc.io/docs/v11/server/procedures
        */
       procedure: createBuilder<$Root['ctx'], $Root['meta']>({
         meta: opts?.defaultMeta,
       }),
       /**
        * Create reusable middlewares
-       * @link https://trpc.io/docs/v11/server/middlewares
+       * @see https://trpc.io/docs/v11/server/middlewares
        */
       middleware: createMiddlewareFactory<$Root['ctx'], $Root['meta']>(),
       /**
        * Create a router
-       * @link https://trpc.io/docs/v11/server/routers
+       * @see https://trpc.io/docs/v11/server/routers
        */
       router: createRouterFactory<$Root>(config),
       /**
        * Merge Routers
-       * @link https://trpc.io/docs/v11/server/merging-routers
+       * @see https://trpc.io/docs/v11/server/merging-routers
        */
       mergeRouters,
       /**
        * Create a server-side caller for a router
-       * @link https://trpc.io/docs/v11/server/server-side-calls
+       * @see https://trpc.io/docs/v11/server/server-side-calls
        */
       createCallerFactory: createCallerFactory<$Root>(),
     };
@@ -147,7 +141,7 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
 
 /**
  * Builder to initialize the tRPC root object - use this exactly once per backend
- * @link https://trpc.io/docs/v11/quickstart
+ * @see https://trpc.io/docs/v11/quickstart
  */
 export const initTRPC = new TRPCBuilder();
 export type { TRPCBuilder };

package/src/unstable-core-do-not-import/middleware.ts

@@ -100,15 +100,16 @@ export type MiddlewareFunction<
     input: TInputOut;
     getRawInput: GetRawInputFn;
     meta: TMeta | undefined;
+    signal: AbortSignal | undefined;
     next: {
       (): Promise<MiddlewareResult<TContextOverridesIn>>;
       <$ContextOverride>(opts: {
         ctx?: $ContextOverride;
         input?: unknown;
       }): Promise<MiddlewareResult<$ContextOverride>>;
-      (opts: { getRawInput: GetRawInputFn }): Promise<
-        MiddlewareResult<TContextOverridesIn>
-      >;
+      (opts: {
+        getRawInput: GetRawInputFn;
+      }): Promise<MiddlewareResult<TContextOverridesIn>>;
     };
   }): Promise<MiddlewareResult<$ContextOverridesOut>>;
   _type?: string | undefined;
@@ -157,7 +158,7 @@ export function createMiddlewareFactory<
 
 /**
  * Create a standalone middleware
- * @link https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+ * @see https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
  * @deprecated use `.unstable_concat()` instead
  */
 export const experimental_standaloneMiddleware = <