@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.667

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

@@ -1,11 +1,12 @@
-import type { ConsumerOnError } from './jsonl';
+import type { MaybePromise } from '../types';
+import type { EventSourceLike } from './sse.types';
 import type { inferTrackedOutput } from './tracked';
 type Serialize = (value: any) => any;
 type Deserialize = (value: any) => any;
 /**
  * @internal
  */
-export interface PingOptions {
+export interface SSEPingOptions {
     /**
      * Enable ping comments sent from the server
      * @default false
@@ -17,14 +18,20 @@ export interface PingOptions {
      */
     intervalMs?: number;
 }
-export interface SSEStreamProducerOptions {
+export interface SSEClientOptions {
+    /**
+     * Timeout and reconnect after inactivity in milliseconds
+     * @default undefined
+     */
+    reconnectAfterInactivityMs?: number;
+}
+export interface SSEStreamProducerOptions<TValue = unknown> {
     serialize?: Serialize;
-    data: AsyncIterable<unknown>;
+    data: AsyncIterable<TValue>;
     maxDepth?: number;
-    ping?: PingOptions;
+    ping?: SSEPingOptions;
     /**
      * Maximum duration in milliseconds for the request before ending the stream
-     * Only useful for serverless runtimes
      * @default undefined
      */
     maxDurationMs?: number;
@@ -37,27 +44,60 @@ export interface SSEStreamProducerOptions {
     formatError?: (opts: {
         error: unknown;
     }) => unknown;
+    /**
+     * Client-specific options - these will be sent to the client as part of the first message
+     * @default {}
+     */
+    client?: SSEClientOptions;
 }
 /**
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-export declare function sseStreamProducer(opts: SSEStreamProducerOptions): ReadableStream<string>;
-type ConsumerStreamResult<TData> = {
-    ok: true;
-    data: inferTrackedOutput<TData>;
-} | {
-    ok: false;
+export declare function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptions<TValue>): ReadableStream<string>;
+interface ConsumerStreamResultBase<TConfig extends ConsumerConfig> {
+    eventSource: InstanceType<TConfig['EventSource']> | null;
+}
+interface ConsumerStreamResultData<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'data';
+    data: inferTrackedOutput<TConfig['data']>;
+}
+interface ConsumerStreamResultError<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'serialized-error';
+    error: TConfig['error'];
+}
+interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'connecting';
+    event: EventSourceLike.EventOf<TConfig['EventSource']> | null;
+}
+interface ConsumerStreamResultTimeout<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'timeout';
+    ms: number;
+}
+interface ConsumerStreamResultPing<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'ping';
+}
+interface ConsumerStreamResultConnected<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+    type: 'connected';
+    options: SSEClientOptions;
+}
+type ConsumerStreamResult<TConfig extends ConsumerConfig> = ConsumerStreamResultData<TConfig> | ConsumerStreamResultError<TConfig> | ConsumerStreamResultConnecting<TConfig> | ConsumerStreamResultTimeout<TConfig> | ConsumerStreamResultPing<TConfig> | ConsumerStreamResultConnected<TConfig>;
+export interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
+    url: () => MaybePromise<string>;
+    init: () => MaybePromise<EventSourceLike.InitDictOf<TConfig['EventSource']>> | undefined;
+    signal: AbortSignal;
+    deserialize?: Deserialize;
+    EventSource: TConfig['EventSource'];
+}
+interface ConsumerConfig {
+    data: unknown;
     error: unknown;
-};
+    EventSource: EventSourceLike.AnyConstructor;
+}
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-export declare function sseStreamConsumer<TData>(opts: {
-    from: EventSource;
-    onError?: ConsumerOnError;
-    deserialize?: Deserialize;
-}): AsyncIterable<ConsumerStreamResult<TData>>;
+export declare function sseStreamConsumer<TConfig extends ConsumerConfig>(opts: SSEStreamConsumerOptions<TConfig>): AsyncIterable<ConsumerStreamResult<TConfig>>;
 export declare const sseHeaders: {
     readonly 'Content-Type': "text/event-stream";
     readonly 'Cache-Control': "no-cache, no-transform";

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

@@ -1 +1 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/sse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAKpD,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AACrC,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AAEvC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC;CACrD;AAUD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,wBAAwB,0BAoH/D;AAED,KAAK,oBAAoB,CAAC,KAAK,IAC3B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;CACjC,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEN;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE;IAC7C,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,GAAG,aAAa,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CA6E7C;AAED,eAAO,MAAM,UAAU;;;;;CAKb,CAAC"}
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/sse.ts"],"names":[],"mappings":"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"}

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

@@ -1,90 +1,164 @@
 '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 createDeferred = require('./utils/createDeferred.js');
-var createReadableStream = require('./utils/createReadableStream.js');
+var asyncIterable = require('./utils/asyncIterable.js');
+var disposable = require('./utils/disposable.js');
+var readableStreamFrom = require('./utils/readableStreamFrom.js');
+var timerResource = require('./utils/timerResource.js');
+var withPing = require('./utils/withPing.js');
 
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+const PING_EVENT = 'ping';
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
+const CONNECTED_EVENT = 'connected';
 /**
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamProducer(opts) {
-    const stream = createReadableStream.createReadableStream();
-    stream.controller.enqueue({
-        comment: 'connected'
-    });
-    const { serialize =(v)=>v  } = opts;
+    const { serialize = utils.identity } = opts;
     const ping = {
         enabled: opts.ping?.enabled ?? false,
         intervalMs: opts.ping?.intervalMs ?? 1000
     };
-    utils.run(async ()=>{
-        const iterator = opts.data[Symbol.asyncIterator]();
-        const closedPromise = stream.cancelledPromise.then(()=>'closed');
-        const maxDurationPromise = createDeferred.createTimeoutPromise(opts.maxDurationMs ?? Infinity, 'maxDuration');
-        let nextPromise = iterator.next();
-        while(true){
-            const pingPromise = createDeferred.createTimeoutPromise(ping.enabled ? ping.intervalMs : Infinity, 'ping');
-            const next = await Promise.race([
-                nextPromise.catch(TRPCError.getTRPCErrorFromUnknown),
-                pingPromise.promise,
-                closedPromise,
-                maxDurationPromise.promise
-            ]);
-            pingPromise.clear();
-            if (next === 'closed') {
-                break;
-            }
-            if (next === 'maxDuration') {
-                break;
-            }
-            if (next === 'ping') {
-                stream.controller.enqueue({
-                    comment: 'ping'
-                });
+    const client = opts.client ?? {};
+    if (ping.enabled && client.reconnectAfterInactivityMs && ping.intervalMs > client.reconnectAfterInactivityMs) {
+        throw new Error(`Ping interval must be less than client reconnect interval to prevent unnecessary reconnection - ping.intervalMs: ${ping.intervalMs} client.reconnectAfterInactivityMs: ${client.reconnectAfterInactivityMs}`);
+    }
+    async function* generator() {
+        yield {
+            event: CONNECTED_EVENT,
+            data: JSON.stringify(client)
+        };
+        let iterable = opts.data;
+        if (opts.emitAndEndImmediately) {
+            iterable = asyncIterable.takeWithGrace(iterable, {
+                count: 1,
+                gracePeriodMs: 1
+            });
+        }
+        if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            iterable = asyncIterable.withMaxDuration(iterable, {
+                maxDurationMs: opts.maxDurationMs
+            });
+        }
+        if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
+            iterable = withPing.withPing(iterable, ping.intervalMs);
+        }
+        // We need those declarations outside the loop for garbage collection reasons. If they were
+        // declared inside, they would not be freed until the next value is present.
+        let value;
+        let chunk;
+        for await (value of iterable){
+            if (value === withPing.PING_SYM) {
+                yield {
+                    event: PING_EVENT,
+                    data: ''
+                };
                 continue;
             }
-            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;
-            }
-            const value = next.value;
-            const chunk = tracked.isTrackedEnvelope(value) ? {
+            chunk = tracked.isTrackedEnvelope(value) ? {
                 id: value[0],
                 data: value[1]
             } : {
                 data: value
             };
-            if ('data' in chunk) {
-                chunk.data = JSON.stringify(serialize(chunk.data));
-            }
-            stream.controller.enqueue(chunk);
-            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);
-            }
-            nextPromise = iterator.next();
+            chunk.data = JSON.stringify(serialize(chunk.data));
+            yield chunk;
+            // free up references for garbage collection
+            value = null;
+            chunk = null;
         }
-        maxDurationPromise.clear();
-        await iterator.return?.();
+    }
+    async function* generatorWithErrorHandling() {
         try {
-            stream.controller.close();
-        } catch  {}
-    }).catch((error)=>{
-        return stream.controller.error(error);
-    });
-    return stream.readable.pipeThrough(new TransformStream({
+            yield* generator();
+        } catch (cause) {
+            if (isAbortError.isAbortError(cause)) {
+                // 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(cause);
+            const data = opts.formatError?.({
+                error
+            }) ?? null;
+            yield {
+                event: SERIALIZED_ERROR_EVENT,
+                data: JSON.stringify(serialize(data))
+            };
+        }
+    }
+    const stream = readableStreamFrom.readableStreamFrom(generatorWithErrorHandling());
+    return stream.pipeThrough(new TransformStream({
         transform (chunk, controller) {
             if ('event' in chunk) {
                 controller.enqueue(`event: ${chunk.event}\n`);
@@ -102,75 +176,176 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
         }
     }));
 }
+async function withTimeout(opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const timeoutPromise = _ts_add_disposable_resource(env, timerResource.timerResource(opts.timeoutMs), false);
+        ;
+        const res = await unpromise.Unpromise.race([
+            opts.promise,
+            timeoutPromise.start()
+        ]);
+        if (res === timerResource.disposablePromiseTimerResult) {
+            return await opts.onTimeout();
+        }
+        return res;
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        _ts_dispose_resources(env);
+    }
+}
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamConsumer(opts) {
-    const { deserialize =(v)=>v  } = opts;
-    const eventSource = opts.from;
-    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) {
+    const { deserialize = (v)=>v } = opts;
+    let clientOptions = {};
+    const signal = opts.signal;
+    let _es = null;
+    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({
-                    ok: false,
-                    error: data
+                    type: 'connecting',
+                    eventSource: _es,
+                    event: null
                 });
-                return;
-            }
-            // console.debug('transforming', chunk.type, chunk.data);
-            const def = {
-                data
-            };
-            if (chunk.lastEventId) {
-                def.id = chunk.lastEventId;
-            }
-            controller.enqueue({
-                ok: true,
-                data: def
-            });
-        }
-    });
-    eventSource.addEventListener('message', (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (msg)=>{
-        stream.controller.enqueue(msg);
-    });
-    eventSource.addEventListener('error', (cause)=>{
-        if (eventSource.readyState === EventSource.CLOSED) {
-            stream.controller.error(cause);
-        }
-    });
-    const readable = stream.readable.pipeThrough(transform);
-    return {
-        [Symbol.asyncIterator] () {
-            const reader = readable.getReader();
-            const iterator = {
-                async next () {
-                    const value = await reader.read();
-                    if (value.done) {
-                        return {
-                            value: undefined,
-                            done: true
-                        };
+                eventSource.addEventListener(CONNECTED_EVENT, (_msg)=>{
+                    const msg = _msg;
+                    const options = JSON.parse(msg.data);
+                    clientOptions = options;
+                    controller.enqueue({
+                        type: 'connected',
+                        options,
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
+                    const msg = _msg;
+                    controller.enqueue({
+                        type: 'serialized-error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource
+                    });
+                });
+                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
+                        });
                     }
-                    return {
-                        value: value.value,
-                        done: false
-                    };
-                },
-                async return () {
-                    reader.releaseLock();
-                    return {
-                        value: undefined,
-                        done: true
+                });
+                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 (signal.aborted) {
+                    onAbort();
+                } else {
+                    signal.addEventListener('abort', onAbort);
                 }
-            };
-            return iterator;
+            },
+            cancel () {
+                _es?.close();
+            }
+        });
+    const getStreamResource = ()=>{
+        let stream = createStream();
+        let reader = stream.getReader();
+        async function dispose() {
+            await reader.cancel();
+            _es = null;
         }
+        return disposable.makeAsyncResource({
+            read () {
+                return reader.read();
+            },
+            async recreate () {
+                await dispose();
+                stream = createStream();
+                reader = stream.getReader();
+            }
+        }, dispose);
     };
+    return utils.run(async function*() {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            const stream = _ts_add_disposable_resource(env, getStreamResource(), true);
+            ;
+            while(true){
+                let promise = stream.read();
+                const timeoutMs = clientOptions.reconnectAfterInactivityMs;
+                if (timeoutMs) {
+                    promise = withTimeout({
+                        promise,
+                        timeoutMs,
+                        onTimeout: async ()=>{
+                            const res = {
+                                value: {
+                                    type: 'timeout',
+                                    ms: timeoutMs,
+                                    eventSource: _es
+                                },
+                                done: false
+                            };
+                            // Close and release old reader
+                            await stream.recreate();
+                            return res;
+                        }
+                    });
+                }
+                const result = await promise;
+                if (result.done) {
+                    return result.value;
+                }
+                yield result.value;
+            }
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
+    });
 }
 const sseHeaders = {
     'Content-Type': 'text/event-stream',