@trpc/server 10.29.0 → 10.30.0

package/src/adapters/node-http/nodeHTTPRequestHandler.ts

@@ -64,7 +64,9 @@ export async function nodeHTTPRequestHandler<
       body: bodyResult.ok ? bodyResult.data : undefined,
     };
 
-    const onHead = (head: HTTPResponse) => {
+    let isStream = false;
+    let formatter: ReturnType<typeof getBatchStreamFormatter>;
+    const unstable_onHead = (head: HTTPResponse, isStreaming: boolean) => {
       if (
         'status' in head &&
         (!opts.res.statusCode || opts.res.statusCode === 200)
@@ -78,11 +80,20 @@ export async function nodeHTTPRequestHandler<
         }
         opts.res.setHeader(key, value);
       }
+      if (isStreaming) {
+        opts.res.setHeader('Transfer-Encoding', 'chunked');
+        const vary = opts.res.getHeader('Vary');
+        opts.res.setHeader(
+          'Vary',
+          vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode',
+        );
+        isStream = true;
+        formatter = getBatchStreamFormatter();
+        opts.res.flushHeaders();
+      }
     };
 
-    const formatter = getBatchStreamFormatter();
-    let isStream = false;
-    const onChunk = ([index, string]: ResponseChunk) => {
+    const unstable_onChunk = ([index, string]: ResponseChunk) => {
       if (index === -1) {
         /**
          * Full response, no streaming. This can happen
@@ -90,18 +101,10 @@ export async function nodeHTTPRequestHandler<
          * - if response is empty (HEAD request)
          */
         opts.res.end(string);
-        return;
-      }
-      if (!isStream) {
-        opts.res.setHeader('Transfer-Encoding', 'chunked');
-        const vary = opts.res.getHeader('Vary');
-        opts.res.setHeader(
-          'Vary',
-          vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode',
-        );
-        isStream = true;
+      } else {
+        opts.res.write(formatter!(index, string));
+        opts.res.flush?.();
       }
-      opts.res.write(formatter(index, string));
     };
 
     await resolveHTTPResponse({
@@ -120,16 +123,15 @@ export async function nodeHTTPRequestHandler<
         });
       },
       contentTypeHandler,
-      onHead,
-      onChunk,
+      unstable_onHead,
+      unstable_onChunk,
     });
 
-    if (!isStream) {
-      return opts.res;
+    if (isStream) {
+      opts.res.write(formatter!.end());
+      opts.res.end();
     }
 
-    opts.res.write(formatter.end());
-    opts.res.end();
     return opts.res;
   });
 }

package/src/adapters/node-http/types.ts

@@ -12,7 +12,17 @@ export type NodeHTTPRequest = IncomingMessage & {
   query?: ParsedQs;
   body?: unknown;
 };
-export type NodeHTTPResponse = ServerResponse;
+export type NodeHTTPResponse = ServerResponse & {
+  /**
+   * Force the partially-compressed response to be flushed to the client.
+   *
+   * Added by compression middleware
+   * (depending on the environment,
+   * e.g. Next <= 12,
+   * e.g. Express w/ `compression()`)
+   */
+  flush?: () => void;
+};
 
 export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,

package/src/http/internals/types.ts

@@ -36,5 +36,5 @@ export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
    * generated without knowing the response data
    * (e.g. for streaming requests).
    */
-  eagerGeneration: boolean;
+  eagerGeneration?: boolean;
 }) => ResponseMeta;

package/src/http/resolveHTTPResponse.ts

@@ -47,12 +47,16 @@ interface ResolveHTTPRequestOptions<
   contentTypeHandler?: BaseContentTypeHandler<any>;
   preprocessedBody?: boolean;
   /**
-   * Called as soon as the response head is known,
-   * with headers that were generated **without** knowing the response body.
+   * Called as soon as the response head is known.
+   * When streaming, headers will have been generated
+   * **without** knowing the response body.
    *
    * Without this callback, streaming is disabled.
    */
-  onHead: (headResponse: Omit<HTTPResponse, 'body'>) => void;
+  unstable_onHead: (
+    headResponse: Omit<HTTPResponse, 'body'>,
+    isStreaming: boolean,
+  ) => void;
   /**
    * Called for every procedure with `[index, result]`.
    *
@@ -62,7 +66,7 @@ interface ResolveHTTPRequestOptions<
    *
    * Without this callback, streaming is disabled.
    */
-  onChunk: (chunk: ResponseChunk) => void;
+  unstable_onChunk: (chunk: ResponseChunk) => void;
 }
 
 function initResponse<
@@ -223,8 +227,8 @@ function caughtErrorToData<
 
 /**
  * Non-streaming signature for `resolveHTTPResponse`:
- * @param opts.onHead `undefined`
- * @param opts.onChunk `undefined`
+ * @param opts.unstable_onHead `undefined`
+ * @param opts.unstable_onChunk `undefined`
  * @returns `Promise<HTTPResponse>`
  */
 export async function resolveHTTPResponse<
@@ -233,13 +237,13 @@ export async function resolveHTTPResponse<
 >(
   opts: Omit<
     ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'onHead' | 'onChunk'
+    'unstable_onHead' | 'unstable_onChunk'
   >,
 ): Promise<HTTPResponse>;
 /**
  * Streaming signature for `resolveHTTPResponse`:
- * @param opts.onHead called as soon as the response head is known
- * @param opts.onChunk called for every procedure with `[index, result]`
+ * @param opts.unstable_onHead called as soon as the response head is known
+ * @param opts.unstable_onChunk called for every procedure with `[index, result]`
  * @returns `Promise<void>` since the response is streamed
  */
 export async function resolveHTTPResponse<
@@ -253,18 +257,18 @@ export async function resolveHTTPResponse<
 >(
   opts: PartialBy<
     ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'onHead' | 'onChunk'
+    'unstable_onHead' | 'unstable_onChunk'
   >,
 ): Promise<HTTPResponse | void> {
-  const { router, req, onHead, onChunk } = opts;
+  const { router, req, unstable_onHead, unstable_onChunk } = opts;
 
   if (req.method === 'HEAD') {
     // can be used for lambda warmup
     const headResponse: HTTPResponse = {
       status: 204,
     };
-    onHead?.(headResponse);
-    onChunk?.([-1, '']);
+    unstable_onHead?.(headResponse, false);
+    unstable_onChunk?.([-1, '']);
     return headResponse;
   }
   const contentTypeHandler =
@@ -278,8 +282,8 @@ export async function resolveHTTPResponse<
   const isBatchCall = !!req.query.get('batch');
   const isStreamCall =
     isBatchCall &&
-    onHead &&
-    onChunk &&
+    unstable_onHead &&
+    unstable_onChunk &&
     req.headers['trpc-batch-mode'] === 'stream';
 
   try {
@@ -337,7 +341,7 @@ export async function resolveHTTPResponse<
         untransformedJSON,
         errors,
       });
-      onHead?.(headResponse);
+      unstable_onHead?.(headResponse, false);
 
       // return body stuff
       const result = isBatchCall ? untransformedJSON : untransformedJSON[0]!; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
@@ -346,7 +350,7 @@ export async function resolveHTTPResponse<
         result,
       );
       const body = JSON.stringify(transformedJSON);
-      onChunk?.([-1, body]);
+      unstable_onChunk?.([-1, body]);
 
       return {
         status: headResponse.status,
@@ -367,7 +371,7 @@ export async function resolveHTTPResponse<
       type,
       responseMeta: opts.responseMeta,
     });
-    onHead(headResponse);
+    unstable_onHead(headResponse, true);
 
     const indexedPromises = new Map(
       promises.map((promise, index) => [
@@ -388,7 +392,7 @@ export async function resolveHTTPResponse<
         );
         const body = JSON.stringify(transformedJSON);
 
-        onChunk([index, body]);
+        unstable_onChunk([index, body]);
       } catch (cause) {
         const path = paths[index];
         const input = inputs[index];
@@ -400,7 +404,7 @@ export async function resolveHTTPResponse<
           input,
         });
 
-        onChunk([index, body]);
+        unstable_onChunk([index, body]);
       }
     }
     return;
@@ -426,9 +430,9 @@ export async function resolveHTTPResponse<
       untransformedJSON,
       errors: [error],
     });
-    onHead?.(headResponse);
+    unstable_onHead?.(headResponse, false);
 
-    onChunk?.([-1, body]);
+    unstable_onChunk?.([-1, body]);
 
     return {
       status: headResponse.status,