@trpc/server 11.0.0-alpha-tmp-issues-6374.694 → 11.0.0-alpha-tmp-issues-6374.697

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

@@ -0,0 +1,239 @@
+import { createDeferred } from './createDeferred.mjs';
+import { makeAsyncResource } from './disposable.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 (!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();
+    /**
+   * 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, 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();
+                }
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        }
+    };
+}
+
+export { mergeAsyncIterables };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-alpha-tmp-issues-6374.694+ce45f1c48",
+  "version": "11.0.0-alpha-tmp-issues-6374.697+41465ba29",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -152,5 +152,5 @@
   "peerDependencies": {
     "typescript": ">=5.7.2"
   },
-  "gitHead": "ce45f1c48b24261580aabe1793a78876d77e5168"
+  "gitHead": "41465ba29ad50fa0a28146f8d8fb85cde796c562"
 }

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

@@ -1,9 +1,9 @@
-import { Unpromise } from '../../vendor/unpromise';
 import { isAsyncIterable, isFunction, isObject, run } from '../utils';
 import { iteratorResource } from './utils/asyncIterable';
 import type { Deferred } from './utils/createDeferred';
 import { createDeferred } from './utils/createDeferred';
-import { makeAsyncResource, makeResource } from './utils/disposable';
+import { makeResource } from './utils/disposable';
+import { mergeAsyncIterables } from './utils/mergeAsyncIterables';
 import { readableStreamFrom } from './utils/readableStreamFrom';
 
 /**
@@ -128,31 +128,14 @@ async function* createBatchStreamProducer(
   let counter = 0 as ChunkIndex;
   const placeholder = 0 as PlaceholderValue;
 
-  await using queue = makeAsyncResource(
-    new Set<{
-      iterator: AsyncIterator<ChunkData, ChunkData>;
-      nextPromise: Promise<IteratorResult<ChunkData, ChunkData>>;
-    }>(),
-    async () => {
-      await Promise.all(Array.from(queue).map((it) => it.iterator.return?.()));
-    },
-  );
+  const mergedIterables = mergeAsyncIterables<ChunkData>();
   function registerAsync(
-    callback: (idx: ChunkIndex) => AsyncIterable<ChunkData, ChunkData>,
+    callback: (idx: ChunkIndex) => AsyncIterable<ChunkData, void>,
   ) {
     const idx = counter++ as ChunkIndex;
 
-    const iterator = callback(idx)[Symbol.asyncIterator]();
-
-    const nextPromise = iterator.next();
-
-    nextPromise.catch(() => {
-      // prevent unhandled promise rejection
-    });
-    queue.add({
-      iterator,
-      nextPromise,
-    });
+    const iterable = callback(idx);
+    mergedIterables.add(iterable);
 
     return idx;
   }
@@ -170,10 +153,10 @@ async function* createBatchStreamProducer(
       }
       try {
         const next = await promise;
-        return [idx, PROMISE_STATUS_FULFILLED, encode(next, path)];
+        yield [idx, PROMISE_STATUS_FULFILLED, encode(next, path)];
       } catch (cause) {
         opts.onError?.({ error: cause, path });
-        return [
+        yield [
           idx,
           PROMISE_STATUS_REJECTED,
           opts.formatError?.({ error: cause, path }),
@@ -196,17 +179,15 @@ async function* createBatchStreamProducer(
         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_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,
           ASYNC_ITERABLE_STATUS_ERROR,
           opts.formatError?.({ error: cause, path }),
@@ -270,21 +251,8 @@ async function* createBatchStreamProducer(
 
   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] as const),
-    );
-
-    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);
-    }
+  for await (const value of mergedIterables) {
+    yield value;
   }
 }
 /**

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

@@ -0,0 +1,193 @@
+import { createDeferred } from './createDeferred';
+import { makeAsyncResource } from './disposable';
+
+type ManagedIteratorResult<TYield, TReturn> =
+  | { status: 'yield'; value: TYield }
+  | { status: 'return'; value: TReturn }
+  | { status: 'error'; error: unknown };
+function createManagedIterator<TYield, TReturn>(
+  iterable: AsyncIterable<TYield, TReturn>,
+  onResult: (result: ManagedIteratorResult<TYield, TReturn>) => void,
+) {
+  const iterator = iterable[Symbol.asyncIterator]();
+  let state: 'idle' | 'pending' | 'done' = '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?.();
+    },
+  };
+}
+type ManagedIterator<TYield, TReturn> = ReturnType<
+  typeof createManagedIterator<TYield, TReturn>
+>;
+
+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 function mergeAsyncIterables<TYield>(): MergedAsyncIterables<TYield> {
+  let state: 'idle' | 'pending' | 'done' = 'idle';
+  let flushSignal = createDeferred<void>();
+
+  /**
+   * used while {@link state} is `idle`
+   */
+  const iterables: AsyncIterable<TYield, void, unknown>[] = [];
+  /**
+   * used while {@link state} is `pending`
+   */
+  const iterators = new Set<ManagedIterator<TYield, void>>();
+
+  const buffer: Array<
+    [
+      iterator: ManagedIterator<TYield, void>,
+      result: Exclude<
+        ManagedIteratorResult<TYield, void>,
+        { status: 'return' }
+      >,
+    ]
+  > = [];
+
+  function initIterable(iterable: AsyncIterable<TYield, void, unknown>) {
+    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: AsyncIterable<TYield, void, unknown>) {
+      switch (state) {
+        case 'idle':
+          iterables.push(iterable);
+          break;
+        case 'pending':
+          initIterable(iterable);
+          break;
+        case 'done': {
+          // shouldn't happen
+          break;
+        }
+      }
+    },
+    async *[Symbol.asyncIterator]() {
+      if (state !== 'idle') {
+        throw new Error('Cannot iterate twice');
+      }
+      state = 'pending';
+
+      await using _finally = makeAsyncResource({}, async () => {
+        state = 'done';
+
+        const errors: unknown[] = [];
+        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);
+        }
+      });
+
+      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();
+      }
+    },
+  };
+}