@trpc/server 11.0.0-rc.643 → 11.0.0-rc.648

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

@@ -4,9 +4,76 @@ import { isAbortError } from '../http/isAbortError.mjs';
 import { run, identity } from '../utils.mjs';
 import { isTrackedEnvelope } from './tracked.mjs';
 import { takeWithGrace, withMaxDuration } from './utils/asyncIterable.mjs';
-import { createReadableStream } from './utils/createReadableStream.mjs';
+import { makeAsyncResource } from './utils/disposable.mjs';
+import { readableStreamFrom } from './utils/readableStreamFrom.mjs';
+import { timerResource, disposablePromiseTimerResult } from './utils/timerResource.mjs';
 import { withPing, PING_SYM } from './utils/withPing.mjs';
 
+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';
@@ -14,21 +81,20 @@ const CONNECTED_EVENT = 'connected';
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */ function sseStreamProducer(opts) {
-    const stream = createReadableStream();
     const { serialize = identity } = opts;
     const ping = {
         enabled: opts.ping?.enabled ?? false,
         intervalMs: opts.ping?.intervalMs ?? 1000
     };
     const client = opts.client ?? {};
-    stream.controller.enqueue({
-        event: CONNECTED_EVENT,
-        data: JSON.stringify(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}`);
     }
-    run(async ()=>{
+    async function* generator() {
+        yield {
+            event: CONNECTED_EVENT,
+            data: JSON.stringify(client)
+        };
         let iterable = opts.data;
         if (opts.emitAndEndImmediately) {
             iterable = takeWithGrace(iterable, {
@@ -44,60 +110,53 @@ const CONNECTED_EVENT = 'connected';
         if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
             iterable = withPing(iterable, ping.intervalMs);
         }
-        try {
-            // 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 === PING_SYM) {
-                    stream.controller.enqueue({
-                        event: PING_EVENT,
-                        data: ''
-                    });
-                    continue;
-                }
-                chunk = isTrackedEnvelope(value) ? {
-                    id: value[0],
-                    data: value[1]
-                } : {
-                    data: value
+        // 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 === PING_SYM) {
+                yield {
+                    event: PING_EVENT,
+                    data: ''
                 };
-                if ('data' in chunk) {
-                    chunk.data = JSON.stringify(serialize(chunk.data));
-                }
-                stream.controller.enqueue(chunk);
-                // free up references for garbage collection
-                value = null;
-                chunk = null;
+                continue;
             }
-        } catch (err) {
-            if (isAbortError(err)) {
+            chunk = isTrackedEnvelope(value) ? {
+                id: value[0],
+                data: value[1]
+            } : {
+                data: value
+            };
+            chunk.data = JSON.stringify(serialize(chunk.data));
+            yield chunk;
+            // free up references for garbage collection
+            value = null;
+            chunk = null;
+        }
+    }
+    async function* generatorWithErrorHandling() {
+        try {
+            yield* generator();
+        } catch (cause) {
+            if (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 = getTRPCErrorFromUnknown(err);
+            const error = getTRPCErrorFromUnknown(cause);
             const data = opts.formatError?.({
                 error
             }) ?? null;
-            stream.controller.enqueue({
+            yield {
                 event: SERIALIZED_ERROR_EVENT,
                 data: JSON.stringify(serialize(data))
-            });
-        } finally{
-            try {
-                stream.controller.close();
-            } catch  {
-            // ignore
-            }
+            };
         }
-    }).catch((err)=>{
-        // should not be reached; just in case...
-        stream.controller.error(err);
-    });
-    return stream.readable.pipeThrough(new TransformStream({
+    }
+    const stream = readableStreamFrom(generatorWithErrorHandling());
+    return stream.pipeThrough(new TransformStream({
         transform (chunk, controller) {
             if ('event' in chunk) {
                 controller.enqueue(`event: ${chunk.event}\n`);
@@ -116,26 +175,28 @@ const CONNECTED_EVENT = 'connected';
     }));
 }
 async function withTimeout(opts) {
-    let timeoutId;
-    const timeoutPromise = new Promise((resolve)=>{
-        timeoutId = setTimeout(()=>{
-            resolve(null);
-        }, opts.timeoutMs);
-    });
-    let res;
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
     try {
-        res = await Unpromise.race([
+        const timeoutPromise = _ts_add_disposable_resource(env, timerResource(opts.timeoutMs), false);
+        ;
+        const res = await Unpromise.race([
             opts.promise,
-            timeoutPromise
+            timeoutPromise.start()
         ]);
+        if (res === disposablePromiseTimerResult) {
+            return await opts.onTimeout();
+        }
+        return res;
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
     } finally{
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        clearTimeout(timeoutId);
+        _ts_dispose_resources(env);
     }
-    if (res === null) {
-        return await opts.onTimeout();
-    }
-    return res;
 }
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
@@ -220,69 +281,69 @@ async function withTimeout(opts) {
                 _es?.close();
             }
         });
-    const getNewStreamAndReader = ()=>{
-        const stream = createStream();
-        const reader = stream.getReader();
-        return {
-            reader,
-            cancel: ()=>{
-                reader.releaseLock();
-                return stream.cancel();
+    const getStreamResource = ()=>{
+        let stream = createStream();
+        let reader = stream.getReader();
+        async function dispose() {
+            await reader.cancel();
+            _es = null;
+        }
+        return makeAsyncResource({
+            read () {
+                return reader.read();
+            },
+            async recreate () {
+                await dispose();
+                stream = createStream();
+                reader = stream.getReader();
             }
-        };
+        }, dispose);
     };
-    return {
-        [Symbol.asyncIterator] () {
-            let stream = getNewStreamAndReader();
-            const iterator = {
-                async next () {
-                    let promise = stream.reader.read();
-                    const timeoutMs = clientOptions.reconnectAfterInactivityMs;
-                    if (timeoutMs) {
-                        promise = withTimeout({
-                            promise,
-                            timeoutMs,
-                            onTimeout: async ()=>{
-                                // Close and release old reader
-                                await stream.cancel();
-                                // Create new reader
-                                stream = getNewStreamAndReader();
-                                return {
-                                    value: {
-                                        type: 'timeout',
-                                        ms: timeoutMs,
-                                        // 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: result.value,
-                            done: true
-                        };
-                    }
-                    return {
-                        value: result.value,
-                        done: false
-                    };
-                },
-                async return () {
-                    await stream.cancel();
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+    return 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;
+                        }
+                    });
                 }
-            };
-            return iterator;
+                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',

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

@@ -1,3 +1,4 @@
+export declare function iteratorResource<TYield, TReturn, TNext>(iterable: AsyncIterable<TYield, TReturn, TNext>): AsyncIterator<TYield, TReturn, TNext> & AsyncDisposable;
 /**
  * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */

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":"AAGA;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9B,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;CACvB,GACA,cAAc,CAAC,CAAC,CAAC,CAkCnB"}
+{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EACrD,QAAQ,EAAE,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,GAC9C,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,eAAe,CAMzD;AACD;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CAyBnB;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;CACvB,GACA,cAAc,CAAC,CAAC,CAAC,CA+BnB"}

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

@@ -1,14 +1,93 @@
 'use strict';
 
 var unpromise = require('../../../vendor/unpromise/unpromise.js');
+var disposable = require('./disposable.js');
 var timerResource = require('./timerResource.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);
+}
+function iteratorResource(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return disposable.makeAsyncResource(iterator, async ()=>{
+        await iterator.return?.();
+    });
+}
 /**
  * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */ async function* withMaxDuration(iterable, opts) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    const timer = timerResource.timerResource(opts.maxDurationMs);
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
     try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        const timer = _ts_add_disposable_resource(env, timerResource.timerResource(opts.maxDurationMs), false);
+        ;
         const timerPromise = timer.start();
         // declaration outside the loop for garbage collection reasons
         let result;
@@ -29,10 +108,12 @@ var timerResource = require('./timerResource.js');
             // free up reference for garbage collection
             result = null;
         }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
     } finally{
-        // dispose timer
-        // Shouldn't be needed, but build breaks with `using` keyword
-        timer[Symbol.dispose]();
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
 }
 /**
@@ -40,11 +121,18 @@ var timerResource = require('./timerResource.js');
  * {@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.
  */ async function* takeWithGrace(iterable, opts) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    // declaration outside the loop for garbage collection reasons
-    let result;
-    const timer = timerResource.timerResource(opts.gracePeriodMs);
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
     try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        const timer = _ts_add_disposable_resource(env, timerResource.timerResource(opts.gracePeriodMs), false);
+        ;
         let count = opts.count;
         let timerPromise = new Promise(()=>{
         // never resolves
@@ -69,10 +157,15 @@ var timerResource = require('./timerResource.js');
             // free up reference for garbage collection
             result = null;
         }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
     } finally{
-        timer[Symbol.dispose]();
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
 }
 
+exports.iteratorResource = iteratorResource;
 exports.takeWithGrace = takeWithGrace;
 exports.withMaxDuration = withMaxDuration;