@trpc/server 11.0.0-rc.693 → 11.0.0-rc.695

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

@@ -1,8 +1,8 @@
-import { Unpromise } from '../../vendor/unpromise/unpromise.mjs';
-import { isObject, isFunction, isAsyncIterable, run } from '../utils.mjs';
+import { isObject, isFunction, run, isAsyncIterable } from '../utils.mjs';
 import { iteratorResource } from './utils/asyncIterable.mjs';
 import { createDeferred } from './utils/createDeferred.mjs';
-import { makeAsyncResource, makeResource } from './utils/disposable.mjs';
+import { makeResource } from './utils/disposable.mjs';
+import { mergeAsyncIterables } from './utils/mergeAsyncIterables.mjs';
 import { readableStreamFrom } from './utils/readableStreamFrom.mjs';
 
 function _define_property(obj, key, value) {
@@ -101,223 +101,189 @@ class MaxDepthError extends Error {
     }
 }
 async function* createBatchStreamProducer(opts) {
-    const env = {
-        stack: [],
-        error: void 0,
-        hasError: false
-    };
-    try {
-        const { data } = opts;
-        let counter = 0;
-        const placeholder = 0;
-        const queue = _ts_add_disposable_resource(env, makeAsyncResource(new Set(), async ()=>{
-            await Promise.all(Array.from(queue).map((it)=>it.iterator.return?.()));
-        }), true);
-        ;
-        function registerAsync(callback) {
-            const idx = counter++;
-            const iterator = callback(idx)[Symbol.asyncIterator]();
-            const nextPromise = iterator.next();
-            nextPromise.catch(()=>{
-            // prevent unhandled promise rejection
-            });
-            queue.add({
-                iterator,
-                nextPromise
-            });
-            return idx;
-        }
-        function encodePromise(promise, path) {
-            return registerAsync(async function*(idx) {
+    const { data } = opts;
+    let counter = 0;
+    const placeholder = 0;
+    const mergedIterables = mergeAsyncIterables();
+    function registerAsync(callback) {
+        const idx = counter++;
+        const iterable = callback(idx);
+        mergedIterables.add(iterable);
+        return idx;
+    }
+    function encodePromise(promise, path) {
+        return registerAsync(async function*(idx) {
+            const error = checkMaxDepth(path);
+            if (error) {
+                // Catch any errors from the original promise to ensure they're reported
+                promise.catch((cause)=>{
+                    opts.onError?.({
+                        error: cause,
+                        path
+                    });
+                });
+                // Replace the promise with a rejected one containing the max depth error
+                promise = Promise.reject(error);
+            }
+            try {
+                const next = await promise;
+                yield [
+                    idx,
+                    PROMISE_STATUS_FULFILLED,
+                    encode(next, path)
+                ];
+            } catch (cause) {
+                opts.onError?.({
+                    error: cause,
+                    path
+                });
+                yield [
+                    idx,
+                    PROMISE_STATUS_REJECTED,
+                    opts.formatError?.({
+                        error: cause,
+                        path
+                    })
+                ];
+            }
+        });
+    }
+    function encodeAsyncIterable(iterable, path) {
+        return registerAsync(async function*(idx) {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
                 const error = checkMaxDepth(path);
                 if (error) {
-                    // Catch any errors from the original promise to ensure they're reported
-                    promise.catch((cause)=>{
-                        opts.onError?.({
-                            error: cause,
-                            path
-                        });
-                    });
-                    // Replace the promise with a rejected one containing the max depth error
-                    promise = Promise.reject(error);
+                    throw error;
                 }
+                const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+                ;
                 try {
-                    const next = await promise;
-                    return [
-                        idx,
-                        PROMISE_STATUS_FULFILLED,
-                        encode(next, path)
-                    ];
+                    while(true){
+                        const next = await iterator.next();
+                        if (next.done) {
+                            yield [
+                                idx,
+                                ASYNC_ITERABLE_STATUS_RETURN,
+                                encode(next.value, path)
+                            ];
+                            break;
+                        }
+                        yield [
+                            idx,
+                            ASYNC_ITERABLE_STATUS_YIELD,
+                            encode(next.value, path)
+                        ];
+                    }
                 } catch (cause) {
                     opts.onError?.({
                         error: cause,
                         path
                     });
-                    return [
+                    yield [
                         idx,
-                        PROMISE_STATUS_REJECTED,
+                        ASYNC_ITERABLE_STATUS_ERROR,
                         opts.formatError?.({
                             error: cause,
                             path
                         })
                     ];
                 }
-            });
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        });
+    }
+    function checkMaxDepth(path) {
+        if (opts.maxDepth && path.length > opts.maxDepth) {
+            return new MaxDepthError(path);
         }
-        function encodeAsyncIterable(iterable, path) {
-            return registerAsync(async function*(idx) {
-                const env = {
-                    stack: [],
-                    error: void 0,
-                    hasError: false
-                };
-                try {
-                    const error = checkMaxDepth(path);
-                    if (error) {
-                        throw error;
-                    }
-                    const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
-                    ;
-                    try {
-                        while(true){
-                            const next = await iterator.next();
-                            if (next.done) {
-                                return [
-                                    idx,
-                                    ASYNC_ITERABLE_STATUS_RETURN,
-                                    encode(next.value, path)
-                                ];
-                            }
-                            yield [
-                                idx,
-                                ASYNC_ITERABLE_STATUS_YIELD,
-                                encode(next.value, path)
-                            ];
-                        }
-                    } catch (cause) {
-                        opts.onError?.({
-                            error: cause,
-                            path
-                        });
-                        return [
-                            idx,
-                            ASYNC_ITERABLE_STATUS_ERROR,
-                            opts.formatError?.({
-                                error: cause,
-                                path
-                            })
-                        ];
-                    }
-                } catch (e) {
-                    env.error = e;
-                    env.hasError = true;
-                } finally{
-                    const result = _ts_dispose_resources(env);
-                    if (result) await result;
-                }
-            });
+        return null;
+    }
+    function encodeAsync(value, path) {
+        if (isPromise(value)) {
+            return [
+                CHUNK_VALUE_TYPE_PROMISE,
+                encodePromise(value, path)
+            ];
         }
-        function checkMaxDepth(path) {
-            if (opts.maxDepth && path.length > opts.maxDepth) {
-                return new MaxDepthError(path);
+        if (isAsyncIterable(value)) {
+            if (opts.maxDepth && path.length >= opts.maxDepth) {
+                throw new Error('Max depth reached');
             }
-            return null;
+            return [
+                CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
+                encodeAsyncIterable(value, path)
+            ];
         }
-        function encodeAsync(value, path) {
-            if (isPromise(value)) {
-                return [
-                    CHUNK_VALUE_TYPE_PROMISE,
-                    encodePromise(value, path)
-                ];
-            }
-            if (isAsyncIterable(value)) {
-                if (opts.maxDepth && path.length >= opts.maxDepth) {
-                    throw new Error('Max depth reached');
-                }
-                return [
-                    CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-                    encodeAsyncIterable(value, path)
-                ];
-            }
-            return null;
+        return null;
+    }
+    function encode(value, path) {
+        if (value === undefined) {
+            return [
+                []
+            ];
         }
-        function encode(value, path) {
-            if (value === undefined) {
-                return [
-                    []
-                ];
-            }
-            if (!isObject(value)) {
-                return [
-                    [
-                        value
-                    ]
-                ];
-            }
-            const reg = encodeAsync(value, path);
-            if (reg) {
-                return [
-                    [
-                        placeholder
-                    ],
-                    [
-                        null,
-                        ...reg
-                    ]
-                ];
-            }
-            const newObj = {};
-            const asyncValues = [];
-            for (const [key, item] of Object.entries(value)){
-                const transformed = encodeAsync(item, [
-                    ...path,
-                    key
-                ]);
-                if (!transformed) {
-                    newObj[key] = item;
-                    continue;
-                }
-                newObj[key] = placeholder;
-                asyncValues.push([
-                    key,
-                    ...transformed
-                ]);
-            }
+        if (!isObject(value)) {
+            return [
+                [
+                    value
+                ]
+            ];
+        }
+        const reg = encodeAsync(value, path);
+        if (reg) {
             return [
                 [
-                    newObj
+                    placeholder
                 ],
-                ...asyncValues
+                [
+                    null,
+                    ...reg
+                ]
             ];
         }
-        const newHead = {};
-        for (const [key, item] of Object.entries(data)){
-            newHead[key] = encode(item, [
+        const newObj = {};
+        const asyncValues = [];
+        for (const [key, item] of Object.entries(value)){
+            const transformed = encodeAsync(item, [
+                ...path,
                 key
             ]);
-        }
-        yield newHead;
-        // Process all async iterables in parallel by racing their next values
-        while(queue.size > 0){
-            // Race all iterators to get the next value from any of them
-            const [entry, res] = await Unpromise.race(Array.from(queue).map(async (it)=>[
-                    it,
-                    await it.nextPromise
-                ]));
-            yield res.value;
-            // Remove current iterator and re-add if not done
-            queue.delete(entry);
-            if (!res.done) {
-                entry.nextPromise = entry.iterator.next();
-                queue.add(entry);
+            if (!transformed) {
+                newObj[key] = item;
+                continue;
             }
+            newObj[key] = placeholder;
+            asyncValues.push([
+                key,
+                ...transformed
+            ]);
         }
-    } catch (e) {
-        env.error = e;
-        env.hasError = true;
-    } finally{
-        const result = _ts_dispose_resources(env);
-        if (result) await result;
+        return [
+            [
+                newObj
+            ],
+            ...asyncValues
+        ];
+    }
+    const newHead = {};
+    for (const [key, item] of Object.entries(data)){
+        newHead[key] = encode(item, [
+            key
+        ]);
+    }
+    yield newHead;
+    for await (const value of mergedIterables){
+        yield value;
     }
 }
 /**

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

@@ -0,0 +1,17 @@
+interface MergedAsyncIterables<TYield> extends AsyncIterable<TYield, void, unknown> {
+    add(iterable: AsyncIterable<TYield>): void;
+}
+/**
+ * Creates a new async iterable that merges multiple async iterables into a single stream.
+ * Values from the input iterables are yielded in the order they resolve, similar to Promise.race().
+ *
+ * New iterables can be added dynamically using the returned {@link MergedAsyncIterables.add} method, even after iteration has started.
+ *
+ * If any of the input iterables throws an error, that error will be propagated through the merged stream.
+ * Other iterables will not continue to be processed.
+ *
+ * @template TYield The type of values yielded by the input iterables
+ */
+export declare function mergeAsyncIterables<TYield>(): MergedAsyncIterables<TYield>;
+export {};
+//# sourceMappingURL=mergeAsyncIterables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeAsyncIterables.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/mergeAsyncIterables.ts"],"names":[],"mappings":"AAyDA,UAAU,oBAAoB,CAAC,MAAM,CACnC,SAAQ,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IAC5C,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CAC5C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,KAAK,oBAAoB,CAAC,MAAM,CAAC,CAuH1E"}

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

@@ -0,0 +1,241 @@
+'use strict';
+
+var createDeferred = require('./createDeferred.js');
+var disposable = require('./disposable.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 (!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];
+            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 {
+        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 createManagedIterator(iterable, onResult) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    let state = 'idle';
+    function cleanup() {
+        state = 'done';
+        onResult = ()=>{
+        // noop
+        };
+    }
+    function pull() {
+        if (state !== 'idle') {
+            return;
+        }
+        state = 'pending';
+        const next = iterator.next();
+        next.then((result)=>{
+            if (result.done) {
+                state = 'done';
+                onResult({
+                    status: 'return',
+                    value: result.value
+                });
+                cleanup();
+                return;
+            }
+            state = 'idle';
+            onResult({
+                status: 'yield',
+                value: result.value
+            });
+        }).catch((cause)=>{
+            onResult({
+                status: 'error',
+                error: cause
+            });
+            cleanup();
+        });
+    }
+    return {
+        pull,
+        destroy: async ()=>{
+            cleanup();
+            await iterator.return?.();
+        }
+    };
+}
+/**
+ * Creates a new async iterable that merges multiple async iterables into a single stream.
+ * Values from the input iterables are yielded in the order they resolve, similar to Promise.race().
+ *
+ * New iterables can be added dynamically using the returned {@link MergedAsyncIterables.add} method, even after iteration has started.
+ *
+ * If any of the input iterables throws an error, that error will be propagated through the merged stream.
+ * Other iterables will not continue to be processed.
+ *
+ * @template TYield The type of values yielded by the input iterables
+ */ function mergeAsyncIterables() {
+    let state = 'idle';
+    let flushSignal = createDeferred.createDeferred();
+    /**
+   * used while {@link state} is `idle`
+   */ const iterables = [];
+    /**
+   * used while {@link state} is `pending`
+   */ const iterators = new Set();
+    const buffer = [];
+    function initIterable(iterable) {
+        if (state !== 'pending') {
+            // shouldn't happen
+            return;
+        }
+        const iterator = createManagedIterator(iterable, (result)=>{
+            if (state !== 'pending') {
+                // shouldn't happen
+                return;
+            }
+            switch(result.status){
+                case 'yield':
+                    buffer.push([
+                        iterator,
+                        result
+                    ]);
+                    break;
+                case 'return':
+                    iterators.delete(iterator);
+                    break;
+                case 'error':
+                    buffer.push([
+                        iterator,
+                        result
+                    ]);
+                    iterators.delete(iterator);
+                    break;
+            }
+            flushSignal.resolve();
+        });
+        iterators.add(iterator);
+        iterator.pull();
+    }
+    return {
+        add (iterable) {
+            switch(state){
+                case 'idle':
+                    iterables.push(iterable);
+                    break;
+                case 'pending':
+                    initIterable(iterable);
+                    break;
+            }
+        },
+        async *[Symbol.asyncIterator] () {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                if (state !== 'idle') {
+                    throw new Error('Cannot iterate twice');
+                }
+                state = 'pending';
+                const _finally = _ts_add_disposable_resource(env, disposable.makeAsyncResource({}, async ()=>{
+                    state = 'done';
+                    const errors = [];
+                    await Promise.all(Array.from(iterators.values()).map(async (it)=>{
+                        try {
+                            await it.destroy();
+                        } catch (cause) {
+                            errors.push(cause);
+                        }
+                    }));
+                    buffer.length = 0;
+                    iterators.clear();
+                    flushSignal.resolve();
+                    if (errors.length > 0) {
+                        throw new AggregateError(errors);
+                    }
+                }), true);
+                ;
+                while(iterables.length > 0){
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    initIterable(iterables.shift());
+                }
+                while(iterators.size > 0){
+                    await flushSignal.promise;
+                    while(buffer.length > 0){
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        const [iterator, result] = buffer.shift();
+                        switch(result.status){
+                            case 'yield':
+                                yield result.value;
+                                iterator.pull();
+                                break;
+                            case 'error':
+                                throw result.error;
+                        }
+                    }
+                    flushSignal = createDeferred.createDeferred();
+                }
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        }
+    };
+}
+
+exports.mergeAsyncIterables = mergeAsyncIterables;