@trpc/server 11.0.0-alpha-tmp-12-06-react.674 → 11.0.0-alpha-tmp-issues-6374.696

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;

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-12-06-react.674+d396198ca",
+  "version": "11.0.0-alpha-tmp-issues-6374.696+c944cfbf2",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -118,7 +118,7 @@
   },
   "devDependencies": {
     "@fastify/websocket": "^10.0.1",
-    "@tanstack/react-query": "^5.59.15",
+    "@tanstack/react-query": "^5.62.8",
     "@types/aws-lambda": "^8.10.137",
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
@@ -128,19 +128,19 @@
     "@types/ws": "^8.2.0",
     "devalue": "^5.0.0",
     "eslint": "^9.13.0",
-    "express": "^4.17.1",
+    "express": "^5.0.0",
     "fastify": "^4.16.0",
     "fastify-plugin": "^5.0.0",
     "hash-sum": "^2.0.0",
     "myzod": "^1.3.1",
-    "next": "^15.0.4",
+    "next": "^15.1.3",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "rollup": "^4.24.4",
     "superjson": "^1.12.4",
     "superstruct": "^2.0.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.7.0",
+    "typescript": "^5.7.2",
     "valibot": "^0.42.0",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
@@ -150,7 +150,7 @@
     "https://trpc.io/sponsor"
   ],
   "peerDependencies": {
-    "typescript": ">=5.6.2"
+    "typescript": ">=5.7.2"
   },
-  "gitHead": "d396198ca526f56f0a5954cdee0fd407476d9475"
+  "gitHead": "c944cfbf28c0723b087dfd4b2d26c554457374f0"
 }

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -19,8 +19,8 @@ import {
 // @trpc/server/node-http
 import {
   incomingMessageToRequest,
-  type IncomingMessageWithBody,
   type NodeHTTPCreateContextOption,
+  type UniversalIncomingMessage,
 } from '../node-http';
 
 export type FastifyHandlerOptions<
@@ -54,7 +54,7 @@ export async function fastifyRequestHandler<
     });
   };
 
-  const incomingMessage = opts.req.raw as IncomingMessageWithBody;
+  const incomingMessage: UniversalIncomingMessage = opts.req.raw;
 
   // monkey-path body to the IncomingMessage
   if ('body' in opts.req) {

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

@@ -1,15 +1,23 @@
 import type * as http from 'http';
 import { TRPCError } from '../../@trpc/server';
 
-export interface IncomingMessageWithBody extends http.IncomingMessage {
+export interface UniversalIncomingMessage
+  extends Omit<http.IncomingMessage, 'socket'> {
   /**
    * Many adapters will add a `body` property to the incoming message and pre-parse the body
    */
   body?: unknown;
+  /**
+   * Socket is not always available in all deployments, so we need to make it optional
+   * @see https://github.com/trpc/trpc/issues/6341
+   * The socket object provided in the request does not fully implement the expected Node.js Socket interface.
+   * @see https://github.com/trpc/trpc/pull/6358
+   */
+  socket?: Partial<http.IncomingMessage['socket']>;
 }
 
 function createBody(
-  req: http.IncomingMessage,
+  req: UniversalIncomingMessage,
   opts: {
     /**
      * Max body size in bytes. If the body is larger than this, the request will be aborted
@@ -19,16 +27,16 @@ function createBody(
 ): RequestInit['body'] {
   // Some adapters will pre-parse the body and add it to the request object
   if ('body' in req) {
+    if (req.body === undefined) {
+      // If body property exists but is undefined, return undefined
+      return undefined;
+    }
     // If the body is already a string, return it directly
     if (typeof req.body === 'string') {
       return req.body;
     }
     // If body exists but isn't a string, stringify it as JSON
-    else if (req.body !== undefined) {
-      return JSON.stringify(req.body);
-    }
-    // If body property exists but is undefined, return undefined
-    return undefined;
+    return JSON.stringify(req.body);
   }
   let size = 0;
   let hasClosed = false;
@@ -71,7 +79,7 @@ function createBody(
     },
   });
 }
-export function createURL(req: http.IncomingMessage): URL {
+export function createURL(req: UniversalIncomingMessage): URL {
   try {
     const protocol =
       req.socket && 'encrypted' in req.socket && req.socket.encrypted
@@ -117,7 +125,7 @@ function createHeaders(incoming: http.IncomingHttpHeaders): Headers {
  * Convert an [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
  */
 export function incomingMessageToRequest(
-  req: http.IncomingMessage,
+  req: UniversalIncomingMessage,
   res: http.ServerResponse,
   opts: {
     /**
@@ -130,14 +138,14 @@ export function incomingMessageToRequest(
 
   const onAbort = () => {
     res.off('close', onAbort);
-    req.socket.off('end', onAbort);
+    req.socket?.off?.('end', onAbort);
 
     // abort the request
     ac.abort();
   };
 
   res.once('close', onAbort);
-  req.socket.once('end', onAbort);
+  req.socket?.once?.('end', onAbort);
 
   // Get host from either regular header or HTTP/2 pseudo-header
   const url = createURL(req);

package/src/unstable-core-do-not-import/createProxy.ts

@@ -70,11 +70,12 @@ export const createRecursiveProxy = <TFaux = unknown>(
  * @internal
  */
 export const createFlatProxy = <TFaux>(
-  callback: (path: string & keyof TFaux) => any,
+  callback: (path: (string & keyof TFaux) | symbol) => any,
 ): TFaux => {
   return new Proxy(noop, {
     get(_obj, name) {
-      if (typeof name !== 'string' || name === 'then') {
+      const type = typeof name;
+      if ((type !== 'string' && type !== 'symbol') || name === 'then') {
         // special case for if the proxy is accidentally treated
         // like a PromiseLike (like in `Promise.resolve(proxy)`)
         return undefined;