@trpc/server 11.0.0-alpha-tmp-app-router-example.388 → 11.0.0-alpha-tmp-issues-5851-take-two.451

package/dist/unstable-core-do-not-import/stream/{stream.js → jsonl.js}

@@ -1,20 +1,10 @@
 'use strict';
 
+var TRPCError = require('../error/TRPCError.js');
 var utils = require('../utils.js');
+var createDeferred = require('./utils/createDeferred.js');
+var createReadableStream = require('./utils/createReadableStream.js');
 
-// ---------- utils
-function createReadableStream() {
-    let controller = null;
-    const stream = new ReadableStream({
-        start (c) {
-            controller = c;
-        }
-    });
-    return [
-        stream,
-        controller
-    ];
-}
 // ---------- types
 const CHUNK_VALUE_TYPE_PROMISE = 0;
 const CHUNK_VALUE_TYPE_ASYNC_ITERABLE = 1;
@@ -36,14 +26,14 @@ function createBatchStreamProducer(opts) {
     const { data  } = opts;
     let counter = 0;
     const placeholder = 0;
-    const [stream, controller] = createReadableStream();
+    const stream = createReadableStream.createReadableStream();
     const pending = new Set();
     function maybeClose() {
-        if (pending.size === 0) {
-            controller.close();
+        if (pending.size === 0 && !stream.cancelled()) {
+            stream.controller.close();
         }
     }
-    function hydratePromise(promise, path) {
+    function dehydratePromise(promise, path) {
         //
         const error = checkMaxDepth(path);
         if (error) {
@@ -54,25 +44,28 @@ function createBatchStreamProducer(opts) {
         }
         const idx = counter++;
         pending.add(idx);
-        const enqueue = (value)=>{
-            controller.enqueue(value);
-        };
-        promise.then((it)=>{
-            enqueue([
+        Promise.race([
+            promise,
+            stream.cancelledPromise
+        ]).then((it)=>{
+            if (it === null) {
+                return;
+            }
+            stream.controller.enqueue([
                 idx,
                 PROMISE_STATUS_FULFILLED,
-                hydrate(it, path)
+                dehydrate(it, path)
             ]);
-        }).catch((error)=>{
+        }).catch((cause)=>{
             opts.onError?.({
-                error,
+                error: cause,
                 path
             });
-            enqueue([
+            stream.controller.enqueue([
                 idx,
                 PROMISE_STATUS_REJECTED,
                 opts.formatError?.({
-                    error,
+                    error: cause,
                     path
                 })
             ]);
@@ -82,7 +75,7 @@ function createBatchStreamProducer(opts) {
         });
         return idx;
     }
-    function hydrateAsyncIterable(iterable, path) {
+    function dehydrateAsyncIterable(iterable, path) {
         const error = checkMaxDepth(path);
         if (error) {
             iterable = {
@@ -93,37 +86,58 @@ function createBatchStreamProducer(opts) {
         }
         const idx = counter++;
         pending.add(idx);
-        void (async ()=>{
-            try {
-                for await (const item of iterable){
-                    controller.enqueue([
+        utils.run(async ()=>{
+            const iterator = iterable[Symbol.asyncIterator]();
+            while(true){
+                const next = await Promise.race([
+                    iterator.next().catch(TRPCError.getTRPCErrorFromUnknown),
+                    stream.cancelledPromise
+                ]);
+                if (next instanceof Error) {
+                    opts.onError?.({
+                        error: next,
+                        path
+                    });
+                    stream.controller.enqueue([
                         idx,
-                        ASYNC_ITERABLE_STATUS_VALUE,
-                        hydrate(item, path)
+                        ASYNC_ITERABLE_STATUS_ERROR,
+                        opts.formatError?.({
+                            error: next,
+                            path
+                        })
                     ]);
+                    return;
                 }
-                controller.enqueue([
-                    idx,
-                    ASYNC_ITERABLE_STATUS_DONE
-                ]);
-            } catch (error) {
-                opts.onError?.({
-                    error,
-                    path
-                });
-                controller.enqueue([
+                if (next === 'cancelled') {
+                    await iterator.return?.();
+                    break;
+                }
+                if (next.done) {
+                    stream.controller.enqueue([
+                        idx,
+                        ASYNC_ITERABLE_STATUS_DONE
+                    ]);
+                    break;
+                }
+                stream.controller.enqueue([
                     idx,
-                    ASYNC_ITERABLE_STATUS_ERROR,
-                    opts.formatError?.({
-                        error,
-                        path
-                    })
+                    ASYNC_ITERABLE_STATUS_VALUE,
+                    dehydrate(next.value, path)
                 ]);
-            } finally{
-                pending.delete(idx);
-                maybeClose();
             }
-        })();
+            pending.delete(idx);
+            maybeClose();
+        }).catch((cause)=>{
+            // this shouldn't happen, but node crashes if we don't catch it
+            opts.onError?.({
+                error: new Error('You found a bug - please report it on https://github.com/trpc/trpc', // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore https://github.com/tc39/proposal-error-cause
+                {
+                    cause
+                }),
+                path
+            });
+        });
         return idx;
     }
     function checkMaxDepth(path) {
@@ -132,11 +146,11 @@ function createBatchStreamProducer(opts) {
         }
         return null;
     }
-    function hydrateChunk(value, path) {
+    function dehydrateChunk(value, path) {
         if (isPromise(value)) {
             return [
                 CHUNK_VALUE_TYPE_PROMISE,
-                hydratePromise(value, path)
+                dehydratePromise(value, path)
             ];
         }
         if (utils.isAsyncIterable(value)) {
@@ -145,13 +159,13 @@ function createBatchStreamProducer(opts) {
             }
             return [
                 CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-                hydrateAsyncIterable(value, path)
+                dehydrateAsyncIterable(value, path)
             ];
         }
         return null;
     }
-    function hydrate(value, path) {
-        const reg = hydrateChunk(value, path);
+    function dehydrate(value, path) {
+        const reg = dehydrateChunk(value, path);
         if (reg) {
             return [
                 [
@@ -173,7 +187,7 @@ function createBatchStreamProducer(opts) {
         const newObj = {};
         const asyncValues = [];
         for (const [key, item] of Object.entries(value)){
-            const transformed = hydrateChunk(item, [
+            const transformed = dehydrateChunk(item, [
                 ...path,
                 key
             ]);
@@ -196,13 +210,13 @@ function createBatchStreamProducer(opts) {
     }
     const newHead = {};
     for (const [key, item] of Object.entries(data)){
-        newHead[key] = hydrate(item, [
+        newHead[key] = dehydrate(item, [
             key
         ]);
     }
     return [
         newHead,
-        stream
+        stream.readable
     ];
 }
 /**
@@ -246,7 +260,7 @@ class AsyncError extends Error {
 const nodeJsStreamToReaderEsque = (source)=>{
     return {
         getReader () {
-            const [stream, controller] = createReadableStream();
+            const { readable , controller  } = createReadableStream.createReadableStream();
             source.on('data', (chunk)=>{
                 controller.enqueue(chunk);
             });
@@ -256,7 +270,7 @@ const nodeJsStreamToReaderEsque = (source)=>{
             source.on('error', (error)=>{
                 controller.error(error);
             });
-            return stream.getReader();
+            return readable.getReader();
         }
     };
 };
@@ -302,24 +316,12 @@ function createConsumerStream(from) {
         }
     }));
 }
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject
-    };
-}
 /**
  * JSON Lines stream consumer
  * @see https://jsonlines.org/
  */ async function jsonlStreamConsumer(opts) {
     const { deserialize =(v)=>v  } = opts;
+    const streamAbortController = new AbortController();
     let source = createConsumerStream(opts.from);
     if (deserialize) {
         source = source.pipeThrough(new TransformStream({
@@ -328,17 +330,21 @@ function createDeferred() {
             }
         }));
     }
-    let headDeferred = createDeferred();
+    let headDeferred = createDeferred.createDeferred();
     const chunkDeferred = new Map();
     const controllers = new Map();
-    function dehydrateChunkDefinition(value) {
+    function hydrateChunkDefinition(value, path) {
         const [_path, type, chunkId] = value;
-        const [stream, controller] = createReadableStream();
-        controllers.set(chunkId, controller);
+        const { readable , controller  } = createReadableStream.createReadableStream();
+        const wrapper = {
+            controller,
+            abortController: new AbortController()
+        };
+        controllers.set(chunkId, wrapper);
         // resolve chunk deferred if it exists
         const deferred = chunkDeferred.get(chunkId);
         if (deferred) {
-            deferred.resolve(controller);
+            deferred.resolve(wrapper);
             chunkDeferred.delete(chunkId);
         }
         switch(type){
@@ -346,7 +352,7 @@ function createDeferred() {
                 {
                     return new Promise((resolve, reject)=>{
                         // listen for next value in the stream
-                        const reader = stream.getReader();
+                        const reader = readable.getReader();
                         reader.read().then((it)=>{
                             if (it.done) {
                                 reject(new Error('Promise chunk ended without value'));
@@ -360,7 +366,7 @@ function createDeferred() {
                             const [_chunkId, status, data] = value;
                             switch(status){
                                 case PROMISE_STATUS_FULFILLED:
-                                    resolve(dehydrate(data));
+                                    resolve(hydrate(data, path));
                                     break;
                                 case PROMISE_STATUS_REJECTED:
                                     reject(opts.formatError?.({
@@ -377,45 +383,71 @@ function createDeferred() {
             case CHUNK_VALUE_TYPE_ASYNC_ITERABLE:
                 {
                     return {
-                        [Symbol.asyncIterator]: async function*() {
-                            const reader = stream.getReader();
-                            while(true){
-                                const { done , value  } = await reader.read();
-                                if (done) {
-                                    break;
-                                }
-                                if (value instanceof StreamInterruptedError) {
-                                    throw value;
-                                }
-                                const [_chunkId, status, data] = value;
-                                switch(status){
-                                    case ASYNC_ITERABLE_STATUS_VALUE:
-                                        yield dehydrate(data);
-                                        break;
-                                    case ASYNC_ITERABLE_STATUS_DONE:
-                                        controllers.delete(chunkId);
-                                        return;
-                                    case ASYNC_ITERABLE_STATUS_ERROR:
+                        [Symbol.asyncIterator]: ()=>{
+                            const reader = readable.getReader();
+                            const iterator = {
+                                next: async ()=>{
+                                    const { done , value  } = await reader.read();
+                                    if (value instanceof StreamInterruptedError) {
+                                        throw value;
+                                    }
+                                    if (done) {
                                         controllers.delete(chunkId);
-                                        throw opts.formatError?.({
-                                            error: data
-                                        }) ?? new AsyncError(data);
+                                        return {
+                                            done: true,
+                                            value: undefined
+                                        };
+                                    }
+                                    const [_chunkId, status, data] = value;
+                                    switch(status){
+                                        case ASYNC_ITERABLE_STATUS_VALUE:
+                                            return {
+                                                done: false,
+                                                value: hydrate(data, path)
+                                            };
+                                        case ASYNC_ITERABLE_STATUS_DONE:
+                                            controllers.delete(chunkId);
+                                            return {
+                                                done: true,
+                                                value: undefined
+                                            };
+                                        case ASYNC_ITERABLE_STATUS_ERROR:
+                                            controllers.delete(chunkId);
+                                            throw opts.formatError?.({
+                                                error: data
+                                            }) ?? new AsyncError(data);
+                                    }
+                                },
+                                return: async ()=>{
+                                    wrapper.abortController.abort();
+                                    if (chunkDeferred.size === 0 && Array.from(controllers.values()).every((it)=>it.abortController.signal.aborted)) {
+                                        // nothing is listening to the stream anymore
+                                        streamAbortController.abort();
+                                    }
+                                    return {
+                                        done: true,
+                                        value: undefined
+                                    };
                                 }
-                            }
+                            };
+                            return iterator;
                         }
                     };
                 }
         }
     }
-    function dehydrate(value) {
+    function hydrate(value, path) {
         const [[data], ...asyncProps] = value;
         for (const value1 of asyncProps){
-            const dehydrated = dehydrateChunkDefinition(value1);
-            const [path] = value1;
-            if (path === null) {
-                return dehydrated;
+            const [key] = value1;
+            const hydrated = hydrateChunkDefinition(value1, key === null ? path : [
+                ...path,
+                key
+            ]);
+            if (key === null) {
+                return hydrated;
             }
-            data[path] = dehydrated;
+            data[key] = hydrated;
         }
         return data;
     }
@@ -426,18 +458,25 @@ function createDeferred() {
             deferred.reject(error);
         }
         chunkDeferred.clear();
-        for (const controller of controllers.values()){
+        for (const { controller  } of controllers.values()){
             controller.enqueue(error);
             controller.close();
         }
         controllers.clear();
     };
     source.pipeTo(new WritableStream({
+        start (controller) {
+            streamAbortController.signal.addEventListener('abort', ()=>{
+                controller.error(streamAbortController.signal.reason);
+            });
+        },
         async write (chunkOrHead) {
             if (headDeferred) {
                 const head = chunkOrHead;
                 for (const [key, value] of Object.entries(chunkOrHead)){
-                    const parsed = dehydrate(value);
+                    const parsed = hydrate(value, [
+                        key
+                    ]);
                     head[key] = parsed;
                 }
                 headDeferred.resolve(head);
@@ -446,16 +485,16 @@ function createDeferred() {
             }
             const chunk = chunkOrHead;
             const [idx] = chunk;
-            let controller = controllers.get(idx);
-            if (!controller) {
+            let wrapper = controllers.get(idx);
+            if (!wrapper) {
                 let deferred = chunkDeferred.get(idx);
                 if (!deferred) {
-                    deferred = createDeferred();
+                    deferred = createDeferred.createDeferred();
                     chunkDeferred.set(idx, deferred);
                 }
-                controller = await deferred.promise;
+                wrapper = await deferred.promise;
             }
-            controller.enqueue(chunk);
+            wrapper.controller.enqueue(chunk);
         },
         close: closeOrAbort,
         abort: closeOrAbort