@trpc/server 11.0.0-rc.632 → 11.0.0-rc.633

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.632+3df8b21be",
+  "version": "11.0.0-rc.633+55512768a",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -156,5 +156,5 @@
     "next": "*",
     "ws": "*"
   },
-  "gitHead": "3df8b21beb4925cf73194fc776d1a88603a3c420"
+  "gitHead": "55512768ac9e57c472c9b03d8e39f606a8c1e1c6"
 }

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

@@ -42,11 +42,6 @@ export async function writeResponseBody(opts: {
         await writeResponseBodyChunk(res, chunk);
         res.flush?.();
       },
-      abort() {
-        if (!res.headersSent) {
-          res.statusCode = 500;
-        }
-      },
     });
 
     await opts.body.pipeTo(writableStream, {

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

@@ -300,9 +300,8 @@ 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 {
     const [infoError, info] = infoTuple;
     if (infoError) {
@@ -465,7 +464,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           });
 
           const stream = sseStreamProducer({
-            ...config.experimental?.sseSubscriptions,
+            ...config.sse,
             data: iterable,
             abortCtrl: result?.abortCtrl ?? new AbortController(),
             serialize: (v) => config.transformer.output.serialize(v),

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

@@ -76,6 +76,7 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
     }>;
 
     const config: RootConfig<$Root> = {
+      ...opts,
       transformer: getDataTransformer(opts?.transformer ?? defaultTransformer),
       isDev:
         opts?.isDev ??
@@ -89,7 +90,6 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
        * @internal
        */
       $types: null as any,
-      experimental: opts?.experimental ?? {},
     };
 
     {

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

@@ -65,26 +65,26 @@ export interface RootConfig<TTypes extends RootTypes> {
 
   defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
 
-  experimental?: {
+  /**
+   * Enable support for returning async iterables and returning deferred promises when using `httpBatchStreamLink`
+   * @default true
+   */
+  iterablesAndDeferreds?: boolean;
+  /**
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   */
+  sse?: {
     /**
-     * Enable support for returning async iterables and returning deferred promises when using `httpBatchStreamLink`
+     * Enable server-sent events (SSE) subscriptions
      * @default true
      */
-    iterablesAndDeferreds?: boolean;
-    /**
-     * Enable support for server-sent events (SSE) subscriptions
-     */
-    sseSubscriptions?: {
-      /**
-       * Enable server-sent events (SSE) subscriptions
-       * @default true
-       */
-      enabled?: boolean;
-    } & Pick<
-      SSEStreamProducerOptions,
-      'ping' | 'emitAndEndImmediately' | 'maxDurationMs'
-    >;
-  };
+    enabled?: boolean;
+  } & Pick<
+    SSEStreamProducerOptions,
+    'ping' | 'emitAndEndImmediately' | 'maxDurationMs'
+  >;
+  experimental?: {};
 }
 
 /**

package/src/unstable-core-do-not-import/rpc/envelopes.ts

@@ -63,14 +63,15 @@ export interface TRPCRequest
 
 export interface TRPCResult<TData = unknown> {
   data: TData;
+  type?: 'data';
+  /**
+   * The id of the message to keep track of in case of a reconnect
+   */
+  id?: string;
 }
 
 export interface TRPCSuccessResponse<TData>
-  extends JSONRPC2.ResultResponse<
-    TRPCResult<TData> & {
-      type?: 'data';
-    }
-  > {}
+  extends JSONRPC2.ResultResponse<TRPCResult<TData>> {}
 
 export interface TRPCErrorResponse<
   TError extends TRPCErrorShape = TRPCErrorShape,
@@ -111,13 +112,7 @@ export interface TRPCResultMessage<TData>
   extends JSONRPC2.ResultResponse<
     | { type: 'started'; data?: never }
     | { type: 'stopped'; data?: never }
-    | (TRPCResult<TData> & {
-        type: 'data';
-        /**
-         * The id of the message to keep track of in case of a reconnect
-         */
-        id?: string;
-      })
+    | TRPCResult<TData>
   > {}
 
 export type TRPCResponseMessage<

package/src/unstable-core-do-not-import/stream/sse.ts

@@ -1,3 +1,4 @@
+import { Unpromise } from '../../vendor/unpromise';
 import { getTRPCErrorFromUnknown } from '../error/TRPCError';
 import { isAbortError } from '../http/isAbortError';
 import type { MaybePromise } from '../types';
@@ -49,6 +50,7 @@ export interface SSEStreamProducerOptions<TValue = unknown> {
   formatError?: (opts: { error: unknown }) => unknown;
 }
 
+const PING_EVENT = 'ping';
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
 
 type SSEvent = Partial<{
@@ -110,7 +112,7 @@ export function sseStreamProducer<TValue = unknown>(
 
       for await (value of iterable) {
         if (value === PING_SYM) {
-          stream.controller.enqueue({ comment: 'ping' });
+          stream.controller.enqueue({ event: PING_EVENT, data: '' });
           continue;
         }
 
@@ -199,12 +201,23 @@ interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig>
   type: 'connecting';
   event: EventSourceLike.EventOf<TConfig['EventSource']> | null;
 }
+interface ConsumerStreamResultTimeout<TConfig extends ConsumerConfig>
+  extends ConsumerStreamResultBase<TConfig> {
+  type: 'timeout';
+}
+
+interface ConsumerStreamResultPing<TConfig extends ConsumerConfig>
+  extends ConsumerStreamResultBase<TConfig> {
+  type: 'ping';
+}
 
 type ConsumerStreamResult<TConfig extends ConsumerConfig> =
   | ConsumerStreamResultData<TConfig>
   | ConsumerStreamResultError<TConfig>
   | ConsumerStreamResultOpened<TConfig>
-  | ConsumerStreamResultConnecting<TConfig>;
+  | ConsumerStreamResultConnecting<TConfig>
+  | ConsumerStreamResultTimeout<TConfig>
+  | ConsumerStreamResultPing<TConfig>;
 
 export interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
   url: () => MaybePromise<string>;
@@ -214,6 +227,10 @@ export interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
   signal: AbortSignal;
   deserialize?: Deserialize;
   EventSource: TConfig['EventSource'];
+  /**
+   * Reconnect after inactivity in milliseconds
+   */
+  reconnectAfterInactivityMs?: number;
 }
 
 interface ConsumerConfig {
@@ -222,6 +239,31 @@ interface ConsumerConfig {
   EventSource: EventSourceLike.AnyConstructor;
 }
 
+async function withTimeout<T>(opts: {
+  promise: Promise<T>;
+  timeoutMs: number;
+  onTimeout: () => Promise<NoInfer<T>>;
+}): Promise<T> {
+  let timeoutId: ReturnType<typeof setTimeout>;
+
+  const timeoutPromise = new Promise<null>((resolve) => {
+    timeoutId = setTimeout(() => {
+      resolve(null);
+    }, opts.timeoutMs);
+  });
+  let res;
+  try {
+    res = await Unpromise.race([opts.promise, timeoutPromise]);
+  } finally {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    clearTimeout(timeoutId!);
+  }
+  if (res === null) {
+    return await opts.onTimeout();
+  }
+  return res;
+}
+
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
@@ -234,99 +276,145 @@ export function sseStreamConsumer<TConfig extends ConsumerConfig>(
 
   let _es: InstanceType<TConfig['EventSource']> | null = null;
 
-  const stream = new ReadableStream<ConsumerStreamResult<TConfig>>({
-    async start(controller) {
-      const [url, init] = await Promise.all([opts.url(), opts.init()]);
-      const eventSource = (_es = new opts.EventSource(
-        url,
-        init,
-      ) as InstanceType<TConfig['EventSource']>);
-
-      controller.enqueue({
-        type: 'connecting',
-        eventSource: _es,
-        event: null,
-      });
-      eventSource.addEventListener('open', () => {
+  const createStream = () =>
+    new ReadableStream<ConsumerStreamResult<TConfig>>({
+      async start(controller) {
+        const [url, init] = await Promise.all([opts.url(), opts.init()]);
+        const eventSource = (_es = new opts.EventSource(
+          url,
+          init,
+        ) as InstanceType<TConfig['EventSource']>);
+
         controller.enqueue({
-          type: 'opened',
-          eventSource,
+          type: 'connecting',
+          eventSource: _es,
+          event: null,
+        });
+        eventSource.addEventListener('open', () => {
+          controller.enqueue({
+            type: 'opened',
+            eventSource,
+          });
         });
-      });
 
-      eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg) => {
-        const msg = _msg as EventSourceLike.MessageEvent;
+        eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg) => {
+          const msg = _msg as EventSourceLike.MessageEvent;
 
-        controller.enqueue({
-          type: 'serialized-error',
-          error: deserialize(JSON.parse(msg.data)),
-          eventSource,
+          controller.enqueue({
+            type: 'serialized-error',
+            error: deserialize(JSON.parse(msg.data)),
+            eventSource,
+          });
         });
-      });
-      eventSource.addEventListener('error', (event) => {
-        if (eventSource.readyState === EventSource.CLOSED) {
-          controller.error(event);
-        } else {
+        eventSource.addEventListener(PING_EVENT, () => {
           controller.enqueue({
-            type: 'connecting',
+            type: 'ping',
             eventSource,
-            event,
           });
-        }
-      });
-      eventSource.addEventListener('message', (_msg) => {
-        const msg = _msg as EventSourceLike.MessageEvent;
+        });
+        eventSource.addEventListener('error', (event) => {
+          if (eventSource.readyState === EventSource.CLOSED) {
+            controller.error(event);
+          } else {
+            controller.enqueue({
+              type: 'connecting',
+              eventSource,
+              event,
+            });
+          }
+        });
+        eventSource.addEventListener('message', (_msg) => {
+          const msg = _msg as EventSourceLike.MessageEvent;
 
-        const chunk = deserialize(JSON.parse(msg.data));
+          const chunk = deserialize(JSON.parse(msg.data));
 
-        const def: SSEvent = {
-          data: chunk,
+          const def: SSEvent = {
+            data: chunk,
+          };
+          if (msg.lastEventId) {
+            def.id = msg.lastEventId;
+          }
+          controller.enqueue({
+            type: 'data',
+            data: def as inferTrackedOutput<TConfig['data']>,
+            eventSource,
+          });
+        });
+
+        const onAbort = () => {
+          controller.close();
+          eventSource.close();
         };
-        if (msg.lastEventId) {
-          def.id = msg.lastEventId;
+        if (signal.aborted) {
+          onAbort();
+        } else {
+          signal.addEventListener('abort', onAbort);
         }
-        controller.enqueue({
-          type: 'data',
-          data: def as inferTrackedOutput<TConfig['data']>,
-          eventSource,
-        });
-      });
+      },
+      cancel() {
+        _es?.close();
+      },
+    });
 
-      const onAbort = () => {
-        controller.close();
-        eventSource.close();
-      };
-      if (signal.aborted) {
-        onAbort();
-      } else {
-        signal.addEventListener('abort', onAbort);
-      }
-    },
-    cancel() {
-      _es?.close();
-    },
-  });
+  const getNewStreamAndReader = () => {
+    const stream = createStream();
+    const reader = stream.getReader();
+
+    return {
+      reader,
+      cancel: () => {
+        reader.releaseLock();
+        return stream.cancel();
+      },
+    };
+  };
   return {
     [Symbol.asyncIterator]() {
-      const reader = stream.getReader();
+      let stream = getNewStreamAndReader();
 
       const iterator: AsyncIterator<ConsumerStreamResult<TConfig>> = {
         async next() {
-          const value = await reader.read();
+          let promise = stream.reader.read();
+
+          if (opts.reconnectAfterInactivityMs) {
+            promise = withTimeout({
+              promise,
+              timeoutMs: opts.reconnectAfterInactivityMs,
+              onTimeout: async () => {
+                // Close and release old reader
+                await stream.cancel();
+
+                // Create new reader
+                stream = getNewStreamAndReader();
+
+                return {
+                  value: {
+                    type: 'timeout',
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    eventSource: _es!,
+                  },
+                  done: false,
+                };
+              },
+            });
+          }
+
+          const result = await promise;
 
-          if (value.done) {
+          // console.debug('result', result, 'done', result.done);
+          if (result.done) {
             return {
-              value: undefined,
+              value: result.value,
               done: true,
             };
           }
           return {
-            value: value.value,
+            value: result.value,
             done: false,
           };
         },
         async return() {
-          reader.releaseLock();
+          await stream.cancel();
           return {
             value: undefined,
             done: true,