@trpc/server 11.0.0-rc.569 → 11.0.0-rc.576

package/dist/unstable-core-do-not-import/stream/utils/withPing.mjs

@@ -0,0 +1,34 @@
+import { createPromiseTimer } from './promiseTimer.mjs';
+
+const PING_SYM = Symbol('ping');
+const PING_RESULT = {
+    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}.
+ */ async function* withPing(iterable, pingIntervalMs) {
+    const timer = createPromiseTimer(pingIntervalMs);
+    const iterator = iterable[Symbol.asyncIterator]();
+    while(true){
+        const nextPromise = iterator.next();
+        const pingPromise = timer.start().promise.then(()=>PING_RESULT);
+        let result;
+        try {
+            result = await Promise.race([
+                nextPromise,
+                pingPromise
+            ]);
+        } finally{
+            timer.clear();
+        }
+        if (result.done) {
+            return result.value;
+        }
+        yield result.value;
+        timer.reset();
+    }
+}
+
+export { PING_SYM, withPing };

package/dist/unstable-core-do-not-import/utils.d.ts

@@ -23,5 +23,7 @@ export declare function isAsyncIterable<TValue>(value: unknown): value is AsyncI
  * Run an IIFE
  */
 export declare const run: <TValue>(fn: () => TValue) => TValue;
+export declare function noop(): void;
+export declare function identity<T>(it: T): T;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/unstable-core-do-not-import/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/utils.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,eAAO,MAAM,WAAW,eAAW,CAAC;AACpC,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,GACxB,KAAK,CAYP;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,KAAK,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,EAAE,OAAO,CAAC,CAAC;AACxE,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,KAAK,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,GAAG,EAAE,IAAI,GACR,IAAI,CAEN;AAKD,wBAAgB,eAAe,CAAC,MAAM,EACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,aAAa,CAAC,MAAM,CAAC,CAIhC;AAED;;GAEG;AACH,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,MAAM,MAAM,KAAG,MAAc,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/utils.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,eAAO,MAAM,WAAW,eAAW,CAAC;AACpC,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,GACxB,KAAK,CAYP;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,KAAK,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,EAAE,OAAO,CAAC,CAAC;AACxE,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,KAAK,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,GAAG,EAAE,IAAI,GACR,IAAI,CAEN;AAKD,wBAAgB,eAAe,CAAC,MAAM,EACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,aAAa,CAAC,MAAM,CAAC,CAIhC;AAED;;GAEG;AACH,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,MAAM,MAAM,KAAG,MAAc,CAAC;AAG9D,wBAAgB,IAAI,IAAI,IAAI,CAAG;AAE/B,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAEpC"}

package/dist/unstable-core-do-not-import/utils.js

@@ -38,11 +38,18 @@ function isAsyncIterable(value) {
 /**
  * Run an IIFE
  */ const run = (fn)=>fn();
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() {}
+function identity(it) {
+    return it;
+}
 
+exports.identity = identity;
 exports.isAsyncIterable = isAsyncIterable;
 exports.isFunction = isFunction;
 exports.isObject = isObject;
 exports.mergeWithoutOverrides = mergeWithoutOverrides;
+exports.noop = noop;
 exports.omitPrototype = omitPrototype;
 exports.run = run;
 exports.unsetMarker = unsetMarker;

package/dist/unstable-core-do-not-import/utils.mjs

@@ -36,5 +36,10 @@ function isAsyncIterable(value) {
 /**
  * Run an IIFE
  */ const run = (fn)=>fn();
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() {}
+function identity(it) {
+    return it;
+}
 
-export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, run, unsetMarker };
+export { identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, unsetMarker };

package/dist/unstable-core-do-not-import.js

@@ -74,15 +74,16 @@ exports.isTrackedEnvelope = tracked.isTrackedEnvelope;
 exports.sse = tracked.sse;
 exports.tracked = tracked.tracked;
 exports.createDeferred = createDeferred.createDeferred;
-exports.createTimeoutPromise = createDeferred.createTimeoutPromise;
 exports.defaultTransformer = transformer.defaultTransformer;
 exports.getDataTransformer = transformer.getDataTransformer;
 exports.transformResult = transformer.transformResult;
 exports.transformTRPCResponse = transformer.transformTRPCResponse;
+exports.identity = utils.identity;
 exports.isAsyncIterable = utils.isAsyncIterable;
 exports.isFunction = utils.isFunction;
 exports.isObject = utils.isObject;
 exports.mergeWithoutOverrides = utils.mergeWithoutOverrides;
+exports.noop = utils.noop;
 exports.omitPrototype = utils.omitPrototype;
 exports.run = utils.run;
 exports.unsetMarker = utils.unsetMarker;

package/dist/unstable-core-do-not-import.mjs

@@ -22,6 +22,6 @@ export { parseTRPCMessage } from './unstable-core-do-not-import/rpc/parseTRPCMes
 export { isPromise, jsonlStreamConsumer, jsonlStreamProducer } from './unstable-core-do-not-import/stream/jsonl.mjs';
 export { sseHeaders, sseStreamConsumer, sseStreamProducer } from './unstable-core-do-not-import/stream/sse.mjs';
 export { isTrackedEnvelope, sse, tracked } from './unstable-core-do-not-import/stream/tracked.mjs';
-export { createDeferred, createTimeoutPromise } from './unstable-core-do-not-import/stream/utils/createDeferred.mjs';
+export { createDeferred } from './unstable-core-do-not-import/stream/utils/createDeferred.mjs';
 export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
-export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, run, unsetMarker } from './unstable-core-do-not-import/utils.mjs';
+export { identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, unsetMarker } from './unstable-core-do-not-import/utils.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.569+8049266de",
+  "version": "11.0.0-rc.576+deed81c1b",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -149,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "8049266dee912f1d98542f6baf750ee11b45b5ad"
+  "gitHead": "deed81c1b24b29bb028075af56cef3b3329e2a8e"
 }

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

@@ -1,10 +1,14 @@
 import { getTRPCErrorFromUnknown } from '../error/TRPCError';
 import type { MaybePromise } from '../types';
-import { run } from '../utils';
+import { identity, run } from '../utils';
 import type { inferTrackedOutput } from './tracked';
 import { isTrackedEnvelope } from './tracked';
-import { createDeferred, createTimeoutPromise } from './utils/createDeferred';
+import { takeWithGrace, withCancel } from './utils/asyncIterable';
+import { createDeferred } from './utils/createDeferred';
 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;
 type Deserialize = (value: any) => any;
@@ -25,9 +29,9 @@ export interface PingOptions {
   intervalMs?: number;
 }
 
-export interface SSEStreamProducerOptions {
+export interface SSEStreamProducerOptions<TValue = unknown> {
   serialize?: Serialize;
-  data: AsyncIterable<unknown>;
+  data: AsyncIterable<TValue>;
   maxDepth?: number;
   ping?: PingOptions;
   /**
@@ -57,13 +61,11 @@ type SSEvent = Partial<{
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-export function sseStreamProducer(opts: SSEStreamProducerOptions) {
+export function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptions<TValue>) {
   const stream = createReadableStream<SSEvent>();
-  stream.controller.enqueue({
-    comment: 'connected',
-  });
+  stream.controller.enqueue({ comment: 'connected' });
 
-  const { serialize = (v) => v } = opts;
+  const { serialize = identity } = opts;
 
   const ping: Required<PingOptions> = {
     enabled: opts.ping?.enabled ?? false,
@@ -71,96 +73,63 @@ export function sseStreamProducer(opts: SSEStreamProducerOptions) {
   };
 
   run(async () => {
-    const iterator = opts.data[Symbol.asyncIterator]();
-
-    const closedPromise = stream.cancelledPromise.then(() => 'closed' as const);
-    const maxDurationPromise = createTimeoutPromise(
-      opts.maxDurationMs ?? Infinity,
-      'maxDuration' as const,
-    );
-
-    let nextPromise = iterator.next();
-
-    while (true) {
-      const pingPromise = createTimeoutPromise(
-        ping.enabled ? ping.intervalMs : Infinity,
-        'ping' as const,
-      );
-      const next = await Promise.race([
-        nextPromise.catch((err) => {
-          if (err instanceof Error && err.name === 'AbortError') {
-            // Ensures that aborting the request doesn't throw an error
-            return 'aborted' as const;
-          }
-          return getTRPCErrorFromUnknown(err);
-        }),
-        pingPromise.promise,
-        closedPromise,
-        maxDurationPromise.promise,
-      ]);
-
-      pingPromise.clear();
-      if (next === 'aborted') {
-        break;
-      }
-      if (next === 'closed') {
-        break;
-      }
-      if (next === 'maxDuration') {
-        break;
-      }
+    let iterable: AsyncIterable<TValue | typeof PING_SYM> = opts.data;
+    
+    iterable = withCancel(iterable, stream.cancelledPromise);
 
-      if (next === 'ping') {
-        stream.controller.enqueue({
-          comment: 'ping',
-        });
-        continue;
-      }
+    if (opts.emitAndEndImmediately) {
+      iterable = takeWithGrace(iterable, { count: 1, gracePeriodMs: 1 });
+    }
 
-      if (next instanceof Error) {
-        const data = opts.formatError
-          ? opts.formatError({ error: next })
-          : null;
-        stream.controller.enqueue({
-          event: SERIALIZED_ERROR_EVENT,
-          data: JSON.stringify(serialize(data)),
-        });
-        break;
-      }
-      if (next.done) {
-        break;
-      }
+    let maxDurationTimer: PromiseTimer | null = null;
+    if (
+      opts.maxDurationMs != null &&
+      opts.maxDurationMs > 0 &&
+      opts.maxDurationMs !== Infinity
+    ) {
+      maxDurationTimer = createPromiseTimer(opts.maxDurationMs).start();
+      iterable = withCancel(iterable, maxDurationTimer.promise);
+    }
 
-      const value = next.value;
+    if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
+      iterable = withPing(iterable, ping.intervalMs);
+    }
 
-      const chunk: SSEvent = isTrackedEnvelope(value)
-        ? {
-            id: value[0],
-            data: value[1],
-          }
-        : {
-            data: value,
-          };
-      if ('data' in chunk) {
-        chunk.data = JSON.stringify(serialize(chunk.data));
-      }
+    try {
+      for await (const value of iterable) {
+        if (value === PING_SYM) {
+          stream.controller.enqueue({ comment: 'ping' });
+          continue;
+        }
 
-      stream.controller.enqueue(chunk);
+        const chunk: SSEvent = isTrackedEnvelope(value)
+          ? { id: value[0], data: value[1] }
+          : { data: value };
+        if ('data' in chunk) {
+          chunk.data = JSON.stringify(serialize(chunk.data));
+        }
 
-      if (opts.emitAndEndImmediately) {
-        // end the stream in the next tick so that we can send a few more events from the queue
-        setTimeout(maxDurationPromise.resolve, 1);
+        stream.controller.enqueue(chunk);
       }
-
-      nextPromise = iterator.next();
-    }
-    maxDurationPromise.clear();
-    await iterator.return?.();
-    try {
+    } 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)),
+        });
+      }
+    } finally {
+      maxDurationTimer?.clear();
       stream.controller.close();
-    } catch {}
-  }).catch((error) => {
-    return stream.controller.error(error);
+    }
+  }).catch((err) => {
+    // should not be reached; just in case...
+    stream.controller.error(err);
   });
 
   return stream.readable.pipeThrough(

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

@@ -0,0 +1,62 @@
+import { noop } from '../../utils';
+import { createPromiseTimer } from './promiseTimer';
+
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that automatically stops with the
+ * passed {@link cancel} promise.
+ */
+export async function* withCancel<T>(
+  iterable: AsyncIterable<T>,
+  cancel: Promise<unknown>,
+): AsyncGenerator<T> {
+  const cancelPromise = cancel.then(noop);
+  const iterator = iterable[Symbol.asyncIterator]();
+  while (true) {
+    const result = await Promise.race([iterator.next(), cancelPromise]);
+    if (result == null) {
+      await iterator.return?.();
+      break;
+    }
+    if (result.done) {
+      break;
+    }
+    yield result.value;
+  }
+}
+
+interface TakeWithGraceOptions {
+  count: number;
+  gracePeriodMs: number;
+}
+
+/**
+ * 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
+ * values may still come through. After this period, the generator stops.
+ */
+export async function* takeWithGrace<T>(
+  iterable: AsyncIterable<T>,
+  { count, gracePeriodMs }: TakeWithGraceOptions,
+): AsyncGenerator<T> {
+  const iterator = iterable[Symbol.asyncIterator]();
+  const timer = createPromiseTimer(gracePeriodMs);
+  try {
+    while (true) {
+      const result = await Promise.race([iterator.next(), timer.promise]);
+      if (result == null) {
+        // cancelled
+        await iterator.return?.();
+        break;
+      }
+      if (result.done) {
+        break;
+      }
+      yield result.value;
+      if (--count === 0) {
+        timer.start();
+      }
+    }
+  } finally {
+    timer.clear();
+  }
+}

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

@@ -10,39 +10,3 @@ export function createDeferred<TValue>() {
   return { promise, resolve: resolve!, reject: reject! };
 }
 export type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
-
-export const createTimeoutPromise = <TValue>(
-  timeoutMs: number,
-  value: TValue,
-) => {
-  let deferred = createDeferred<TValue>();
-  deferred = deferred as typeof deferred & { clear: () => void };
-
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-  const clear = () => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = null;
-    }
-  };
-  const resolve = () => {
-    deferred.resolve(value);
-    clear();
-  };
-  if (timeoutMs !== Infinity) {
-    timeout = setTimeout(resolve, timeoutMs);
-    timeout.unref?.();
-  }
-
-  return {
-    promise: deferred.promise,
-    /**
-     * Clear the timeout without resolving the promise
-     */
-    clear,
-    /**
-     * Resolve the promise with the value
-     */
-    resolve,
-  };
-};

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

@@ -0,0 +1,40 @@
+import { createDeferred } from './createDeferred';
+
+export function createPromiseTimer(ms: number) {
+  let deferred = createDeferred<void>();
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+
+  const timer = {
+    get promise() {
+      return deferred.promise;
+    },
+
+    start,
+    reset,
+    clear,
+  };
+  return timer;
+
+  function start(): PromiseTimer {
+    if (timeout != null) {
+      throw new Error("PromiseTimer already started.");
+    }
+    timeout = setTimeout(deferred.resolve, ms);
+    return timer;
+  }
+
+  function reset(): PromiseTimer {
+    clear();
+    deferred = createDeferred();
+    return timer;
+  }
+
+  function clear(): PromiseTimer {
+    if (timeout != null) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    return timer;
+  }
+}
+export type PromiseTimer = ReturnType<typeof createPromiseTimer>;

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

@@ -0,0 +1,35 @@
+import { createPromiseTimer } from './promiseTimer';
+
+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}.
+ */
+export async function* withPing<TValue>(
+  iterable: AsyncIterable<TValue>,
+  pingIntervalMs: number,
+): AsyncGenerator<TValue | typeof PING_SYM> {
+  const timer = createPromiseTimer(pingIntervalMs);
+  const iterator = iterable[Symbol.asyncIterator]();
+  while (true) {
+    const nextPromise = iterator.next();
+    const pingPromise = timer.start().promise.then(() => PING_RESULT);
+    let result: IteratorResult<TValue | typeof PING_SYM>;
+    try {
+      result = await Promise.race([nextPromise, pingPromise]);
+    } finally {
+      timer.clear();
+    }
+    if (result.done) {
+      return result.value;
+    }
+    yield result.value;
+    timer.reset();
+  }
+}

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

@@ -61,3 +61,10 @@ export function isAsyncIterable<TValue>(
  * Run an IIFE
  */
 export const run = <TValue>(fn: () => TValue): TValue => fn();
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop(): void {}
+
+export function identity<T>(it: T): T {
+  return it;
+}