@trpc/server 11.0.0-rc.340 → 11.0.0-rc.345

package/src/adapters/aws-lambda/content-type/json/index.ts

@@ -0,0 +1,99 @@
+// @trpc/server
+import { TRPCError } from '../../../../@trpc/server';
+import type {
+  AnyRouter,
+  CombinedDataTransformer,
+} from '../../../../@trpc/server';
+import type {
+  BaseContentTypeHandler,
+  HTTPRequest,
+} from '../../../../@trpc/server/http';
+import {
+  lambdaEventToHTTPBody,
+  type APIGatewayEvent,
+  type AWSLambdaOptions,
+} from '../../utils';
+
+export interface LambdaHTTPContentTypeHandler<
+  TRouter extends AnyRouter,
+  TEvent extends APIGatewayEvent,
+> extends BaseContentTypeHandler<
+    AWSLambdaOptions<TRouter, TEvent> & {
+      event: TEvent;
+      req: HTTPRequest;
+    }
+  > {}
+
+export const getLambdaHTTPJSONContentTypeHandler: <
+  TRouter extends AnyRouter,
+  TEvent extends APIGatewayEvent,
+>() => LambdaHTTPContentTypeHandler<TRouter, TEvent> = () => ({
+  name: 'lambda-json',
+  isMatch(opts) {
+    return !!opts.event.headers['Content-Type']?.startsWith('application/json');
+  },
+  getInputs: async (opts, info) => {
+    function getRawProcedureInputOrThrow() {
+      const { event, req } = opts;
+
+      try {
+        if (req.method === 'GET') {
+          const input = req.query.get('input');
+          if (!input) {
+            return undefined;
+          }
+
+          return JSON.parse(input);
+        }
+
+        const body = lambdaEventToHTTPBody(opts.event);
+        if (typeof body === 'string') {
+          // A mutation with no inputs will have req.body === ''
+          return body.length === 0 ? undefined : JSON.parse(body);
+        }
+        return event.body;
+      } catch (cause) {
+        throw new TRPCError({
+          code: 'PARSE_ERROR',
+          cause,
+        });
+      }
+    }
+
+    const deserializeInputValue = (
+      rawValue: unknown,
+      transformer: CombinedDataTransformer,
+    ) => {
+      return typeof rawValue !== 'undefined'
+        ? transformer.input.deserialize(rawValue)
+        : rawValue;
+    };
+
+    const rawInput = getRawProcedureInputOrThrow();
+    if (rawInput === undefined) {
+      return undefined;
+    }
+
+    const transformer = opts.router._def._config.transformer;
+
+    if (!info.isBatchCall) {
+      return deserializeInputValue(rawInput, transformer);
+    }
+
+    /* istanbul ignore if  */
+    if (
+      rawInput == null ||
+      typeof rawInput !== 'object' ||
+      Array.isArray(rawInput)
+    ) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: '"input" needs to be an object when doing a batch call',
+      });
+    }
+
+    const rawValue = rawInput[info.batch];
+
+    return deserializeInputValue(rawValue, transformer);
+  },
+});

package/src/adapters/aws-lambda/index.ts

@@ -24,6 +24,8 @@ import type {
   ResolveHTTPRequestOptionsContextFn,
 } from '../../@trpc/server/http';
 import { resolveHTTPResponse } from '../../@trpc/server/http';
+import { selectContentHandlerOrUnsupportedMediaType } from '../content-handlers/selectContentHandlerOrUnsupportedMediaType';
+import { getLambdaHTTPJSONContentTypeHandler } from './content-type/json';
 import type {
   APIGatewayEvent,
   APIGatewayResult,
@@ -50,18 +52,10 @@ function lambdaEventToHTTPRequest(event: APIGatewayEvent): HTTPRequest {
     }
   }
 
-  let body: string | null | undefined;
-  if (event.body && event.isBase64Encoded) {
-    body = Buffer.from(event.body, 'base64').toString('utf8');
-  } else {
-    body = event.body;
-  }
-
   return {
     method: getHTTPMethod(event),
     query: query,
     headers: event.headers,
-    body: body,
   };
 }
 
@@ -109,18 +103,39 @@ export function awsLambdaRequestHandler<
   return async (event, context) => {
     const req = lambdaEventToHTTPRequest(event);
     const path = getPath(event);
+
     const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
       innerOpts,
     ) => {
       return await opts.createContext?.({ event, context, ...innerOpts });
     };
 
+    const [contentTypeHandler, unsupportedMediaTypeError] =
+      selectContentHandlerOrUnsupportedMediaType(
+        [getLambdaHTTPJSONContentTypeHandler<TRouter, TEvent>()],
+        {
+          ...opts,
+          event,
+          req,
+        },
+      );
+
     const response = await resolveHTTPResponse({
       ...opts,
       createContext,
       req,
       path,
-      error: null,
+      error: unsupportedMediaTypeError,
+      async getInput(info) {
+        return await contentTypeHandler?.getInputs(
+          {
+            ...opts,
+            event,
+            req,
+          },
+          info,
+        );
+      },
       onError(o) {
         opts?.onError?.({
           ...o,

package/src/adapters/aws-lambda/utils.ts

@@ -14,7 +14,12 @@ import type {
   APIGatewayProxyStructuredResultV2,
   Context as APIGWContext,
 } from 'aws-lambda';
-import type { AnyRouter, inferRouterContext } from '../../@trpc/server'; // import @trpc/server
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../../@trpc/server';
+// import @trpc/server
 
 // @trpc/server
 import { TRPCError } from '../../@trpc/server';
@@ -50,20 +55,10 @@ export type AWSLambdaOptions<
   TEvent extends APIGatewayEvent,
 > =
   | HTTPBaseHandlerOptions<TRouter, TEvent> &
-      (
-        | {
-            /**
-             * @link https://trpc.io/docs/v11/context
-             **/
-            createContext: AWSLambdaCreateContextFn<TRouter, TEvent>;
-          }
-        | {
-            /**
-             * @link https://trpc.io/docs/v11/context
-             **/
-            createContext?: AWSLambdaCreateContextFn<TRouter, TEvent>;
-          }
-      );
+      CreateContextCallback<
+        inferRouterContext<AnyRouter>,
+        AWSLambdaCreateContextFn<TRouter, TEvent>
+      >;
 
 export function isPayloadV1(
   event: APIGatewayEvent,
@@ -162,3 +157,14 @@ export type APIGatewayPayloadFormatVersion =
 export const UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE =
   'Custom payload format version not handled by this adapter. Please use either 1.0 or 2.0. More information here' +
   'https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html';
+
+export function lambdaEventToHTTPBody(event: APIGatewayEvent) {
+  let body: string | null | undefined;
+  if (event.body && event.isBase64Encoded) {
+    body = Buffer.from(event.body, 'base64').toString('utf8');
+  } else {
+    body = event.body;
+  }
+
+  return body;
+}

package/src/adapters/content-handlers/selectContentHandlerOrUnsupportedMediaType.ts

@@ -0,0 +1,21 @@
+import { TRPCError } from '../../@trpc/server';
+import type { BaseContentTypeHandler } from '../../@trpc/server/http';
+
+export function selectContentHandlerOrUnsupportedMediaType<
+  THandlerOpts,
+  THandler extends BaseContentTypeHandler<THandlerOpts>,
+>(handlers: THandler[], opts: THandlerOpts) {
+  const handler = handlers.find((handler) => handler.isMatch(opts));
+  if (!handler) {
+    return [
+      undefined,
+      new TRPCError({
+        code: 'UNSUPPORTED_MEDIA_TYPE',
+        message:
+          'Invalid Content-Type header. This request may not be supported by your tRPC Adapter, or possibly by tRPC at all',
+      }),
+    ] as const;
+  }
+
+  return [handler] as const;
+}

package/src/adapters/express.ts

@@ -27,12 +27,7 @@ export function createExpressMiddleware<TRouter extends AnyRouter>(
     const endpoint = req.path.slice(1);
 
     await nodeHTTPRequestHandler({
-      // FIXME: no typecasting should be needed here
-      ...(opts as NodeHTTPHandlerOptions<
-        AnyRouter,
-        express.Request,
-        express.Response
-      >),
+      ...opts,
       req,
       res,
       path: endpoint,

package/src/adapters/fastify/content-type/json/index.ts

@@ -0,0 +1,97 @@
+// @trpc/server
+import type { FastifyReply, FastifyRequest } from 'fastify';
+import { TRPCError } from '../../../../@trpc/server';
+import type {
+  AnyRouter,
+  CombinedDataTransformer,
+} from '../../../../@trpc/server';
+import type { BaseContentTypeHandler } from '../../../../@trpc/server/http';
+import type { FastifyRequestHandlerOptions } from '../../types';
+
+export interface FastifyHTTPContentTypeHandler<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> extends BaseContentTypeHandler<
+    FastifyRequestHandlerOptions<TRouter, TRequest, TResponse>
+  > {}
+
+export const getFastifyHTTPJSONContentTypeHandler: <
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+>() => FastifyHTTPContentTypeHandler<TRouter, TRequest, TResponse> = () => ({
+  name: 'fastify-json',
+  isMatch(opts) {
+    return !!opts.req.headers['content-type']?.startsWith('application/json');
+  },
+  getInputs: async (opts, info) => {
+    async function getRawProcedureInputOrThrow() {
+      const { req } = opts;
+
+      try {
+        if (req.method === 'GET') {
+          const query = opts.req.query
+            ? new URLSearchParams(opts.req.query as any)
+            : new URLSearchParams(opts.req.url.split('?')[1]);
+
+          const input = query.get('input');
+          if (!input) {
+            return undefined;
+          }
+
+          return JSON.parse(input);
+        }
+
+        const body = opts.req.body ?? 'null';
+        if (typeof body === 'string') {
+          // A mutation with no inputs will have req.body === ''
+          return body.length === 0 ? undefined : JSON.parse(body);
+        }
+
+        return body;
+      } catch (cause) {
+        throw new TRPCError({
+          code: 'PARSE_ERROR',
+          cause,
+        });
+      }
+    }
+
+    const deserializeInputValue = (
+      rawValue: unknown,
+      transformer: CombinedDataTransformer,
+    ) => {
+      return typeof rawValue !== 'undefined'
+        ? transformer.input.deserialize(rawValue)
+        : rawValue;
+    };
+
+    const rawInput = await getRawProcedureInputOrThrow();
+    if (rawInput === undefined) {
+      return undefined;
+    }
+
+    const transformer = opts.router._def._config.transformer;
+
+    if (!info.isBatchCall) {
+      return deserializeInputValue(rawInput, transformer);
+    }
+
+    /* istanbul ignore if  */
+    if (
+      rawInput == null ||
+      typeof rawInput !== 'object' ||
+      Array.isArray(rawInput)
+    ) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: '"input" needs to be an object when doing a batch call',
+      });
+    }
+
+    const rawValue = rawInput[info.batch];
+
+    return deserializeInputValue(rawValue, transformer);
+  },
+});

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -7,12 +7,11 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import { Readable } from 'node:stream';
+import { Readable } from 'stream';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 // @trpc/server
 import type { AnyRouter } from '../../@trpc/server';
 import type {
-  HTTPBaseHandlerOptions,
   HTTPRequest,
   HTTPResponse,
   ResolveHTTPRequestOptionsContextFn,
@@ -22,24 +21,9 @@ import {
   getBatchStreamFormatter,
   resolveHTTPResponse,
 } from '../../@trpc/server/http';
-import type { NodeHTTPCreateContextOption } from '../node-http';
-
-export type FastifyHandlerOptions<
-  TRouter extends AnyRouter,
-  TRequest extends FastifyRequest,
-  TResponse extends FastifyReply,
-> = HTTPBaseHandlerOptions<TRouter, TRequest> &
-  NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
-
-type FastifyRequestHandlerOptions<
-  TRouter extends AnyRouter,
-  TRequest extends FastifyRequest,
-  TResponse extends FastifyReply,
-> = FastifyHandlerOptions<TRouter, TRequest, TResponse> & {
-  req: TRequest;
-  res: TResponse;
-  path: string;
-};
+import { selectContentHandlerOrUnsupportedMediaType } from '../content-handlers/selectContentHandlerOrUnsupportedMediaType';
+import { getFastifyHTTPJSONContentTypeHandler } from './content-type/json';
+import type { FastifyRequestHandlerOptions } from './types';
 
 export async function fastifyRequestHandler<
   TRouter extends AnyRouter,
@@ -63,7 +47,6 @@ export async function fastifyRequestHandler<
     query,
     method: opts.req.method,
     headers: opts.req.headers,
-    body: opts.req.body ?? 'null',
   };
 
   let resolve: (value: FastifyReply) => void;
@@ -108,10 +91,21 @@ export async function fastifyRequestHandler<
     }
   };
 
+  const [contentTypeHandler, unsupportedMediaTypeError] =
+    selectContentHandlerOrUnsupportedMediaType(
+      [getFastifyHTTPJSONContentTypeHandler<TRouter, TRequest, TResponse>()],
+      opts,
+    );
+
   resolveHTTPResponse({
     ...opts,
     req,
+    error: unsupportedMediaTypeError,
+    async getInput(info) {
+      return await contentTypeHandler?.getInputs(opts, info);
+    },
     createContext,
+
     onError(o) {
       opts?.onError?.({ ...o, req: opts.req });
     },

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -9,13 +9,13 @@
  */
 /// <reference types="@fastify/websocket" />
 import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
-import type { FastifyHandlerOptions } from '.';
 // @trpc/server
 import type { AnyRouter } from '../../@trpc/server';
 import type { NodeHTTPCreateContextFnOptions } from '../node-http';
 import type { WSSHandlerOptions } from '../ws';
 import { getWSConnectionHandler } from '../ws';
 import { fastifyRequestHandler } from './fastifyRequestHandler';
+import type { FastifyHandlerOptions } from './types';
 
 export interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {
   prefix?: string;

package/src/adapters/fastify/types.ts

@@ -0,0 +1,22 @@
+import type { FastifyReply, FastifyRequest } from 'fastify';
+// @trpc/server
+import type { AnyRouter } from '../../@trpc/server';
+import type { HTTPBaseHandlerOptions } from '../../@trpc/server/http';
+import type { NodeHTTPConditionCreateContextOption } from '../node-http';
+
+export type FastifyHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = HTTPBaseHandlerOptions<TRouter, TRequest> &
+  NodeHTTPConditionCreateContextOption<TRouter, TRequest, TResponse>;
+
+export type FastifyRequestHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = FastifyHandlerOptions<TRouter, TRequest, TResponse> & {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+};

package/src/adapters/fetch/content-type/json/index.ts

@@ -0,0 +1,96 @@
+// @trpc/server
+import { TRPCError } from '../../../../@trpc/server';
+import type {
+  AnyRouter,
+  CombinedDataTransformer,
+} from '../../../../@trpc/server';
+import type { BaseContentTypeHandler } from '../../../../@trpc/server/http';
+import type { FetchHandlerRequestOptions } from '../../types';
+
+export interface FetchHTTPContentTypeHandler<TRouter extends AnyRouter>
+  extends BaseContentTypeHandler<
+    FetchHandlerRequestOptions<TRouter> & {
+      url: URL;
+    }
+  > {}
+
+export const getFetchHTTPJSONContentTypeHandler: <
+  TRouter extends AnyRouter,
+>() => FetchHTTPContentTypeHandler<TRouter> = () => ({
+  name: 'fetch-json',
+  isMatch(opts) {
+    return !!opts.req.headers
+      .get('content-type')
+      ?.startsWith('application/json');
+  },
+  getInputs: async (opts, info) => {
+    async function getRawProcedureInputOrThrow() {
+      const { req } = opts;
+
+      try {
+        if (req.method === 'GET') {
+          const input = opts.url.searchParams.get('input');
+          if (!input) {
+            return undefined;
+          }
+
+          return JSON.parse(input);
+        }
+
+        const body = opts.req.headers
+          .get('content-type')
+          ?.startsWith('application/json')
+          ? await opts.req.text()
+          : '';
+
+        if (typeof body === 'string') {
+          // A mutation with no inputs will have req.body === ''
+          return body.length === 0 ? undefined : JSON.parse(body);
+        }
+
+        return body;
+      } catch (cause) {
+        throw new TRPCError({
+          code: 'PARSE_ERROR',
+          cause,
+        });
+      }
+    }
+
+    const deserializeInputValue = (
+      rawValue: unknown,
+      transformer: CombinedDataTransformer,
+    ) => {
+      return typeof rawValue !== 'undefined'
+        ? transformer.input.deserialize(rawValue)
+        : rawValue;
+    };
+
+    const rawInput = await getRawProcedureInputOrThrow();
+    if (rawInput === undefined) {
+      return undefined;
+    }
+
+    const transformer = opts.router._def._config.transformer;
+
+    if (!info.isBatchCall) {
+      return deserializeInputValue(rawInput, transformer);
+    }
+
+    /* istanbul ignore if  */
+    if (
+      rawInput == null ||
+      typeof rawInput !== 'object' ||
+      Array.isArray(rawInput)
+    ) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: '"input" needs to be an object when doing a batch call',
+      });
+    }
+
+    const rawValue = rawInput[info.batch];
+
+    return deserializeInputValue(rawValue, transformer);
+  },
+});

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -21,14 +21,10 @@ import {
   resolveHTTPResponse,
   toURL,
 } from '../../@trpc/server/http';
+import { selectContentHandlerOrUnsupportedMediaType } from '../content-handlers/selectContentHandlerOrUnsupportedMediaType';
+import { getFetchHTTPJSONContentTypeHandler } from './content-type/json';
 import type { FetchHandlerOptions } from './types';
 
-export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
-  FetchHandlerOptions<TRouter> & {
-    req: Request;
-    endpoint: string;
-  };
-
 const trimSlashes = (path: string): string => {
   path = path.startsWith('/') ? path.slice(1) : path;
   path = path.endsWith('/') ? path.slice(0, -1) : path;
@@ -37,7 +33,7 @@ const trimSlashes = (path: string): string => {
 };
 
 export async function fetchRequestHandler<TRouter extends AnyRouter>(
-  opts: FetchHandlerRequestOptions<TRouter>,
+  opts: FetchHandlerOptions<TRouter>,
 ): Promise<Response> {
   const resHeaders = new Headers();
 
@@ -57,9 +53,6 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
     query: url.searchParams,
     method: opts.req.method,
     headers: Object.fromEntries(opts.req.headers),
-    body: opts.req.headers.get('content-type')?.startsWith('application/json')
-      ? await opts.req.text()
-      : '',
   };
 
   let resolve: (value: Response) => void;
@@ -117,11 +110,30 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
     }
   };
 
+  const [contentTypeHandler, unsupportedMediaTypeError] =
+    selectContentHandlerOrUnsupportedMediaType(
+      [getFetchHTTPJSONContentTypeHandler<TRouter>()],
+      {
+        ...opts,
+        url,
+      },
+    );
+
   resolveHTTPResponse({
     ...opts,
     req,
     createContext,
     path,
+    error: unsupportedMediaTypeError,
+    async getInput(info) {
+      return await contentTypeHandler?.getInputs(
+        {
+          ...opts,
+          url,
+        },
+        info,
+      );
+    },
     onError(o) {
       opts?.onError?.({ ...o, req: opts.req });
     },

package/src/adapters/fetch/types.ts

@@ -8,7 +8,12 @@
  * ```
  */
 // @trpc/server
-import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+  WrapCreateContext,
+} from '../../@trpc/server';
 // @trpc/server/http
 import type {
   HTTPBaseHandlerOptions,
@@ -26,19 +31,21 @@ export type FetchCreateContextFn<TRouter extends AnyRouter> = (
 ) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
 
 export type FetchCreateContextOption<TRouter extends AnyRouter> =
-  unknown extends inferRouterContext<TRouter>
-    ? {
-        /**
-         * @link https://trpc.io/docs/v11/context
-         **/
-        createContext?: FetchCreateContextFn<TRouter>;
-      }
-    : {
-        /**
-         * @link https://trpc.io/docs/v11/context
-         **/
-        createContext: FetchCreateContextFn<TRouter>;
-      };
+  CreateContextCallback<
+    inferRouterContext<TRouter>,
+    FetchCreateContextFn<TRouter>
+  >;
 
 export type FetchHandlerOptions<TRouter extends AnyRouter> =
-  FetchCreateContextOption<TRouter> & HTTPBaseHandlerOptions<TRouter, Request>;
+  FetchCreateContextOption<TRouter> &
+    HTTPBaseHandlerOptions<TRouter, Request> & {
+      req: Request;
+      endpoint: string;
+    };
+
+export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
+  HTTPBaseHandlerOptions<TRouter, Request> &
+    WrapCreateContext<FetchCreateContextFn<TRouter>> & {
+      req: Request;
+      endpoint: string;
+    };