@trpc/server 11.0.0-rc.417 → 11.0.0-rc.419

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,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;AAKD,wBAAgB,eAAe,CAAC,MAAM,EACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,aAAa,CAAC,MAAM,CAAC,CAIhC"}
+{"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;AAKD,wBAAgB,eAAe,CAAC,MAAM,EACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,aAAa,CAAC,MAAM,CAAC,CAIhC;AAED;;GAEG;AACH,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,MAAM,MAAM,KAAG,MAAc,CAAC"}

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

@@ -35,10 +35,14 @@ const asyncIteratorsSupported = typeof Symbol === 'function' && !!Symbol.asyncIt
 function isAsyncIterable(value) {
     return asyncIteratorsSupported && isObject(value) && Symbol.asyncIterator in value;
 }
+/**
+ * Run an IIFE
+ */ const run = (fn)=>fn();
 
 exports.isAsyncIterable = isAsyncIterable;
 exports.isFunction = isFunction;
 exports.isObject = isObject;
 exports.mergeWithoutOverrides = mergeWithoutOverrides;
 exports.omitPrototype = omitPrototype;
+exports.run = run;
 exports.unsetMarker = unsetMarker;

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

@@ -33,5 +33,8 @@ const asyncIteratorsSupported = typeof Symbol === 'function' && !!Symbol.asyncIt
 function isAsyncIterable(value) {
     return asyncIteratorsSupported && isObject(value) && Symbol.asyncIterator in value;
 }
+/**
+ * Run an IIFE
+ */ const run = (fn)=>fn();
 
-export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker };
+export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, run, unsetMarker };

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

@@ -33,5 +33,6 @@ 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';
+export * from './unstable-core-do-not-import/stream/jsonl';
+export * from './unstable-core-do-not-import/stream/sse';
 //# 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;AACpD,cAAc,6CAA6C,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,4CAA4C,CAAC;AAC3D,cAAc,0CAA0C,CAAC"}

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

@@ -22,7 +22,8 @@ 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');
+var jsonl = require('./unstable-core-do-not-import/stream/jsonl.js');
+var sse = require('./unstable-core-do-not-import/stream/sse.js');
 
 
 
@@ -67,7 +68,13 @@ exports.isFunction = utils.isFunction;
 exports.isObject = utils.isObject;
 exports.mergeWithoutOverrides = utils.mergeWithoutOverrides;
 exports.omitPrototype = utils.omitPrototype;
+exports.run = utils.run;
 exports.unsetMarker = utils.unsetMarker;
-exports.isPromise = stream.isPromise;
-exports.jsonlStreamConsumer = stream.jsonlStreamConsumer;
-exports.jsonlStreamProducer = stream.jsonlStreamProducer;
+exports.isPromise = jsonl.isPromise;
+exports.jsonlStreamConsumer = jsonl.jsonlStreamConsumer;
+exports.jsonlStreamProducer = jsonl.jsonlStreamProducer;
+exports.isServerSentEventEnvelope = sse.isServerSentEventEnvelope;
+exports.sse = sse.sse;
+exports.sseHeaders = sse.sseHeaders;
+exports.sseStreamConsumer = sse.sseStreamConsumer;
+exports.sseStreamProducer = sse.sseStreamProducer;

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

@@ -19,5 +19,6 @@ 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 { 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';
+export { isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, omitPrototype, run, unsetMarker } from './unstable-core-do-not-import/utils.mjs';
+export { isPromise, jsonlStreamConsumer, jsonlStreamProducer } from './unstable-core-do-not-import/stream/jsonl.mjs';
+export { isServerSentEventEnvelope, sse, sseHeaders, sseStreamConsumer, sseStreamProducer } from './unstable-core-do-not-import/stream/sse.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.417+94650c185",
+  "version": "11.0.0-rc.419+343b6de2e",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -140,7 +140,7 @@
     "superstruct": "^1.0.0",
     "tslib": "^2.5.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.4.0",
+    "typescript": "^5.5.0",
     "valibot": "^0.33.0",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
@@ -149,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "94650c185b067c86f2e71fb224b1e70f463632b7"
+  "gitHead": "343b6de2ea719347bffe8332f37589c66c323349"
 }

package/src/@trpc/server/index.ts

@@ -37,6 +37,7 @@ export {
   type QueryProcedure as TRPCQueryProcedure,
   type SubscriptionProcedure as TRPCSubscriptionProcedure,
   type TRPCBuilder,
+  sse,
 } from '../../unstable-core-do-not-import';
 
 export type {

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

@@ -68,8 +68,9 @@ export function incomingMessageToRequest(
   const ac = new AbortController();
   const headers = new Headers(req.headers as any);
   const url = `http://${headers.get('host')}${req.url}`;
-
-  req.once('aborted', () => ac.abort());
+  req.once('aborted', () => {
+    ac.abort();
+  });
 
   const init: RequestInit = {
     headers,

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

@@ -10,7 +10,6 @@
 
 // @trpc/server
 
-import { Readable } from 'node:stream';
 import { getTRPCErrorFromUnknown, type AnyRouter } from '../../@trpc/server';
 import type { ResolveHTTPRequestOptionsContextFn } from '../../@trpc/server/http';
 import { resolveResponse } from '../../@trpc/server/http';
@@ -56,17 +55,43 @@ export async function nodeHTTPRequestHandler<
       },
     });
 
-    if (opts.res.statusCode === 200) {
+    const { res } = opts;
+    if (res.statusCode === 200) {
       // if the status code is set, we assume that it's been manually overridden
-      opts.res.statusCode = response.status;
+      res.statusCode = response.status;
     }
     for (const [key, value] of response.headers) {
-      opts.res.setHeader(key, value);
+      res.setHeader(key, value);
     }
     if (response.body) {
-      Readable.fromWeb(response.body as any).pipe(opts.res);
-    } else {
-      opts.res.end();
+      const reader = response.body.getReader();
+      const onAbort = () => {
+        // cancelling the reader will cause the whole stream to be cancelled
+        reader.cancel().catch(() => {
+          // console.error('reader.cancel() error', err);
+        });
+      };
+      req.signal.addEventListener('abort', onAbort);
+
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          break;
+        }
+        if (!res.writable) {
+          break;
+        }
+        if (!res.write(value)) {
+          await new Promise<void>((resolve) => {
+            res.once('drain', resolve);
+          });
+        }
+        // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
+        res.flush?.();
+      }
+      req.signal.removeEventListener('abort', onAbort);
     }
+    res.end();
   });
 }

package/src/adapters/ws.ts

@@ -16,15 +16,18 @@ import type { BaseHandlerOptions } from '../@trpc/server/http';
 import { parseTRPCMessage } from '../@trpc/server/rpc';
 // @trpc/server/rpc
 import type {
-  JSONRPC2,
   TRPCClientOutgoingMessage,
   TRPCReconnectNotification,
   TRPCResponseMessage,
 } from '../@trpc/server/rpc';
 import { isObservable } from '../observable';
-import type { Unsubscribable } from '../observable';
+import { observableToAsyncIterable } from '../observable/observable';
 // eslint-disable-next-line no-restricted-imports
-import type { MaybePromise } from '../unstable-core-do-not-import';
+import {
+  isAsyncIterable,
+  run,
+  type MaybePromise,
+} from '../unstable-core-do-not-import';
 import type { NodeHTTPCreateContextFnOptions } from './node-http';
 
 /**
@@ -88,7 +91,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
   const { transformer } = router._def._config;
 
   return async (client: ws.WebSocket, req: IncomingMessage) => {
-    const clientSubscriptions = new Map<number | string, Unsubscribable>();
+    const clientSubscriptions = new Map<number | string, AbortController>();
 
     function respond(untransformedJSON: TRPCResponseMessage) {
       client.send(
@@ -98,21 +101,6 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
       );
     }
 
-    function stopSubscription(
-      subscription: Unsubscribable,
-      { id, jsonrpc }: JSONRPC2.BaseEnvelope & { id: JSONRPC2.RequestId },
-    ) {
-      subscription.unsubscribe();
-
-      respond({
-        id,
-        jsonrpc,
-        result: {
-          type: 'stopped',
-        },
-      });
-    }
-
     const ctxPromise = createContext?.({ req, res: client });
     let ctx: inferRouterContext<TRouter> | undefined = undefined;
 
@@ -126,11 +114,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
         });
       }
       if (msg.method === 'subscription.stop') {
-        const sub = clientSubscriptions.get(id);
-        if (sub) {
-          stopSubscription(sub, { id, jsonrpc });
-        }
-        clientSubscriptions.delete(id);
+        clientSubscriptions.get(id)?.abort();
         return;
       }
       const { path, input } = msg.params;
@@ -146,14 +130,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
           type,
         });
 
-        if (type === 'subscription') {
-          if (!isObservable(result)) {
-            throw new TRPCError({
-              message: `Subscription ${path} did not return an observable`,
-              code: 'INTERNAL_SERVER_ERROR',
-            });
-          }
-        } else {
+        if (type !== 'subscription') {
           // send the value as data if the method is not a subscription
           respond({
             id,
@@ -166,62 +143,112 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
           return;
         }
 
-        const observable = result;
-        const sub = observable.subscribe({
-          next(data) {
-            respond({
-              id,
-              jsonrpc,
-              result: {
-                type: 'data',
-                data,
-              },
-            });
-          },
-          error(err) {
-            const error = getTRPCErrorFromUnknown(err);
-            opts.onError?.({ error, path, type, ctx, req, input });
-            respond({
-              id,
-              jsonrpc,
-              error: getErrorShape({
-                config: router._def._config,
-                error,
-                type,
-                path,
-                input,
-                ctx,
-              }),
-            });
-          },
-          complete() {
-            respond({
-              id,
-              jsonrpc,
-              result: {
-                type: 'stopped',
-              },
-            });
-          },
-        });
+        if (!isObservable(result) && !isAsyncIterable(result)) {
+          throw new TRPCError({
+            message: `Subscription ${path} did not return an observable or a AsyncGenerator`,
+            code: 'INTERNAL_SERVER_ERROR',
+          });
+        }
+
         /* istanbul ignore next -- @preserve */
         if (client.readyState !== WEBSOCKET_OPEN) {
           // if the client got disconnected whilst initializing the subscription
           // no need to send stopped message if the client is disconnected
-          sub.unsubscribe();
+
           return;
         }
 
         /* istanbul ignore next -- @preserve */
         if (clientSubscriptions.has(id)) {
           // duplicate request ids for client
-          stopSubscription(sub, { id, jsonrpc });
+
           throw new TRPCError({
             message: `Duplicate id ${id}`,
             code: 'BAD_REQUEST',
           });
         }
-        clientSubscriptions.set(id, sub);
+
+        const iterable = isObservable(result)
+          ? observableToAsyncIterable(result)
+          : result;
+
+        const iterator: AsyncIterator<unknown> =
+          iterable[Symbol.asyncIterator]();
+        const abortController = new AbortController();
+
+        const abortPromise = new Promise<'abort'>((resolve) => {
+          abortController.signal.onabort = () => resolve('abort');
+        });
+
+        run(async () => {
+          while (true) {
+            const next = await Promise.race([
+              iterator.next().catch(getTRPCErrorFromUnknown),
+              abortPromise,
+            ]);
+
+            if (next === 'abort') {
+              await iterator.return?.();
+              break;
+            }
+            if (next instanceof Error) {
+              const error = getTRPCErrorFromUnknown(next);
+              opts.onError?.({ error, path, type, ctx, req, input });
+              respond({
+                id,
+                jsonrpc,
+                error: getErrorShape({
+                  config: router._def._config,
+                  error,
+                  type,
+                  path,
+                  input,
+                  ctx,
+                }),
+              });
+              break;
+            }
+            if (next.done) {
+              break;
+            }
+
+            respond({
+              id,
+              jsonrpc,
+              result: {
+                type: 'data',
+                data: next.value,
+              },
+            });
+          }
+
+          await iterator.return?.();
+          respond({
+            id,
+            jsonrpc,
+            result: {
+              type: 'stopped',
+            },
+          });
+          clientSubscriptions.delete(id);
+        }).catch((cause) => {
+          const error = getTRPCErrorFromUnknown(cause);
+          opts.onError?.({ error, path, type, ctx, req, input });
+          respond({
+            id,
+            jsonrpc,
+            error: getErrorShape({
+              config: router._def._config,
+              error,
+              type,
+              path,
+              input,
+              ctx,
+            }),
+          });
+          abortController.abort();
+        });
+        clientSubscriptions.set(id, abortController);
 
         respond({
           id,
@@ -250,7 +277,6 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
     }
     client.on('message', async (message) => {
       try {
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
         const msgJSON: unknown = JSON.parse(message.toString());
         const msgs: unknown[] = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
         const promises = msgs
@@ -294,7 +320,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
 
     client.once('close', () => {
       for (const sub of clientSubscriptions.values()) {
-        sub.unsubscribe();
+        sub.abort();
       }
       clientSubscriptions.clear();
     });

package/src/observable/observable.ts

@@ -4,6 +4,7 @@ import type {
   OperatorFunction,
   TeardownLogic,
   UnaryFunction,
+  Unsubscribable,
 } from './types';
 
 /** @public */
@@ -136,3 +137,65 @@ export function observableToPromise<TValue>(
     abort: abort!,
   };
 }
+
+/**
+ * @internal
+ */
+function observableToReadableStream<TValue>(
+  observable: Observable<TValue, unknown>,
+): ReadableStream<TValue> {
+  let unsub: Unsubscribable | null = null;
+  return new ReadableStream<TValue>({
+    start(controller) {
+      unsub = observable.subscribe({
+        next(data) {
+          controller.enqueue(data);
+        },
+        error(err) {
+          controller.error(err);
+        },
+        complete() {
+          controller.close();
+        },
+      });
+    },
+    cancel() {
+      unsub?.unsubscribe();
+    },
+  });
+}
+
+export function observableToAsyncIterable<TValue>(
+  observable: Observable<TValue, unknown>,
+): AsyncIterable<TValue> {
+  const stream = observableToReadableStream(observable);
+
+  const reader = stream.getReader();
+  const iterator: AsyncIterator<TValue> = {
+    async next() {
+      const value = await reader.read();
+      if (value.done) {
+        return {
+          value: undefined,
+          done: true,
+        };
+      }
+      return {
+        value: value.value,
+        done: false,
+      };
+    },
+    async return() {
+      await reader.cancel();
+      return {
+        value: undefined,
+        done: true,
+      };
+    },
+  };
+  return {
+    [Symbol.asyncIterator]() {
+      return iterator;
+    },
+  };
+}

package/src/unstable-core-do-not-import/http/contentType.ts

@@ -1,16 +1,24 @@
 import { TRPCError } from '../error/TRPCError';
-import type { RootConfig } from '../rootConfig';
+import type { AnyProcedure, ProcedureType } from '../procedure';
+import type { AnyRouter } from '../router';
 import { isObject, unsetMarker } from '../utils';
-import type { TRPCRequestInfo } from './types';
+import type {
+  TRPCAcceptHeader,
+  TRPCRequestInfo,
+  TRPCRequestInfoBase,
+} from './types';
+
+type GetRequestInfoOptions = {
+  path: string;
+  req: Request;
+  searchParams: URLSearchParams;
+  headers: Headers;
+  router: AnyRouter;
+};
 
 type ContentTypeHandler = {
   isMatch: (opts: Request) => boolean;
-  parse: (opts: {
-    path: string;
-    req: Request;
-    searchParams: URLSearchParams;
-    config: RootConfig<any>;
-  }) => TRPCRequestInfo;
+  parse: (opts: GetRequestInfoOptions) => TRPCRequestInfo;
 };
 
 /**
@@ -82,7 +90,7 @@ const jsonContentTypeHandler: ContentTypeHandler = {
 
       if (!isBatchCall) {
         return {
-          0: opts.config.transformer.input.deserialize(inputs),
+          0: opts.router._def._config.transformer.input.deserialize(inputs),
         };
       }
 
@@ -96,26 +104,74 @@ const jsonContentTypeHandler: ContentTypeHandler = {
       for (const index of paths.keys()) {
         const input = inputs[index];
         if (input !== undefined) {
-          acc[index] = opts.config.transformer.input.deserialize(input);
+          acc[index] =
+            opts.router._def._config.transformer.input.deserialize(input);
         }
       }
 
       return acc;
     });
 
-    return {
-      isBatchCall,
-      calls: paths.map((path, index) => ({
+    const calls = paths.map((path, index): TRPCRequestInfo['calls'][number] => {
+      const procedure: AnyProcedure | null =
+        opts.router._def.procedures[path] ?? null;
+      return {
         path,
+        procedure,
         getRawInput: async () => {
           const inputs = await getInputs.read();
-          return inputs[index];
+          let input = inputs[index];
+
+          if (procedure?._def.type === 'subscription') {
+            const lastEventId =
+              opts.headers.get('last-event-id') ??
+              opts.searchParams.get('lastEventId') ??
+              opts.searchParams.get('Last-Event-Id');
+
+            if (lastEventId) {
+              if (isObject(input)) {
+                input = {
+                  ...input,
+                  lastEventId: lastEventId,
+                };
+              } else {
+                input ??= {
+                  lastEventId: lastEventId,
+                };
+              }
+            }
+          }
+          return input;
         },
         result: () => {
           return getInputs.result()?.[index];
         },
-      })),
+      };
+    });
+
+    const types = new Set(
+      calls.map((call) => call.procedure?._def.type).filter(Boolean),
+    );
+
+    /* istanbul ignore if -- @preserve */
+    if (types.size > 1) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Cannot mix procedure types in call: ${Array.from(types).join(
+          ', ',
+        )}`,
+      });
+    }
+    const type: ProcedureType | 'unknown' =
+      types.values().next().value ?? 'unknown';
+
+    const info: TRPCRequestInfoBase = {
+      isBatchCall,
+      accept: req.headers.get('trpc-accept') as TRPCAcceptHeader | null,
+      calls,
+      type,
     };
+    return info as TRPCRequestInfo;
   },
 };
 
@@ -137,14 +193,17 @@ const formDataContentTypeHandler: ContentTypeHandler = {
       return fd;
     });
     return {
+      accept: null,
       calls: [
         {
           path: opts.path,
           getRawInput: getInputs.read,
           result: getInputs.result,
+          procedure: opts.router._def.procedures[opts.path] ?? null,
         },
       ],
       isBatchCall: false,
+      type: 'mutation',
     };
   },
 };
@@ -173,9 +232,12 @@ const octetStreamContentTypeHandler: ContentTypeHandler = {
           path: opts.path,
           getRawInput: getInputs.read,
           result: getInputs.result,
+          procedure: opts.router._def.procedures[opts.path] ?? null,
         },
       ],
       isBatchCall: false,
+      accept: null,
+      type: 'mutation',
     };
   },
 };
@@ -205,12 +267,7 @@ function getContentTypeHandler(req: Request): ContentTypeHandler {
   });
 }
 
-export function getRequestInfo(opts: {
-  path: string;
-  req: Request;
-  searchParams: URLSearchParams;
-  config: RootConfig<any>;
-}): TRPCRequestInfo {
+export function getRequestInfo(opts: GetRequestInfoOptions): TRPCRequestInfo {
   const handler = getContentTypeHandler(opts.req);
   return handler.parse(opts);
 }