@trpc/server 11.0.0-rc.370 → 11.0.0-rc.374

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

@@ -0,0 +1,462 @@
+import { isObject, isFunction, isAsyncIterable } from '../utils.mjs';
+
+// ---------- 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;
+const PROMISE_STATUS_FULFILLED = 0;
+const PROMISE_STATUS_REJECTED = 1;
+const ASYNC_ITERABLE_STATUS_DONE = 0;
+const ASYNC_ITERABLE_STATUS_VALUE = 1;
+const ASYNC_ITERABLE_STATUS_ERROR = 2;
+function isPromise(value) {
+    return (isObject(value) || isFunction(value)) && typeof value?.['then'] === 'function' && typeof value?.['catch'] === 'function';
+}
+class MaxDepthError extends Error {
+    constructor(path){
+        super('Max depth reached at path: ' + path.join('.'));
+        this.path = path;
+    }
+}
+function createBatchStreamProducer(opts) {
+    const { data  } = opts;
+    let counter = 0;
+    const placeholder = 0;
+    const [stream, controller] = createReadableStream();
+    const pending = new Set();
+    function maybeClose() {
+        if (pending.size === 0) {
+            controller.close();
+        }
+    }
+    function hydratePromise(promise, path) {
+        //
+        const error = checkMaxDepth(path);
+        if (error) {
+            promise.catch(()=>{
+            // ignore
+            });
+            promise = Promise.reject(error);
+        }
+        const idx = counter++;
+        pending.add(idx);
+        const enqueue = (value)=>{
+            controller.enqueue(value);
+        };
+        promise.then((it)=>{
+            enqueue([
+                idx,
+                PROMISE_STATUS_FULFILLED,
+                hydrate(it, path)
+            ]);
+        }).catch((err)=>{
+            opts.onError?.({
+                error: err,
+                path
+            });
+            enqueue([
+                idx,
+                PROMISE_STATUS_REJECTED
+            ]);
+        }).finally(()=>{
+            pending.delete(idx);
+            maybeClose();
+        });
+        return idx;
+    }
+    function hydrateAsyncIterable(iterable, path) {
+        const error = checkMaxDepth(path);
+        if (error) {
+            iterable = {
+                [Symbol.asyncIterator] () {
+                    throw error;
+                }
+            };
+        }
+        const idx = counter++;
+        pending.add(idx);
+        void (async ()=>{
+            try {
+                for await (const item of iterable){
+                    controller.enqueue([
+                        idx,
+                        ASYNC_ITERABLE_STATUS_VALUE,
+                        hydrate(item, path)
+                    ]);
+                }
+                controller.enqueue([
+                    idx,
+                    ASYNC_ITERABLE_STATUS_DONE
+                ]);
+            } catch (error) {
+                opts.onError?.({
+                    error,
+                    path
+                });
+                controller.enqueue([
+                    idx,
+                    ASYNC_ITERABLE_STATUS_ERROR
+                ]);
+            } finally{
+                pending.delete(idx);
+                maybeClose();
+            }
+        })();
+        return idx;
+    }
+    function checkMaxDepth(path) {
+        if (opts.maxDepth && path.length > opts.maxDepth) {
+            return new MaxDepthError(path);
+        }
+        return null;
+    }
+    function hydrateChunk(value, path) {
+        if (isPromise(value)) {
+            return [
+                CHUNK_VALUE_TYPE_PROMISE,
+                hydratePromise(value, path)
+            ];
+        }
+        if (isAsyncIterable(value)) {
+            if (opts.maxDepth && path.length >= opts.maxDepth) {
+                throw new Error('Max depth reached');
+            }
+            return [
+                CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
+                hydrateAsyncIterable(value, path)
+            ];
+        }
+        return null;
+    }
+    function hydrate(value, path) {
+        const reg = hydrateChunk(value, path);
+        if (reg) {
+            return [
+                [
+                    placeholder
+                ],
+                [
+                    null,
+                    ...reg
+                ]
+            ];
+        }
+        if (!isObject(value)) {
+            return [
+                [
+                    value
+                ]
+            ];
+        }
+        const newObj = {};
+        const asyncValues = [];
+        for (const [key, item] of Object.entries(value)){
+            const transformed = hydrateChunk(item, [
+                ...path,
+                key
+            ]);
+            if (!transformed) {
+                newObj[key] = item;
+                continue;
+            }
+            newObj[key] = placeholder;
+            asyncValues.push([
+                key,
+                ...transformed
+            ]);
+        }
+        return [
+            [
+                newObj
+            ],
+            ...asyncValues
+        ];
+    }
+    const newHead = {};
+    for (const [key, item] of Object.entries(data)){
+        newHead[key] = hydrate(item, [
+            key
+        ]);
+    }
+    return [
+        newHead,
+        stream
+    ];
+}
+/**
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
+ */ function jsonlStreamProducer(opts) {
+    let [head, stream] = createBatchStreamProducer(opts);
+    const { serialize  } = opts;
+    if (serialize) {
+        head = serialize(head);
+        stream = stream.pipeThrough(new TransformStream({
+            transform (chunk, controller) {
+                controller.enqueue(serialize(chunk));
+            }
+        }));
+    }
+    return stream.pipeThrough(new TransformStream({
+        start (controller) {
+            controller.enqueue(JSON.stringify(head) + '\n');
+        },
+        transform (chunk, controller) {
+            controller.enqueue(JSON.stringify(chunk) + '\n');
+        }
+    })).pipeThrough(new TextEncoderStream());
+}
+class StreamInterruptedError extends Error {
+    constructor(cause){
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        super('Invalid response or stream interrupted', {
+            cause
+        });
+    }
+}
+class AsyncError extends Error {
+    constructor(data){
+        super('Received error from server');
+        this.data = data;
+    }
+}
+const nodeJsStreamToReaderEsque = (source)=>{
+    return {
+        getReader () {
+            const [stream, controller] = createReadableStream();
+            source.on('data', (chunk)=>{
+                controller.enqueue(chunk);
+            });
+            source.on('end', ()=>{
+                controller.close();
+            });
+            source.on('error', (error)=>{
+                controller.error(error);
+            });
+            return stream.getReader();
+        }
+    };
+};
+function createLineAccumulator(from) {
+    const reader = 'getReader' in from ? from.getReader() : nodeJsStreamToReaderEsque(from).getReader();
+    let lineAggregate = '';
+    return new ReadableStream({
+        async pull (controller) {
+            const { done , value  } = await reader.read();
+            if (done) {
+                controller.close();
+            } else {
+                controller.enqueue(value);
+            }
+        },
+        cancel () {
+            return reader.cancel();
+        }
+    }).pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            lineAggregate += chunk;
+            const parts = lineAggregate.split('\n');
+            lineAggregate = parts.pop() ?? '';
+            for (const part of parts){
+                controller.enqueue(part);
+            }
+        }
+    }));
+}
+function createConsumerStream(from) {
+    const stream = createLineAccumulator(from);
+    let sentHead = false;
+    return stream.pipeThrough(new TransformStream({
+        transform (line, controller) {
+            if (!sentHead) {
+                const head = JSON.parse(line);
+                controller.enqueue(head);
+                sentHead = true;
+            } else {
+                const chunk = JSON.parse(line);
+                controller.enqueue(chunk);
+            }
+        }
+    }));
+}
+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;
+    let source = createConsumerStream(opts.from);
+    if (deserialize) {
+        source = source.pipeThrough(new TransformStream({
+            transform (chunk, controller) {
+                controller.enqueue(deserialize(chunk));
+            }
+        }));
+    }
+    let headDeferred = createDeferred();
+    const chunkDeferred = new Map();
+    const controllers = new Map();
+    function dehydrateChunkDefinition(value) {
+        const [_path, type, chunkId] = value;
+        const [stream, controller] = createReadableStream();
+        controllers.set(chunkId, controller);
+        // resolve chunk deferred if it exists
+        const deferred = chunkDeferred.get(chunkId);
+        if (deferred) {
+            deferred.resolve(controller);
+            chunkDeferred.delete(chunkId);
+        }
+        switch(type){
+            case CHUNK_VALUE_TYPE_PROMISE:
+                {
+                    return new Promise((resolve, reject)=>{
+                        // listen for next value in the stream
+                        const reader = stream.getReader();
+                        reader.read().then((it)=>{
+                            if (it.done) {
+                                reject(new Error('Promise chunk ended without value'));
+                                return;
+                            }
+                            if (it.value instanceof StreamInterruptedError) {
+                                reject(it.value);
+                                return;
+                            }
+                            const value = it.value;
+                            const [_chunkId, status, data] = value;
+                            switch(status){
+                                case PROMISE_STATUS_FULFILLED:
+                                    resolve(dehydrate(data));
+                                    break;
+                                case PROMISE_STATUS_REJECTED:
+                                    reject(new AsyncError(data));
+                                    break;
+                            }
+                        }).catch(reject).finally(()=>{
+                            // reader.releaseLock();
+                            controllers.delete(chunkId);
+                        });
+                    });
+                }
+            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:
+                                        controllers.delete(chunkId);
+                                        throw new AsyncError(data);
+                                }
+                            }
+                        }
+                    };
+                }
+        }
+    }
+    function dehydrate(value) {
+        const [[data], ...asyncProps] = value;
+        for (const value1 of asyncProps){
+            const dehydrated = dehydrateChunkDefinition(value1);
+            const [path] = value1;
+            if (path === null) {
+                return dehydrated;
+            }
+            data[path] = dehydrated;
+        }
+        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()){
+            controller.enqueue(error);
+            controller.close();
+        }
+        controllers.clear();
+    };
+    source.pipeTo(new WritableStream({
+        async write (chunkOrHead) {
+            if (headDeferred) {
+                const head = chunkOrHead;
+                for (const [key, value] of Object.entries(chunkOrHead)){
+                    const parsed = dehydrate(value);
+                    head[key] = parsed;
+                }
+                headDeferred.resolve(head);
+                headDeferred = null;
+                return;
+            }
+            const chunk = chunkOrHead;
+            const [idx] = chunk;
+            let controller = controllers.get(idx);
+            if (!controller) {
+                let deferred = chunkDeferred.get(idx);
+                if (!deferred) {
+                    deferred = createDeferred();
+                    chunkDeferred.set(idx, deferred);
+                }
+                controller = await deferred.promise;
+            }
+            controller.enqueue(chunk);
+        },
+        close: closeOrAbort,
+        abort: closeOrAbort
+    })).catch((error)=>{
+        opts.onError?.({
+            error
+        });
+        closeOrAbort(error);
+    });
+    return [
+        await headDeferred.promise,
+        {
+            controllers
+        }
+    ];
+}
+
+export { isPromise, jsonlStreamConsumer, jsonlStreamProducer };

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

@@ -11,12 +11,13 @@ export declare function mergeWithoutOverrides<TType extends Record<string, unkno
  * @internal
  */
 export declare function isObject(value: unknown): value is Record<string, unknown>;
-type AnyFn = (...args: any[]) => unknown;
+type AnyFn = ((...args: any[]) => unknown) & Record<keyof any, unknown>;
 export declare function isFunction(fn: unknown): fn is AnyFn;
 /**
  * Create an object without inheriting anything from `Object.prototype`
  * @internal
  */
 export declare function omitPrototype<TObj extends Record<string, unknown>>(obj: TObj): TObj;
+export declare function isAsyncIterable<TValue>(value: unknown): value is AsyncIterable<TValue>;
 export {};
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/utils.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,eAAO,MAAM,WAAW,eAAwB,CAAC;AACjD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,GACxB,KAAK,CAYP;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,KAAK,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;AACzC,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,KAAK,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,GAAG,EAAE,IAAI,GACR,IAAI,CAEN"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/utils.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,eAAO,MAAM,WAAW,eAAwB,CAAC;AACjD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,GACxB,KAAK,CAYP;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,KAAK,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,EAAE,OAAO,CAAC,CAAC;AACxE,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,KAAK,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,GAAG,EAAE,IAAI,GACR,IAAI,CAEN;AAED,wBAAgB,eAAe,CAAC,MAAM,EACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,aAAa,CAAC,MAAM,CAAC,CAEhC"}

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

@@ -31,7 +31,11 @@ function isFunction(fn) {
  */ function omitPrototype(obj) {
     return Object.assign(Object.create(null), obj);
 }
+function isAsyncIterable(value) {
+    return isObject(value) && Symbol.asyncIterator in value;
+}
 
+exports.isAsyncIterable = isAsyncIterable;
 exports.isFunction = isFunction;
 exports.isObject = isObject;
 exports.mergeWithoutOverrides = mergeWithoutOverrides;

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

@@ -29,5 +29,8 @@ function isFunction(fn) {
  */ function omitPrototype(obj) {
     return Object.assign(Object.create(null), obj);
 }
+function isAsyncIterable(value) {
+    return isObject(value) && Symbol.asyncIterator in value;
+}
 
-export { isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker };
+export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker };

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

@@ -33,4 +33,5 @@ export * from './unstable-core-do-not-import/rpc';
 export * from './unstable-core-do-not-import/transformer';
 export * from './unstable-core-do-not-import/types';
 export * from './unstable-core-do-not-import/utils';
+export * from './unstable-core-do-not-import/stream/stream';
 //# sourceMappingURL=unstable-core-do-not-import.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"unstable-core-do-not-import.d.ts","sourceRoot":"","sources":["../src/unstable-core-do-not-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,yDAAyD,CAAC;AACxE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,sDAAsD,CAAC;AACrE,cAAc,oDAAoD,CAAC;AACnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"unstable-core-do-not-import.d.ts","sourceRoot":"","sources":["../src/unstable-core-do-not-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,yDAAyD,CAAC;AACxE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,sDAAsD,CAAC;AACrE,cAAc,oDAAoD,CAAC;AACnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,6CAA6C,CAAC"}

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

@@ -22,6 +22,7 @@ var parseTRPCMessage = require('./unstable-core-do-not-import/rpc/parseTRPCMessa
 var transformer = require('./unstable-core-do-not-import/transformer.js');
 var types = require('./unstable-core-do-not-import/types.js');
 var utils = require('./unstable-core-do-not-import/utils.js');
+var stream = require('./unstable-core-do-not-import/stream/stream.js');
 
 
 
@@ -61,8 +62,12 @@ exports.getDataTransformer = transformer.getDataTransformer;
 exports.transformResult = transformer.transformResult;
 exports.transformTRPCResponse = transformer.transformTRPCResponse;
 exports.ERROR_SYMBOL = types.ERROR_SYMBOL;
+exports.isAsyncIterable = utils.isAsyncIterable;
 exports.isFunction = utils.isFunction;
 exports.isObject = utils.isObject;
 exports.mergeWithoutOverrides = utils.mergeWithoutOverrides;
 exports.omitPrototype = utils.omitPrototype;
 exports.unsetMarker = utils.unsetMarker;
+exports.isPromise = stream.isPromise;
+exports.jsonlStreamConsumer = stream.jsonlStreamConsumer;
+exports.jsonlStreamProducer = stream.jsonlStreamProducer;

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

@@ -19,4 +19,5 @@ export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER } from './unstable-
 export { parseTRPCMessage } from './unstable-core-do-not-import/rpc/parseTRPCMessage.mjs';
 export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
 export { ERROR_SYMBOL } from './unstable-core-do-not-import/types.mjs';
-export { isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker } from './unstable-core-do-not-import/utils.mjs';
+export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker } from './unstable-core-do-not-import/utils.mjs';
+export { isPromise, jsonlStreamConsumer, jsonlStreamProducer } from './unstable-core-do-not-import/stream/stream.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.370+1a920ac81",
+  "version": "11.0.0-rc.374+5027209bc",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -149,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "1a920ac8160dacfb6a49e6161f56208859168317"
+  "gitHead": "5027209bc300d299224ecef764adeac09b8cab8d"
 }

package/src/adapters/node-http/incomingMessageToRequest.ts

@@ -17,32 +17,32 @@ function incomingMessageToBodyStream(
   type Value = Buffer | Uint8Array | string | null;
   let size = 0;
   const maxBodySize = opts.maxBodySize;
+  let hasClosed = false;
 
-  let controller: ReadableStreamDefaultController<Value> =
-    null as unknown as ReadableStreamDefaultController<Value>;
   const stream = new ReadableStream<Value>({
-    start(c) {
-      controller = c;
-    },
-    async pull(c) {
-      const chunk: Value = req.read();
-
-      if (chunk) {
+    start(controller) {
+      req.on('data', (chunk) => {
         size += chunk.length;
-      }
-      if (maxBodySize !== null && size > maxBodySize) {
-        controller.error(
-          new TRPCError({
-            code: 'PAYLOAD_TOO_LARGE',
-          }),
-        );
-        return;
-      }
-      if (chunk === null) {
-        c.close();
-        return;
-      }
-      controller.enqueue(chunk);
+        if (maxBodySize != null && size > maxBodySize) {
+          controller.error(
+            new TRPCError({
+              code: 'PAYLOAD_TOO_LARGE',
+            }),
+          );
+          // an error is thrown if we try to close the controller after
+          // erroring, so track the closure
+          hasClosed = true;
+          return;
+        }
+        controller.enqueue(chunk);
+      });
+      req.once('end', () => {
+        if (hasClosed) {
+          return;
+        }
+        hasClosed = true;
+        controller.close();
+      });
     },
     cancel() {
       req.destroy();

package/src/unstable-core-do-not-import/clientish/serialize.ts

@@ -26,6 +26,7 @@ type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never
 export type Serialize<T> =
   IsAny<T> extends true ? any :
   unknown extends T ? unknown :
+  T extends AsyncIterable<infer U> ? AsyncIterable<Serialize<U>> :
   T extends JsonReturnable ? T :
   T extends Map<any, any> | Set<any> ? object :
   T extends NonJsonPrimitive ? never :