@trpc/server 11.0.0-rc.630 → 11.0.0-rc.632

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

@@ -1,11 +1,10 @@
 'use strict';
 
 var _define_property = require('../../node_modules/.pnpm/@swc_helpers@0.5.13/node_modules/@swc/helpers/esm/_define_property.js');
-var unpromise = require('../../vendor/unpromise/unpromise.js');
-var TRPCError = require('../error/TRPCError.js');
 var utils = require('../utils.js');
 var createDeferred = require('./utils/createDeferred.js');
 var createReadableStream = require('./utils/createReadableStream.js');
+var withRefCount = require('./utils/withRefCount.js');
 
 // ---------- types
 const CHUNK_VALUE_TYPE_PROMISE = 0;
@@ -28,41 +27,43 @@ function createBatchStreamProducer(opts) {
     let counter = 0;
     const placeholder = 0;
     const stream = createReadableStream.createReadableStream();
-    const pending = new Set();
-    function maybeClose() {
-        if (pending.size === 0 && !stream.cancelled()) {
+    const pending = withRefCount.withRefCount(new Set(), ()=>{
+        if (!stream.cancelled()) {
             stream.controller.close();
         }
-    }
-    function dehydratePromise(promise, path) {
-        //
+    });
+    const maybeEnqueue = (chunk)=>{
+        if (!stream.cancelled()) {
+            stream.controller.enqueue(chunk);
+        }
+    };
+    function encodePromise(promise, path) {
         const error = checkMaxDepth(path);
         if (error) {
-            promise.catch(()=>{
-            // ignore
+            // 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);
         }
         const idx = counter++;
         pending.add(idx);
-        unpromise.Unpromise.race([
-            promise,
-            stream.cancelledPromise
-        ]).then((it)=>{
-            if (createReadableStream.isCancelledStreamResult(it)) {
-                return;
-            }
-            stream.controller.enqueue([
+        promise.then((it)=>{
+            maybeEnqueue([
                 idx,
                 PROMISE_STATUS_FULFILLED,
-                dehydrate(it, path)
+                encode(it, path)
             ]);
         }).catch((cause)=>{
             opts.onError?.({
                 error: cause,
                 path
             });
-            stream.controller.enqueue([
+            maybeEnqueue([
                 idx,
                 PROMISE_STATUS_REJECTED,
                 opts.formatError?.({
@@ -72,73 +73,53 @@ function createBatchStreamProducer(opts) {
             ]);
         }).finally(()=>{
             pending.delete(idx);
-            maybeClose();
         });
         return idx;
     }
-    function dehydrateAsyncIterable(iterable, path) {
-        const error = checkMaxDepth(path);
-        if (error) {
-            iterable = {
-                [Symbol.asyncIterator] () {
-                    throw error;
-                }
-            };
-        }
+    function encodeAsyncIterable(iterable, path) {
         const idx = counter++;
         pending.add(idx);
         utils.run(async ()=>{
+            const error = checkMaxDepth(path);
+            if (error) {
+                throw error;
+            }
             const iterator = iterable[Symbol.asyncIterator]();
             while(true){
-                const next = await unpromise.Unpromise.race([
-                    iterator.next().catch(TRPCError.getTRPCErrorFromUnknown),
-                    stream.cancelledPromise
-                ]);
-                if (next instanceof Error) {
-                    opts.onError?.({
-                        error: next,
-                        path
-                    });
-                    stream.controller.enqueue([
-                        idx,
-                        ASYNC_ITERABLE_STATUS_ERROR,
-                        opts.formatError?.({
-                            error: next,
-                            path
-                        })
-                    ]);
-                    return;
-                }
-                if (createReadableStream.isCancelledStreamResult(next)) {
-                    await iterator.return?.();
-                    break;
+                if (stream.cancelled()) {
+                    const res = await iterator.return?.();
+                    return res?.value;
                 }
+                const next = await iterator.next();
                 if (next.done) {
-                    stream.controller.enqueue([
+                    maybeEnqueue([
                         idx,
                         ASYNC_ITERABLE_STATUS_RETURN,
-                        dehydrate(next.value, path)
+                        encode(next.value, path)
                     ]);
                     break;
                 }
-                stream.controller.enqueue([
+                maybeEnqueue([
                     idx,
                     ASYNC_ITERABLE_STATUS_VALUE,
-                    dehydrate(next.value, path)
+                    encode(next.value, path)
                 ]);
             }
-            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
-                }),
+                error: cause,
                 path
             });
+            maybeEnqueue([
+                idx,
+                ASYNC_ITERABLE_STATUS_ERROR,
+                opts.formatError?.({
+                    error: cause,
+                    path
+                })
+            ]);
+        }).finally(()=>{
+            pending.delete(idx);
         });
         return idx;
     }
@@ -148,11 +129,11 @@ function createBatchStreamProducer(opts) {
         }
         return null;
     }
-    function dehydrateAsync(value, path) {
+    function encodeAsync(value, path) {
         if (isPromise(value)) {
             return [
                 CHUNK_VALUE_TYPE_PROMISE,
-                dehydratePromise(value, path)
+                encodePromise(value, path)
             ];
         }
         if (utils.isAsyncIterable(value)) {
@@ -161,12 +142,12 @@ function createBatchStreamProducer(opts) {
             }
             return [
                 CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-                dehydrateAsyncIterable(value, path)
+                encodeAsyncIterable(value, path)
             ];
         }
         return null;
     }
-    function dehydrate(value, path) {
+    function encode(value, path) {
         if (value === undefined) {
             return [
                 []
@@ -179,7 +160,7 @@ function createBatchStreamProducer(opts) {
                 ]
             ];
         }
-        const reg = dehydrateAsync(value, path);
+        const reg = encodeAsync(value, path);
         if (reg) {
             return [
                 [
@@ -194,7 +175,7 @@ function createBatchStreamProducer(opts) {
         const newObj = {};
         const asyncValues = [];
         for (const [key, item] of Object.entries(value)){
-            const transformed = dehydrateAsync(item, [
+            const transformed = encodeAsync(item, [
                 ...path,
                 key
             ]);
@@ -217,10 +198,11 @@ function createBatchStreamProducer(opts) {
     }
     const newHead = {};
     for (const [key, item] of Object.entries(data)){
-        newHead[key] = dehydrate(item, [
+        newHead[key] = encode(item, [
             key
         ]);
     }
+    pending.activate();
     return [
         newHead,
         stream.readable
@@ -336,34 +318,19 @@ function createConsumerStream(from) {
         }));
     }
     let headDeferred = createDeferred.createDeferred();
-    const chunkDeferred = new Map();
-    const controllers = new Map();
-    const maybeAbort = ()=>{
-        if (chunkDeferred.size === 0 && Array.from(controllers.values()).every((it)=>it.returned)) {
-            // nothing is listening to the stream anymore
-            opts.abortController?.abort();
-        }
-    };
-    function hydrateChunkDefinition(value) {
+    const controllers = withRefCount.withRefCount(new Map(), ()=>{
+        opts.abortController?.abort();
+    });
+    function decodeChunkDefinition(value) {
         const [_path, type, chunkId] = value;
-        const { readable, controller } = createReadableStream.createReadableStream();
-        const wrapper = {
-            controller,
-            returned: false
-        };
-        controllers.set(chunkId, wrapper);
-        // resolve chunk deferred if it exists
-        const deferred = chunkDeferred.get(chunkId);
-        if (deferred) {
-            deferred.resolve(wrapper);
-            chunkDeferred.delete(chunkId);
-        }
+        const stream = createReadableStream.createReadableStream();
+        controllers.set(chunkId, stream.controller);
         switch(type){
             case CHUNK_VALUE_TYPE_PROMISE:
                 {
                     return new Promise((resolve, reject)=>{
                         // listen for next value in the stream
-                        const reader = readable.getReader();
+                        const reader = stream.readable.getReader();
                         reader.read().then((it)=>{
                             if (it.done) {
                                 reject(new Error('Promise chunk ended without value'));
@@ -377,7 +344,7 @@ function createConsumerStream(from) {
                             const [_chunkId, status, data] = value;
                             switch(status){
                                 case PROMISE_STATUS_FULFILLED:
-                                    resolve(hydrate(data));
+                                    resolve(decode(data));
                                     break;
                                 case PROMISE_STATUS_REJECTED:
                                     reject(opts.formatError?.({
@@ -386,9 +353,7 @@ function createConsumerStream(from) {
                                     break;
                             }
                         }).catch(reject).finally(()=>{
-                            // reader.releaseLock();
                             controllers.delete(chunkId);
-                            maybeAbort();
                         });
                     });
                 }
@@ -396,7 +361,7 @@ function createConsumerStream(from) {
                 {
                     return {
                         [Symbol.asyncIterator]: ()=>{
-                            const reader = readable.getReader();
+                            const reader = stream.readable.getReader();
                             const iterator = {
                                 next: async ()=>{
                                     const { done, value } = await reader.read();
@@ -405,7 +370,6 @@ function createConsumerStream(from) {
                                     }
                                     if (done) {
                                         controllers.delete(chunkId);
-                                        maybeAbort();
                                         return {
                                             done: true,
                                             value: undefined
@@ -416,26 +380,23 @@ function createConsumerStream(from) {
                                         case ASYNC_ITERABLE_STATUS_VALUE:
                                             return {
                                                 done: false,
-                                                value: hydrate(data)
+                                                value: decode(data)
                                             };
                                         case ASYNC_ITERABLE_STATUS_RETURN:
                                             controllers.delete(chunkId);
-                                            maybeAbort();
                                             return {
                                                 done: true,
-                                                value: hydrate(data)
+                                                value: decode(data)
                                             };
                                         case ASYNC_ITERABLE_STATUS_ERROR:
                                             controllers.delete(chunkId);
-                                            maybeAbort();
                                             throw opts.formatError?.({
                                                 error: data
                                             }) ?? new AsyncError(data);
                                     }
                                 },
                                 return: async ()=>{
-                                    wrapper.returned = true;
-                                    maybeAbort();
+                                    controllers.delete(chunkId);
                                     return {
                                         done: true,
                                         value: undefined
@@ -448,26 +409,22 @@ function createConsumerStream(from) {
                 }
         }
     }
-    function hydrate(value) {
+    function decode(value) {
         const [[data], ...asyncProps] = value;
         for (const value of asyncProps){
             const [key] = value;
-            const hydrated = hydrateChunkDefinition(value);
+            const decoded = decodeChunkDefinition(value);
             if (key === null) {
-                return hydrated;
+                return decoded;
             }
-            data[key] = hydrated;
+            data[key] = decoded;
         }
         return data;
     }
     const closeOrAbort = (reason)=>{
         const error = new StreamInterruptedError(reason);
         headDeferred?.reject(error);
-        for (const deferred of chunkDeferred.values()){
-            deferred.reject(error);
-        }
-        chunkDeferred.clear();
-        for (const { controller } of controllers.values()){
+        for (const controller of controllers.values()){
             controller.enqueue(error);
             controller.close();
         }
@@ -478,25 +435,19 @@ function createConsumerStream(from) {
             if (headDeferred) {
                 const head = chunkOrHead;
                 for (const [key, value] of Object.entries(chunkOrHead)){
-                    const parsed = hydrate(value);
+                    const parsed = decode(value);
                     head[key] = parsed;
                 }
                 headDeferred.resolve(head);
                 headDeferred = null;
+                controllers.activate();
                 return;
             }
             const chunk = chunkOrHead;
             const [idx] = chunk;
-            let wrapper = controllers.get(idx);
-            if (!wrapper) {
-                let deferred = chunkDeferred.get(idx);
-                if (!deferred) {
-                    deferred = createDeferred.createDeferred();
-                    chunkDeferred.set(idx, deferred);
-                }
-                wrapper = await deferred.promise;
-            }
-            wrapper.controller.enqueue(chunk);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const controller = controllers.get(idx);
+            controller.enqueue(chunk);
         },
         close: closeOrAbort,
         abort: closeOrAbort