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

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

@@ -1,13 +1,15 @@
 'use strict';
 
+var unpromise = require('../../vendor/unpromise/unpromise.js');
 var TRPCError = require('../error/TRPCError.js');
+var isAbortError = require('../http/isAbortError.js');
 var utils = require('../utils.js');
 var tracked = require('./tracked.js');
 var asyncIterable = require('./utils/asyncIterable.js');
 var createReadableStream = require('./utils/createReadableStream.js');
-var promiseTimer = require('./utils/promiseTimer.js');
 var withPing = require('./utils/withPing.js');
 
+const PING_EVENT = 'ping';
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
 /**
  *
@@ -24,18 +26,18 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
     };
     utils.run(async ()=>{
         let iterable = opts.data;
-        iterable = asyncIterable.withCancel(iterable, stream.cancelledPromise);
         if (opts.emitAndEndImmediately) {
             iterable = asyncIterable.takeWithGrace(iterable, {
                 count: 1,
                 gracePeriodMs: 1,
-                onCancel: ()=>opts.abortCtrl.abort()
+                abortCtrl: opts.abortCtrl
             });
         }
-        let maxDurationTimer = null;
-        if (opts.maxDurationMs != null && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
-            maxDurationTimer = promiseTimer.createPromiseTimer(opts.maxDurationMs).start();
-            iterable = asyncIterable.withCancel(iterable, maxDurationTimer.promise.then(()=>opts.abortCtrl.abort()));
+        if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            iterable = asyncIterable.withMaxDuration(iterable, {
+                maxDurationMs: opts.maxDurationMs,
+                abortCtrl: opts.abortCtrl
+            });
         }
         if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
             iterable = withPing.withPing(iterable, ping.intervalMs);
@@ -48,7 +50,8 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
             for await (value of iterable){
                 if (value === withPing.PING_SYM) {
                     stream.controller.enqueue({
-                        comment: 'ping'
+                        event: PING_EVENT,
+                        data: ''
                     });
                     continue;
                 }
@@ -67,22 +70,26 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
                 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 = TRPCError.getTRPCErrorFromUnknown(err);
-                const data = opts.formatError?.({
-                    error
-                }) ?? null;
-                stream.controller.enqueue({
-                    event: SERIALIZED_ERROR_EVENT,
-                    data: JSON.stringify(serialize(data))
-                });
+            if (isAbortError.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 = TRPCError.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...
@@ -106,97 +113,158 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
         }
     }));
 }
+async function withTimeout(opts) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve)=>{
+        timeoutId = setTimeout(()=>{
+            resolve(null);
+        }, opts.timeoutMs);
+    });
+    let res;
+    try {
+        res = await unpromise.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
  */ function sseStreamConsumer(opts) {
     const { deserialize = (v)=>v } = opts;
     const signal = opts.signal;
     let _es = null;
-    const stream = new ReadableStream({
-        async start (controller) {
-            const [url, init] = await Promise.all([
-                opts.url(),
-                opts.init()
-            ]);
-            const eventSource = _es = new opts.EventSource(url, init);
-            controller.enqueue({
-                type: 'connecting',
-                eventSource: _es,
-                event: null
-            });
-            eventSource.addEventListener('open', ()=>{
+    const createStream = ()=>new ReadableStream({
+            async start (controller) {
+                const [url, init] = await Promise.all([
+                    opts.url(),
+                    opts.init()
+                ]);
+                const eventSource = _es = new opts.EventSource(url, init);
                 controller.enqueue({
-                    type: 'opened',
-                    eventSource
+                    type: 'connecting',
+                    eventSource: _es,
+                    event: null
                 });
-            });
-            eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
-                const msg = _msg;
-                controller.enqueue({
-                    type: 'serialized-error',
-                    error: deserialize(JSON.parse(msg.data)),
-                    eventSource
+                eventSource.addEventListener('open', ()=>{
+                    controller.enqueue({
+                        type: 'opened',
+                        eventSource
+                    });
                 });
-            });
-            eventSource.addEventListener('error', (event)=>{
-                if (eventSource.readyState === EventSource.CLOSED) {
-                    controller.error(event);
-                } else {
+                eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
+                    const msg = _msg;
                     controller.enqueue({
-                        type: 'connecting',
-                        eventSource,
-                        event
+                        type: 'serialized-error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource
                     });
-                }
-            });
-            eventSource.addEventListener('message', (_msg)=>{
-                const msg = _msg;
-                const chunk = deserialize(JSON.parse(msg.data));
-                const def = {
-                    data: chunk
+                });
+                eventSource.addEventListener(PING_EVENT, ()=>{
+                    controller.enqueue({
+                        type: 'ping',
+                        eventSource
+                    });
+                });
+                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;
+                    const chunk = deserialize(JSON.parse(msg.data));
+                    const def = {
+                        data: chunk
+                    };
+                    if (msg.lastEventId) {
+                        def.id = msg.lastEventId;
+                    }
+                    controller.enqueue({
+                        type: 'data',
+                        data: def,
+                        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,
-                    eventSource
-                });
-            });
-            const onAbort = ()=>{
-                controller.close();
-                eventSource.close();
-            };
-            if (signal.aborted) {
-                onAbort();
-            } else {
-                signal.addEventListener('abort', onAbort);
+            },
+            cancel () {
+                _es?.close();
             }
-        },
-        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 = {
                 async next () {
-                    const value = await reader.read();
-                    if (value.done) {
+                    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;
+                    // 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/dist/unstable-core-do-not-import/stream/sse.mjs

@@ -1,11 +1,13 @@
+import { Unpromise } from '../../vendor/unpromise/unpromise.mjs';
 import { getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
+import { isAbortError } from '../http/isAbortError.mjs';
 import { run, identity } from '../utils.mjs';
 import { isTrackedEnvelope } from './tracked.mjs';
-import { withCancel, takeWithGrace } from './utils/asyncIterable.mjs';
+import { takeWithGrace, withMaxDuration } from './utils/asyncIterable.mjs';
 import { createReadableStream } from './utils/createReadableStream.mjs';
-import { createPromiseTimer } from './utils/promiseTimer.mjs';
 import { withPing, PING_SYM } from './utils/withPing.mjs';
 
+const PING_EVENT = 'ping';
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
 /**
  *
@@ -22,18 +24,18 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
     };
     run(async ()=>{
         let iterable = 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 = null;
-        if (opts.maxDurationMs != null && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
-            maxDurationTimer = createPromiseTimer(opts.maxDurationMs).start();
-            iterable = withCancel(iterable, maxDurationTimer.promise.then(()=>opts.abortCtrl.abort()));
+        if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            iterable = withMaxDuration(iterable, {
+                maxDurationMs: opts.maxDurationMs,
+                abortCtrl: opts.abortCtrl
+            });
         }
         if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
             iterable = withPing(iterable, ping.intervalMs);
@@ -46,7 +48,8 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
             for await (value of iterable){
                 if (value === PING_SYM) {
                     stream.controller.enqueue({
-                        comment: 'ping'
+                        event: PING_EVENT,
+                        data: ''
                     });
                     continue;
                 }
@@ -65,22 +68,26 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
                 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...
@@ -104,97 +111,158 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
         }
     }));
 }
+async function withTimeout(opts) {
+    let timeoutId;
+    const timeoutPromise = new Promise((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
  */ function sseStreamConsumer(opts) {
     const { deserialize = (v)=>v } = opts;
     const signal = opts.signal;
     let _es = null;
-    const stream = new ReadableStream({
-        async start (controller) {
-            const [url, init] = await Promise.all([
-                opts.url(),
-                opts.init()
-            ]);
-            const eventSource = _es = new opts.EventSource(url, init);
-            controller.enqueue({
-                type: 'connecting',
-                eventSource: _es,
-                event: null
-            });
-            eventSource.addEventListener('open', ()=>{
+    const createStream = ()=>new ReadableStream({
+            async start (controller) {
+                const [url, init] = await Promise.all([
+                    opts.url(),
+                    opts.init()
+                ]);
+                const eventSource = _es = new opts.EventSource(url, init);
                 controller.enqueue({
-                    type: 'opened',
-                    eventSource
+                    type: 'connecting',
+                    eventSource: _es,
+                    event: null
                 });
-            });
-            eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
-                const msg = _msg;
-                controller.enqueue({
-                    type: 'serialized-error',
-                    error: deserialize(JSON.parse(msg.data)),
-                    eventSource
+                eventSource.addEventListener('open', ()=>{
+                    controller.enqueue({
+                        type: 'opened',
+                        eventSource
+                    });
                 });
-            });
-            eventSource.addEventListener('error', (event)=>{
-                if (eventSource.readyState === EventSource.CLOSED) {
-                    controller.error(event);
-                } else {
+                eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
+                    const msg = _msg;
                     controller.enqueue({
-                        type: 'connecting',
-                        eventSource,
-                        event
+                        type: 'serialized-error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource
                     });
-                }
-            });
-            eventSource.addEventListener('message', (_msg)=>{
-                const msg = _msg;
-                const chunk = deserialize(JSON.parse(msg.data));
-                const def = {
-                    data: chunk
+                });
+                eventSource.addEventListener(PING_EVENT, ()=>{
+                    controller.enqueue({
+                        type: 'ping',
+                        eventSource
+                    });
+                });
+                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;
+                    const chunk = deserialize(JSON.parse(msg.data));
+                    const def = {
+                        data: chunk
+                    };
+                    if (msg.lastEventId) {
+                        def.id = msg.lastEventId;
+                    }
+                    controller.enqueue({
+                        type: 'data',
+                        data: def,
+                        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,
-                    eventSource
-                });
-            });
-            const onAbort = ()=>{
-                controller.close();
-                eventSource.close();
-            };
-            if (signal.aborted) {
-                onAbort();
-            } else {
-                signal.addEventListener('abort', onAbort);
+            },
+            cancel () {
+                _es?.close();
             }
-        },
-        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 = {
                 async next () {
-                    const value = await reader.read();
-                    if (value.done) {
+                    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;
+                    // 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/dist/unstable-core-do-not-import/stream/utils/asyncIterable.d.ts

@@ -1,18 +1,18 @@
 /**
- * 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 declare function withCancel<T>(iterable: AsyncIterable<T>, cancel: Promise<unknown>): AsyncGenerator<T>;
-interface TakeWithGraceOptions {
-    count: number;
-    gracePeriodMs: number;
-    onCancel: () => void;
-}
+export declare function withMaxDuration<T>(iterable: AsyncIterable<T>, opts: {
+    maxDurationMs: number;
+    abortCtrl: AbortController;
+}): AsyncGenerator<T>;
 /**
  * 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 declare function takeWithGrace<T>(iterable: AsyncIterable<T>, { count, gracePeriodMs, onCancel }: TakeWithGraceOptions): AsyncGenerator<T>;
-export {};
+export declare function takeWithGrace<T>(iterable: AsyncIterable<T>, opts: {
+    count: number;
+    gracePeriodMs: number;
+    abortCtrl: AbortController;
+}): AsyncGenerator<T>;
 //# sourceMappingURL=asyncIterable.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAuB,UAAU,CAAC,CAAC,EACjC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,GACvB,cAAc,CAAC,CAAC,CAAC,CAkBnB;AAED,UAAU,oBAAoB;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,EAAE,oBAAoB,GACvD,cAAc,CAAC,CAAC,CAAC,CA0BnB"}
+{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,eAAe,CAAA;CAAE,GAC1D,cAAc,CAAC,CAAC,CAAC,CA8BnB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,eAAe,CAAC;CAC5B,GACA,cAAc,CAAC,CAAC,CAAC,CAoCnB"}