@trpc/server 11.0.0-alpha-tmp-app-router-example.388 → 11.0.0-alpha-tmp-issues-5851-take-two.448

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

@@ -1,17 +1,21 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import {
+  isObservable,
+  observableToAsyncIterable,
+} from '../../observable/observable';
 import { getErrorShape } from '../error/getErrorShape';
 import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
 import type { ProcedureType } from '../procedure';
 import {
-  callProcedure,
   type AnyRouter,
   type inferRouterContext,
   type inferRouterError,
 } from '../router';
 import type { TRPCResponse } from '../rpc';
-import { isPromise, jsonlStreamProducer } from '../stream/stream';
+import { isPromise, jsonlStreamProducer } from '../stream/jsonl';
+import { sseHeaders, sseStreamProducer } from '../stream/sse';
 import { transformTRPCResponse } from '../transformer';
-import { isObject } from '../utils';
+import { isAsyncIterable, isObject } from '../utils';
 import { getRequestInfo } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
 import type {
@@ -20,12 +24,28 @@ import type {
   TRPCRequestInfo,
 } from './types';
 
-const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
-  string,
-  ProcedureType | undefined
+type HTTPMethods =
+  | 'GET'
+  | 'POST'
+  | 'HEAD'
+  | 'OPTIONS'
+  | 'PUT'
+  | 'DELETE'
+  | 'PATCH';
+
+const TYPE_ACCEPTED_METHOD_MAP: Record<ProcedureType, HTTPMethods[]> = {
+  mutation: ['POST'],
+  query: ['GET'],
+  subscription: ['GET'],
+};
+const TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE: Record<
+  ProcedureType,
+  HTTPMethods[]
 > = {
-  GET: 'query',
-  POST: 'mutation',
+  // never allow GET to do a mutation
+  mutation: ['POST'],
+  query: ['GET', 'POST'],
+  subscription: ['GET', 'POST'],
 };
 
 interface ResolveHTTPRequestOptions<TRouter extends AnyRouter>
@@ -42,19 +62,17 @@ interface ResolveHTTPRequestOptions<TRouter extends AnyRouter>
 function initResponse<TRouter extends AnyRouter, TRequest>(initOpts: {
   ctx: inferRouterContext<TRouter> | undefined;
   info: TRPCRequestInfo | undefined;
-  type: ProcedureType | 'unknown';
   responseMeta?: HTTPBaseHandlerOptions<TRouter, TRequest>['responseMeta'];
-  untransformedJSON?:
+  untransformedJSON:
     | TRPCResponse<unknown, inferRouterError<TRouter>>
     | TRPCResponse<unknown, inferRouterError<TRouter>>[]
-    | undefined;
+    | null;
   errors: TRPCError[];
   headers: Headers;
 }) {
   const {
     ctx,
     info,
-    type,
     responseMeta,
     untransformedJSON,
     errors = [],
@@ -75,10 +93,12 @@ function initResponse<TRouter extends AnyRouter, TRequest>(initOpts: {
       ctx,
       info,
       paths: info?.calls.map((call) => call.path),
-      type,
       data,
       errors,
       eagerGeneration,
+      type:
+        info?.calls.find((call) => call.procedure?._def.type)?.procedure?._def
+          .type ?? 'unknown',
     }) ?? {};
 
   if (meta.headers) {
@@ -155,6 +175,25 @@ function caughtErrorToData<TRouter extends AnyRouter>(
   };
 }
 
+/**
+ * Check if a value is a stream-like object
+ * - if it's an async iterable
+ * - if it's an object with async iterables or promises
+ */
+function isDataStream(v: unknown) {
+  if (!isObject(v)) {
+    return false;
+  }
+
+  if (isAsyncIterable(v)) {
+    return true;
+  }
+
+  return (
+    Object.values(v).some(isPromise) || Object.values(v).some(isAsyncIterable)
+  );
+}
+
 export async function resolveResponse<TRouter extends AnyRouter>(
   opts: ResolveHTTPRequestOptions<TRouter>,
 ): Promise<Response> {
@@ -170,26 +209,33 @@ export async function resolveResponse<TRouter extends AnyRouter>(
       status: 204,
     });
   }
+
   const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
   const allowMethodOverride =
     (opts.allowMethodOverride ?? false) && req.method === 'POST';
-
-  const type =
-    HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? ('unknown' as const);
   let ctx: inferRouterContext<TRouter> | undefined = undefined;
   let info: TRPCRequestInfo | undefined = undefined;
 
+  const methodMapper = allowMethodOverride
+    ? TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE
+    : TYPE_ACCEPTED_METHOD_MAP;
+
+  /**
+   * @deprecated
+   */
   const isStreamCall = req.headers.get('trpc-accept') === 'application/jsonl';
 
   const experimentalIterablesAndDeferreds =
-    config.experimental?.iterablesAndDeferreds ?? false;
-
+    router._def._config.experimental?.iterablesAndDeferreds ?? true;
+  const experimentalSSE =
+    router._def._config.experimental?.sseSubscriptions?.enabled ?? true;
   try {
     info = getRequestInfo({
       req,
       path: decodeURIComponent(opts.path),
-      config: config,
+      router,
       searchParams: url.searchParams,
+      headers: opts.req.headers,
     });
 
     // we create context early so that error handlers may access context information
@@ -206,56 +252,49 @@ export async function resolveResponse<TRouter extends AnyRouter>(
         message: `Batching is not enabled on the server`,
       });
     }
-    if (type === 'unknown') {
+    /* istanbul ignore if -- @preserve */
+    if (isStreamCall && !info.isBatchCall) {
       throw new TRPCError({
-        message: `Unexpected request method ${req.method}`,
-        code: 'METHOD_NOT_SUPPORTED',
+        message: `Streaming requests must be batched (you can do a batch of 1)`,
+        code: 'BAD_REQUEST',
       });
     }
 
-    const errors: TRPCError[] = [];
-
-    const promises: Promise<
-      TRPCResponse<unknown, inferRouterError<TRouter>>
-    >[] = info.calls.map(async (call) => {
+    type RPCResult =
+      | [result: null, error: TRPCError]
+      | [result: unknown, error?: never];
+    const rpcCalls = info.calls.map(async (call): Promise<RPCResult> => {
+      const proc = call.procedure;
       try {
-        const data = await callProcedure({
-          procedures: opts.router._def.procedures,
+        if (!proc) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `No procedure found on path "${call.path}"`,
+          });
+        }
+
+        if (!methodMapper[proc._def.type].includes(req.method as HTTPMethods)) {
+          throw new TRPCError({
+            code: 'METHOD_NOT_SUPPORTED',
+            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`,
+          });
+        }
+        const data: unknown = await proc({
           path: call.path,
           getRawInput: call.getRawInput,
           ctx,
-          type,
-          allowMethodOverride,
+          type: proc._def.type,
         });
-
-        if (
-          (!isStreamCall || !experimentalIterablesAndDeferreds) &&
-          isObject(data) &&
-          (Symbol.asyncIterator in data || Object.values(data).some(isPromise))
-        ) {
-          if (!isStreamCall) {
-            throw new TRPCError({
-              code: 'UNSUPPORTED_MEDIA_TYPE',
-              message:
-                'Cannot return async iterable or nested promises in non-streaming response',
-            });
-          }
-          if (!experimentalIterablesAndDeferreds) {
-            throw new TRPCError({
-              code: 'INTERNAL_SERVER_ERROR',
-              message: 'Missing experimental flag "iterablesAndDeferreds"',
-            });
-          }
-        }
-
-        return {
-          result: {
-            data,
-          },
-        };
+        return [data];
       } catch (cause) {
         const error = getTRPCErrorFromUnknown(cause);
-        errors.push(error);
         const input = call.result();
 
         opts.onError?.({
@@ -263,141 +302,272 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           path: call.path,
           input,
           ctx,
-          type: type,
+          type: call.procedure?._def.type ?? 'unknown',
           req: opts.req,
         });
 
-        return {
-          error: getErrorShape({
-            config,
-            error,
-            type,
-            path: call.path,
-            input,
-            ctx,
-          }),
-        };
+        return [null, error];
       }
     });
-    if (!isStreamCall) {
-      headers.set('content-type', 'application/json');
-      /**
-       * Non-streaming response:
-       * - await all responses in parallel, blocking on the slowest one
-       * - create headers with known response body
-       * - return a complete HTTPResponse
-       */
 
-      const untransformedJSON = await Promise.all(promises);
+    // ----------- response handlers -----------
+    if (!info.isBatchCall) {
+      const [call] = info.calls;
+      const [data, error] = await rpcCalls[0]!;
 
-      const errors = untransformedJSON.flatMap((response) =>
-        'error' in response ? [response.error] : [],
-      );
+      switch (info.type) {
+        case 'unknown':
+        case 'mutation':
+        case 'query': {
+          // httpLink
+          headers.set('content-type', 'application/json');
 
+          if (isDataStream(data)) {
+            throw new TRPCError({
+              code: 'UNSUPPORTED_MEDIA_TYPE',
+              message:
+                'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink',
+            });
+          }
+          const res: TRPCResponse<unknown, inferRouterError<TRouter>> = error
+            ? {
+                error: getErrorShape({
+                  config,
+                  ctx,
+                  error,
+                  input: call!.result(),
+                  path: call!.path,
+                  type: info.type,
+                }),
+              }
+            : { result: { data } };
+
+          const headResponse = initResponse({
+            ctx,
+            info,
+            responseMeta: opts.responseMeta,
+            errors: error ? [error] : [],
+            headers,
+            untransformedJSON: [res],
+          });
+          return new Response(
+            JSON.stringify(transformTRPCResponse(config, res)),
+            {
+              status: headResponse.status,
+              headers,
+            },
+          );
+        }
+        case 'subscription': {
+          // httpSubscriptionLink
+
+          if (!experimentalSSE) {
+            throw new TRPCError({
+              code: 'METHOD_NOT_SUPPORTED',
+              message: 'Missing experimental flag "sseSubscriptions"',
+            });
+          }
+
+          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({
+            data: dataAsIterable,
+            serialize: (v) => config.transformer.output.serialize(v),
+          });
+          for (const [key, value] of Object.entries(sseHeaders)) {
+            headers.set(key, value);
+          }
+
+          const headResponse = initResponse({
+            ctx,
+            info,
+            responseMeta: opts.responseMeta,
+            errors: [],
+            headers,
+            untransformedJSON: null,
+          });
+
+          return new Response(stream, {
+            headers,
+            status: headResponse.status,
+          });
+        }
+      }
+    }
+
+    // batch response handlers
+    if (info.accept === 'application/jsonl') {
+      // httpBatchStreamLink
+      headers.set('content-type', 'application/json');
+      headers.set('transfer-encoding', 'chunked');
       const headResponse = initResponse({
         ctx,
         info,
-        type,
         responseMeta: opts.responseMeta,
-        untransformedJSON,
-        errors,
+        errors: [],
         headers,
+        untransformedJSON: null,
       });
+      const stream = jsonlStreamProducer({
+        /**
+         * Example structure for `maxDepth: 4`:
+         * {
+         *   // 1
+         *   0: {
+         *     // 2
+         *     result: {
+         *       // 3
+         *       data: // 4
+         *     }
+         *   }
+         * }
+         */
+        maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
+        data: rpcCalls.map(async (res) => {
+          const [result, error] = await res;
+
+          const call = info!.calls[0];
+          if (error) {
+            return {
+              error: getErrorShape({
+                config,
+                ctx,
+                error,
+                input: call!.result(),
+                path: call!.path,
+                type: call!.procedure?._def.type ?? 'unknown',
+              }),
+            };
+          }
 
-      // return body stuff
-      const result = info.isBatchCall
-        ? untransformedJSON
-        : untransformedJSON[0]!;
-      const transformedJSON = transformTRPCResponse(
-        router._def._config,
-        result,
-      );
-      const body = JSON.stringify(transformedJSON);
-
-      return new Response(body, {
-        status: headResponse.status,
+          /**
+           * 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);
+          return {
+            result: Promise.resolve({
+              data,
+            }),
+          };
+        }),
+        serialize: config.transformer.output.serialize,
+        onError: (cause) => {
+          opts.onError?.({
+            error: getTRPCErrorFromUnknown(cause),
+            path: undefined,
+            input: undefined,
+            ctx,
+            req: opts.req,
+            type: info?.type ?? 'unknown',
+          });
+        },
+
+        formatError(errorOpts) {
+          const call = info?.calls[errorOpts.path[0] as any];
+
+          const shape = getErrorShape({
+            config,
+            ctx,
+            error: getTRPCErrorFromUnknown(errorOpts.error),
+            input: call?.result(),
+            path: call?.path,
+            type: call?.procedure?._def.type ?? 'unknown',
+          });
+
+          return shape;
+        },
+      });
+
+      return new Response(stream, {
         headers,
+        status: headResponse.status,
       });
     }
 
-    headers.set('content-type', 'application/json');
-    headers.set('transfer-encoding', 'chunked');
+    // httpBatchLink
     /**
-     * Streaming response:
-     * - block on none, call `onChunk` as soon as each response is ready
-     * - create headers with minimal data (cannot know the response body in advance)
-     * - return void
+     * Non-streaming response:
+     * - await all responses in parallel, blocking on the slowest one
+     * - create headers with known response body
+     * - return a complete HTTPResponse
      */
-    const headResponse = initResponse({
-      ctx,
-      info,
-      type,
-      responseMeta: opts.responseMeta,
-      errors: [],
-      headers,
-    });
-
-    const stream = jsonlStreamProducer({
-      /**
-       * Example structure for `maxDepth: 4`:
-       * {
-       *   // 1
-       *   0: {
-       *     // 2
-       *     result: {
-       *       // 3
-       *       data: // 4
-       *     }
-       *   }
-       * }
-       */
-      maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
-      formatError(errorOpts) {
-        const call = info?.calls[errorOpts.path[0] as any];
+    headers.set('content-type', 'application/json');
+    const results: RPCResult[] = (await Promise.all(rpcCalls)).map(
+      (res): RPCResult => {
+        const [data, error] = res;
+        if (error) {
+          return res;
+        }
 
-        return getErrorShape({
-          config,
-          ctx,
-          error: getTRPCErrorFromUnknown(errorOpts.error),
-          input: call?.result(),
-          path: call?.path,
-          type,
-        });
+        if (isDataStream(data)) {
+          return [
+            null,
+            new TRPCError({
+              code: 'UNSUPPORTED_MEDIA_TYPE',
+              message:
+                'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink',
+            }),
+          ];
+        }
+        return res;
       },
-      data: promises.map(async (it) => {
-        const response = await it;
-        if ('result' in response) {
-          /**
-           * 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 resultAsRPCResponse = results.map(
+      (
+        [data, error],
+        index,
+      ): TRPCResponse<unknown, inferRouterError<TRouter>> => {
+        const call = info!.calls[index]!;
+        if (error) {
           return {
-            ...response,
-            result: Promise.resolve({
-              ...response.result,
-              data: Promise.resolve(response.result.data),
+            error: getErrorShape({
+              config,
+              ctx,
+              error,
+              input: call.result(),
+              path: call.path,
+              type: call.procedure?._def.type ?? 'unknown',
             }),
           };
         }
-        return response;
-      }),
-      serialize: config.transformer.output.serialize,
-      onError: (cause) => {
-        opts.onError?.({
-          error: getTRPCErrorFromUnknown(cause),
-          path: undefined,
-          input: undefined,
-          ctx,
-          type,
-          req: opts.req,
-        });
+        return {
+          result: { data },
+        };
       },
-    });
+    );
 
-    return new Response(stream, {
+    const errors = results
+      .map(([_, error]) => error)
+      .filter(Boolean) as TRPCError[];
+
+    const headResponse = initResponse({
+      ctx,
+      info,
+      responseMeta: opts.responseMeta,
+      untransformedJSON: resultAsRPCResponse,
+      errors,
       headers,
-      status: headResponse.status,
     });
+
+    return new Response(
+      JSON.stringify(transformTRPCResponse(config, resultAsRPCResponse)),
+      {
+        status: headResponse.status,
+        headers,
+      },
+    );
   } catch (cause) {
     // we get here if
     // - batching is called when it's not enabled
@@ -409,13 +579,12 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     const { error, untransformedJSON, body } = caughtErrorToData(cause, {
       opts,
       ctx,
-      type,
+      type: info?.type ?? 'unknown',
     });
 
     const headResponse = initResponse({
       ctx,
       info,
-      type,
       responseMeta: opts.responseMeta,
       untransformedJSON,
       errors: [error],