@trpc/server 11.0.0-rc.645 → 11.0.0-rc.657

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

@@ -6,9 +6,76 @@ var isAbortError = require('../http/isAbortError.js');
 var utils = require('../utils.js');
 var tracked = require('./tracked.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';
@@ -110,26 +177,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.Unpromise.race([
+        const timeoutPromise = _ts_add_disposable_resource(env, timerResource.timerResource(opts.timeoutMs), false);
+        ;
+        const res = await unpromise.Unpromise.race([
             opts.promise,
-            timeoutPromise
+            timeoutPromise.start()
         ]);
+        if (res === timerResource.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
@@ -214,69 +283,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 disposable.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 ()=>{
-                                const res = {
-                                    value: {
-                                        type: 'timeout',
-                                        ms: timeoutMs,
-                                        eventSource: _es
-                                    },
-                                    done: false
-                                };
-                                // Close and release old reader
-                                await stream.cancel();
-                                // Create new reader
-                                stream = getNewStreamAndReader();
-                                return res;
-                            }
-                        });
-                    }
-                    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 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;
+                        }
+                    });
                 }
-            };
-            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/sse.mjs

@@ -1,12 +1,79 @@
 import { Unpromise } from '../../vendor/unpromise/unpromise.mjs';
 import { getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
 import { isAbortError } from '../http/isAbortError.mjs';
-import { identity } from '../utils.mjs';
+import { run, identity } from '../utils.mjs';
 import { isTrackedEnvelope } from './tracked.mjs';
 import { takeWithGrace, withMaxDuration } from './utils/asyncIterable.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';
@@ -108,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
@@ -212,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 ()=>{
-                                const res = {
-                                    value: {
-                                        type: 'timeout',
-                                        ms: timeoutMs,
-                                        eventSource: _es
-                                    },
-                                    done: false
-                                };
-                                // Close and release old reader
-                                await stream.cancel();
-                                // Create new reader
-                                stream = getNewStreamAndReader();
-                                return res;
-                            }
-                        });
-                    }
-                    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;