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

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

@@ -1,13 +1,13 @@
+import { Unpromise } from '../../vendor/unpromise';
 import { getTRPCErrorFromUnknown } from '../error/TRPCError';
+import { isAbortError } from '../http/isAbortError';
 import type { MaybePromise } from '../types';
 import { identity, run } from '../utils';
 import type { EventSourceLike } from './sse.types';
 import type { inferTrackedOutput } from './tracked';
 import { isTrackedEnvelope } from './tracked';
-import { takeWithGrace, withCancel } from './utils/asyncIterable';
+import { takeWithGrace, withMaxDuration } from './utils/asyncIterable';
 import { createReadableStream } from './utils/createReadableStream';
-import type { PromiseTimer } from './utils/promiseTimer';
-import { createPromiseTimer } from './utils/promiseTimer';
 import { PING_SYM, withPing } from './utils/withPing';
 
 type Serialize = (value: any) => any;
@@ -50,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<{
@@ -80,27 +81,23 @@ export function sseStreamProducer<TValue = unknown>(
 
     let iterable: AsyncIterable<TValue | typeof PING_SYM> = opts.data;
 
-    iterable = withCancel(iterable, stream.cancelledPromise);
-
     if (opts.emitAndEndImmediately) {
       iterable = takeWithGrace(iterable, {
         count: 1,
         gracePeriodMs: 1,
-        onCancel: () => opts.abortCtrl.abort(),
+        abortCtrl: opts.abortCtrl,
       });
     }
 
-    let maxDurationTimer: PromiseTimer | null = null;
     if (
-      opts.maxDurationMs != null &&
+      opts.maxDurationMs &&
       opts.maxDurationMs > 0 &&
       opts.maxDurationMs !== Infinity
     ) {
-      maxDurationTimer = createPromiseTimer(opts.maxDurationMs).start();
-      iterable = withCancel(
-        iterable,
-        maxDurationTimer.promise.then(() => opts.abortCtrl.abort()),
-      );
+      iterable = withMaxDuration(iterable, {
+        maxDurationMs: opts.maxDurationMs,
+        abortCtrl: opts.abortCtrl,
+      });
     }
 
     if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
@@ -115,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;
         }
 
@@ -133,20 +130,24 @@ export function sseStreamProducer<TValue = unknown>(
         chunk = null;
       }
     } catch (err) {
-      // ignore abort errors, send any other errors
-      if (!(err instanceof Error) || err.name !== 'AbortError') {
-        // `err` must be caused by `opts.data`, `JSON.stringify` or `serialize`.
-        // So, a user error in any case.
-        const error = getTRPCErrorFromUnknown(err);
-        const data = opts.formatError?.({ error }) ?? null;
-        stream.controller.enqueue({
-          event: SERIALIZED_ERROR_EVENT,
-          data: JSON.stringify(serialize(data)),
-        });
+      if (isAbortError(err)) {
+        // ignore abort errors, send any other errors
+        return;
       }
+      // `err` must be caused by `opts.data`, `JSON.stringify` or `serialize`.
+      // So, a user error in any case.
+      const error = getTRPCErrorFromUnknown(err);
+      const data = opts.formatError?.({ error }) ?? null;
+      stream.controller.enqueue({
+        event: SERIALIZED_ERROR_EVENT,
+        data: JSON.stringify(serialize(data)),
+      });
     } finally {
-      maxDurationTimer?.clear();
-      stream.controller.close();
+      try {
+        stream.controller.close();
+      } catch {
+        // ignore
+      }
     }
   }).catch((err) => {
     // should not be reached; just in case...
@@ -200,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>;
@@ -215,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 {
@@ -223,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
  */
@@ -235,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,
+          };
+          if (msg.lastEventId) {
+            def.id = msg.lastEventId;
+          }
+          controller.enqueue({
+            type: 'data',
+            data: def as inferTrackedOutput<TConfig['data']>,
+            eventSource,
+          });
+        });
 
-        const def: SSEvent = {
-          data: chunk,
+        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,

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

@@ -1,40 +1,47 @@
 import { Unpromise } from '../../../vendor/unpromise';
-import { noop } from '../../utils';
-import { createPromiseTimer } from './promiseTimer';
+import {
+  disposablePromiseTimer,
+  disposablePromiseTimerResult,
+} from './disposablePromiseTimer';
 
 /**
- * Derives a new {@link AsyncGenerator} based of {@link iterable}, that automatically stops with the
- * passed {@link cancel} promise.
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */
-export async function* withCancel<T>(
+export async function* withMaxDuration<T>(
   iterable: AsyncIterable<T>,
-  cancel: Promise<unknown>,
+  opts: { maxDurationMs: number; abortCtrl: AbortController },
 ): AsyncGenerator<T> {
-  const cancelPromise = cancel.then(noop);
   const iterator = iterable[Symbol.asyncIterator]();
-  // declaration outside the loop for garbage collection reasons
-  let result: null | IteratorResult<T> | void;
-  while (true) {
-    result = await Unpromise.race([iterator.next(), cancelPromise]);
-    if (result == null) {
-      await iterator.return?.();
-      break;
-    }
-    if (result.done) {
-      break;
+
+  const timer = disposablePromiseTimer(opts.maxDurationMs);
+  try {
+    const timerPromise = timer.start();
+
+    // declaration outside the loop for garbage collection reasons
+    let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
+
+    while (true) {
+      result = await Unpromise.race([iterator.next(), timerPromise]);
+      if (result === disposablePromiseTimerResult) {
+        // cancelled due to timeout
+        opts.abortCtrl.abort();
+        const res = await iterator.return?.();
+        return res?.value;
+      }
+      if (result.done) {
+        return result;
+      }
+      yield result.value;
+      // free up reference for garbage collection
+      result = null;
     }
-    yield result.value;
-    // free up reference for garbage collection
-    result = null;
+  } finally {
+    // dispose timer
+    // Shouldn't be needed, but build breaks with `using` keyword
+    timer[Symbol.dispose]();
   }
 }
 
-interface TakeWithGraceOptions {
-  count: number;
-  gracePeriodMs: number;
-  onCancel: () => void;
-}
-
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
  * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
@@ -42,31 +49,45 @@ interface TakeWithGraceOptions {
  */
 export async function* takeWithGrace<T>(
   iterable: AsyncIterable<T>,
-  { count, gracePeriodMs, onCancel }: TakeWithGraceOptions,
+  opts: {
+    count: number;
+    gracePeriodMs: number;
+    abortCtrl: AbortController;
+  },
 ): AsyncGenerator<T> {
   const iterator = iterable[Symbol.asyncIterator]();
-  const timer = createPromiseTimer(gracePeriodMs);
+
+  // declaration outside the loop for garbage collection reasons
+  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
+
+  const timer = disposablePromiseTimer(opts.gracePeriodMs);
   try {
-    // declaration outside the loop for garbage collection reasons
-    let result: null | IteratorResult<T> | void;
+    let count = opts.count;
+
+    let timerPromise = new Promise<typeof disposablePromiseTimerResult>(() => {
+      // never resolves
+    });
+
     while (true) {
-      result = await Unpromise.race([iterator.next(), timer.promise]);
-      if (result == null) {
+      result = await Unpromise.race([iterator.next(), timerPromise]);
+      if (result === disposablePromiseTimerResult) {
         // cancelled
-        await iterator.return?.();
-        break;
+        const res = await iterator.return?.();
+        return res?.value;
       }
       if (result.done) {
-        break;
+        return result.value;
       }
       yield result.value;
       if (--count === 0) {
-        timer.start().promise.then(onCancel, noop);
+        timerPromise = timer.start();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        timerPromise.then(() => opts.abortCtrl.abort());
       }
       // free up reference for garbage collection
       result = null;
     }
   } finally {
-    timer.clear();
+    timer[Symbol.dispose]();
   }
 }

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

@@ -1,8 +1,3 @@
-import { createDeferred } from './createDeferred';
-
-// ---------- utils
-
-const cancelledStreamSymbol = Symbol();
 /**
  * One-off readable stream
  */
@@ -10,14 +5,12 @@ export function createReadableStream<TValue = unknown>() {
   let controller: ReadableStreamDefaultController<TValue> =
     null as unknown as ReadableStreamDefaultController<TValue>;
 
-  const deferred = createDeferred<typeof cancelledStreamSymbol>();
   let cancelled = false;
   const readable = new ReadableStream<TValue>({
     start(c) {
       controller = c;
     },
     cancel() {
-      deferred.resolve(cancelledStreamSymbol);
       cancelled = true;
     },
   });
@@ -25,14 +18,8 @@ export function createReadableStream<TValue = unknown>() {
   return {
     readable,
     controller,
-    cancelledPromise: deferred.promise,
     cancelled() {
       return cancelled;
     },
   } as const;
 }
-export function isCancelledStreamResult(
-  v: unknown,
-): v is typeof cancelledStreamSymbol {
-  return v === cancelledStreamSymbol;
-}

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

@@ -0,0 +1,27 @@
+// @ts-expect-error polyfill
+Symbol.dispose ??= Symbol();
+
+export const disposablePromiseTimerResult = Symbol();
+export function disposablePromiseTimer(ms: number) {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  return {
+    start() {
+      if (timer) {
+        throw new Error('Timer already started');
+      }
+
+      const promise = new Promise<typeof disposablePromiseTimerResult>(
+        (resolve) => {
+          timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
+        },
+      );
+      return promise;
+    },
+    [Symbol.dispose]: () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    },
+  };
+}

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

@@ -1,13 +1,11 @@
 import { Unpromise } from '../../../vendor/unpromise';
-import { createPromiseTimer } from './promiseTimer';
+import {
+  disposablePromiseTimer,
+  disposablePromiseTimerResult,
+} from './disposablePromiseTimer';
 
 export const PING_SYM = Symbol('ping');
 
-const PING_RESULT: IteratorResult<typeof PING_SYM> = {
-  value: PING_SYM,
-  done: false,
-};
-
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
  * whenever no value has been yielded for {@link pingIntervalMs}.
@@ -16,24 +14,38 @@ export async function* withPing<TValue>(
   iterable: AsyncIterable<TValue>,
   pingIntervalMs: number,
 ): AsyncGenerator<TValue | typeof PING_SYM> {
-  const timer = createPromiseTimer(pingIntervalMs);
   const iterator = iterable[Symbol.asyncIterator]();
   // declaration outside the loop for garbage collection reasons
-  let result: null | IteratorResult<TValue | typeof PING_SYM>;
+  let result:
+    | null
+    | IteratorResult<TValue>
+    | typeof disposablePromiseTimerResult;
+
+  let nextPromise = iterator.next();
   while (true) {
-    const nextPromise = iterator.next();
-    const pingPromise = timer.start().promise.then(() => PING_RESULT);
+    const pingPromise = disposablePromiseTimer(pingIntervalMs);
+
     try {
-      result = await Unpromise.race([nextPromise, pingPromise]);
+      result = await Unpromise.race([nextPromise, pingPromise.start()]);
+
+      if (result === disposablePromiseTimerResult) {
+        // cancelled
+
+        yield PING_SYM;
+        continue;
+      }
+
+      if (result.done) {
+        return result.value;
+      }
+
+      nextPromise = iterator.next();
+      yield result.value;
+
+      // free up reference for garbage collection
+      result = null;
     } finally {
-      timer.clear();
-    }
-    if (result.done) {
-      return result.value;
+      pingPromise[Symbol.dispose]();
     }
-    yield result.value;
-    timer.reset();
-    // free up reference for garbage collection
-    result = null;
   }
 }