@trpc/server 11.0.0-rc.560 → 11.0.0-rc.563

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

@@ -105,60 +105,141 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamConsumer(opts) {
-    const { deserialize =(v)=>v  } = opts;
-    const eventSource = opts.from;
+    const { deserialize =(v)=>v , shouldRecreateOnError  } = opts;
+    const signal = opts.signal;
+    let eventSource = null;
+    let lock = null;
     const stream = createReadableStream.createReadableStream();
-    const transform = new TransformStream({
-        async transform (chunk, controller) {
-            const data = deserialize(JSON.parse(chunk.data));
-            if (chunk.type === SERIALIZED_ERROR_EVENT) {
-                controller.enqueue({
-                    ok: false,
-                    error: data
-                });
+    function createEventSource(...args) {
+        const es = new EventSource(...args);
+        if (signal.aborted) {
+            es.close();
+        } else {
+            signal.addEventListener('abort', ()=>es.close());
+        }
+        /**
+     * Dispatch an event to the stream controller
+     *
+     * Will be a no-op if the event source has been replaced
+     */ const dispatch = (fn)=>{
+            utils.run(async ()=>{
+                while(lock){
+                    await lock;
+                }
+                if (es === eventSource) {
+                    await fn(stream.controller);
+                }
+            }).catch((error)=>{
+                stream.controller.error(error);
+            });
+        };
+        const pauseDispatch = async (fn)=>{
+            while(lock){
+                await lock;
+            }
+            if (es !== eventSource) {
                 return;
             }
-            // console.debug('transforming', chunk.type, chunk.data);
-            const def = {
-                data
-            };
-            if (chunk.lastEventId) {
-                def.id = chunk.lastEventId;
+            const deferred = createDeferred.createDeferred();
+            lock = deferred.promise;
+            try {
+                await fn();
+            } finally{
+                lock = null;
+                deferred.resolve();
             }
-            controller.enqueue({
-                ok: true,
-                data: def
+        };
+        es.addEventListener('open', ()=>{
+            dispatch((controller)=>{
+                controller.enqueue({
+                    type: 'opened',
+                    eventSource: es
+                });
             });
-        }
-    });
-    let errorLock = undefined;
-    eventSource.addEventListener('message', (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener('error', async (cause)=>{
-        // We prevent more than 1 error handler from waiting at the same time
-        const result = await errorLock;
-        if (result === 'CANCEL_ALL') {
-            return;
-        }
-        const resolvable = createDeferred.createDeferred();
-        errorLock = resolvable.promise;
-        const handled = await opts.tryHandleError?.(cause);
-        resolvable.resolve();
-        if (handled === true) {
-            return;
-        }
-        if (eventSource.readyState === EventSource.CLOSED) {
-            stream.controller.error(cause);
-        }
+        });
+        es.addEventListener(SERIALIZED_ERROR_EVENT, (msg)=>{
+            dispatch(async ()=>{
+                if (shouldRecreateOnError) {
+                    await pauseDispatch(async ()=>{
+                        const recreate = await shouldRecreateOnError({
+                            type: SERIALIZED_ERROR_EVENT,
+                            error: deserialize(JSON.parse(msg.data))
+                        });
+                        if (recreate) {
+                            await recreateEventSource();
+                        }
+                    });
+                }
+                dispatch((controller)=>{
+                    controller.enqueue({
+                        type: 'error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource: es
+                    });
+                });
+            });
+        });
+        es.addEventListener('error', (event)=>{
+            dispatch(async ()=>{
+                if (shouldRecreateOnError) {
+                    await pauseDispatch(async ()=>{
+                        const recreate = await shouldRecreateOnError({
+                            type: 'event',
+                            event
+                        });
+                        if (recreate) {
+                            await recreateEventSource();
+                        }
+                    });
+                }
+                dispatch((controller)=>{
+                    if (es.readyState === EventSource.CLOSED) {
+                        controller.error(event);
+                    } else {
+                        controller.enqueue({
+                            type: 'connecting',
+                            eventSource: es
+                        });
+                    }
+                });
+            });
+        });
+        es.addEventListener('message', (msg)=>{
+            dispatch((controller)=>{
+                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: es
+                });
+            });
+        });
+        return es;
+    }
+    async function recreateEventSource() {
+        eventSource?.close();
+        const [url, init] = await Promise.all([
+            opts.url(),
+            opts.init()
+        ]);
+        eventSource = createEventSource(url, init);
+        stream.controller.enqueue({
+            type: 'connecting',
+            eventSource
+        });
+    }
+    recreateEventSource().catch(()=>{
+    // prevent unhandled promise rejection
     });
-    const readable = stream.readable.pipeThrough(transform);
     return {
         [Symbol.asyncIterator] () {
-            const reader = readable.getReader();
+            const reader = stream.readable.getReader();
             const iterator = {
                 async next () {
                     const value = await reader.read();

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

@@ -103,60 +103,141 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamConsumer(opts) {
-    const { deserialize =(v)=>v  } = opts;
-    const eventSource = opts.from;
+    const { deserialize =(v)=>v , shouldRecreateOnError  } = opts;
+    const signal = opts.signal;
+    let eventSource = null;
+    let lock = null;
     const stream = createReadableStream();
-    const transform = new TransformStream({
-        async transform (chunk, controller) {
-            const data = deserialize(JSON.parse(chunk.data));
-            if (chunk.type === SERIALIZED_ERROR_EVENT) {
-                controller.enqueue({
-                    ok: false,
-                    error: data
-                });
+    function createEventSource(...args) {
+        const es = new EventSource(...args);
+        if (signal.aborted) {
+            es.close();
+        } else {
+            signal.addEventListener('abort', ()=>es.close());
+        }
+        /**
+     * Dispatch an event to the stream controller
+     *
+     * Will be a no-op if the event source has been replaced
+     */ const dispatch = (fn)=>{
+            run(async ()=>{
+                while(lock){
+                    await lock;
+                }
+                if (es === eventSource) {
+                    await fn(stream.controller);
+                }
+            }).catch((error)=>{
+                stream.controller.error(error);
+            });
+        };
+        const pauseDispatch = async (fn)=>{
+            while(lock){
+                await lock;
+            }
+            if (es !== eventSource) {
                 return;
             }
-            // console.debug('transforming', chunk.type, chunk.data);
-            const def = {
-                data
-            };
-            if (chunk.lastEventId) {
-                def.id = chunk.lastEventId;
+            const deferred = createDeferred();
+            lock = deferred.promise;
+            try {
+                await fn();
+            } finally{
+                lock = null;
+                deferred.resolve();
             }
-            controller.enqueue({
-                ok: true,
-                data: def
+        };
+        es.addEventListener('open', ()=>{
+            dispatch((controller)=>{
+                controller.enqueue({
+                    type: 'opened',
+                    eventSource: es
+                });
             });
-        }
-    });
-    let errorLock = undefined;
-    eventSource.addEventListener('message', (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener('error', async (cause)=>{
-        // We prevent more than 1 error handler from waiting at the same time
-        const result = await errorLock;
-        if (result === 'CANCEL_ALL') {
-            return;
-        }
-        const resolvable = createDeferred();
-        errorLock = resolvable.promise;
-        const handled = await opts.tryHandleError?.(cause);
-        resolvable.resolve();
-        if (handled === true) {
-            return;
-        }
-        if (eventSource.readyState === EventSource.CLOSED) {
-            stream.controller.error(cause);
-        }
+        });
+        es.addEventListener(SERIALIZED_ERROR_EVENT, (msg)=>{
+            dispatch(async ()=>{
+                if (shouldRecreateOnError) {
+                    await pauseDispatch(async ()=>{
+                        const recreate = await shouldRecreateOnError({
+                            type: SERIALIZED_ERROR_EVENT,
+                            error: deserialize(JSON.parse(msg.data))
+                        });
+                        if (recreate) {
+                            await recreateEventSource();
+                        }
+                    });
+                }
+                dispatch((controller)=>{
+                    controller.enqueue({
+                        type: 'error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource: es
+                    });
+                });
+            });
+        });
+        es.addEventListener('error', (event)=>{
+            dispatch(async ()=>{
+                if (shouldRecreateOnError) {
+                    await pauseDispatch(async ()=>{
+                        const recreate = await shouldRecreateOnError({
+                            type: 'event',
+                            event
+                        });
+                        if (recreate) {
+                            await recreateEventSource();
+                        }
+                    });
+                }
+                dispatch((controller)=>{
+                    if (es.readyState === EventSource.CLOSED) {
+                        controller.error(event);
+                    } else {
+                        controller.enqueue({
+                            type: 'connecting',
+                            eventSource: es
+                        });
+                    }
+                });
+            });
+        });
+        es.addEventListener('message', (msg)=>{
+            dispatch((controller)=>{
+                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: es
+                });
+            });
+        });
+        return es;
+    }
+    async function recreateEventSource() {
+        eventSource?.close();
+        const [url, init] = await Promise.all([
+            opts.url(),
+            opts.init()
+        ]);
+        eventSource = createEventSource(url, init);
+        stream.controller.enqueue({
+            type: 'connecting',
+            eventSource
+        });
+    }
+    recreateEventSource().catch(()=>{
+    // prevent unhandled promise rejection
     });
-    const readable = stream.readable.pipeThrough(transform);
     return {
         [Symbol.asyncIterator] () {
-            const reader = readable.getReader();
+            const reader = stream.readable.getReader();
             const iterator = {
                 async next () {
                     const value = await reader.read();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.560+137b085f8",
+  "version": "11.0.0-rc.563+e5ae464b2",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -149,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "137b085f86cb4ceb397b29c69ccbe38a93dbe79a"
+  "gitHead": "e5ae464b2428b591d816ee4e01725c86b232d620"
 }

package/src/adapters/ws.ts

@@ -24,8 +24,7 @@ import type {
   TRPCResultMessage,
 } from '../@trpc/server/rpc';
 import { parseConnectionParamsFromUnknown } from '../http';
-import { isObservable } from '../observable';
-import { observableToAsyncIterable } from '../observable/observable';
+import { isObservable, observableToAsyncIterable } from '../observable';
 // eslint-disable-next-line no-restricted-imports
 import {
   isAsyncIterable,

package/src/observable/index.ts

@@ -1,5 +1,5 @@
 export type { inferObservableValue } from './observable';
-export { isObservable, observable, observableToPromise } from './observable';
+export { isObservable, observable, observableToAsyncIterable, observableToPromise } from './observable';
 export { map, share, tap } from './operators';
 export type {
   Observable,

package/src/observable/observable.ts

@@ -152,6 +152,7 @@ function observableToReadableStream<TValue>(
   });
 }
 
+/** @internal */
 export function observableToAsyncIterable<TValue>(
   observable: Observable<TValue, unknown>,
 ): AsyncIterable<TValue> {

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

@@ -436,6 +436,9 @@ export async function jsonlStreamConsumer<THead>(opts: {
   deserialize?: Deserialize;
   onError?: ConsumerOnError;
   formatError?: (opts: { error: unknown }) => Error;
+  /**
+   * This `AbortController` will be triggered when there are no more listeners to the stream.
+   */
   abortController: AbortController | null;
 }) {
   const { deserialize = (v) => v } = opts;