@trpc/server 11.0.0-rc.354 → 11.0.0-rc.361

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

@@ -0,0 +1,108 @@
+// @trpc/server
+import { TRPCError } from '../../../../@trpc/server';
+import type {
+  AnyRouter,
+  CombinedDataTransformer,
+} from '../../../../@trpc/server';
+import type {
+  BaseContentTypeHandler,
+  HTTPRequest,
+} from '../../../../@trpc/server/http';
+import { createConcurrentCache } from '../../../content-handlers/concurrentCache';
+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> = () => {
+  const cache = createConcurrentCache();
+
+  return {
+    name: 'lambda-json',
+    isMatch: (headers) => {
+      return !!headers.get('content-type')?.startsWith('application/json');
+    },
+    getInputs: async (opts, info) => {
+      function getRawProcedureInputOrThrow() {
+        const { event, req } = opts;
+
+        try {
+          if (req.query.has('input')) {
+            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 = await cache.concurrentSafeGet('rawInput', () =>
+        getRawProcedureInputOrThrow(),
+      );
+      if (rawInput === undefined) {
+        return undefined;
+      }
+
+      const transformer = opts.router._def._config.transformer;
+
+      if (!info.isBatchCall) {
+        return cache.concurrentSafeGet('input', () =>
+          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',
+        });
+      }
+
+      return cache.concurrentSafeGet(String(info.batch), () =>
+        deserializeInputValue(rawInput[info.batch], 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/concurrentCache.ts

@@ -0,0 +1,16 @@
+/**
+ * A simple concurrent cache that ensures that only one promise is created for a given key.
+ */
+export function createConcurrentCache() {
+  const cache = new Map<string, any>();
+
+  return {
+    concurrentSafeGet<TValue>(key: string, setter: () => TValue): TValue {
+      if (!cache.has(key)) {
+        cache.set(key, setter());
+      }
+
+      return cache.get(key) as TValue;
+    },
+  };
+}

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

@@ -0,0 +1,45 @@
+import { TRPCError } from '../../@trpc/server';
+import type {
+  BaseContentTypeHandler,
+  HTTPHeaders,
+} from '../../@trpc/server/http';
+
+interface MinimalHandlerOpts {
+  req: {
+    // TODO: This could probably only take Headers and do the conversion higher up,
+    //       but that's a bigger refactor for another day
+    headers: HTTPHeaders | Headers;
+  };
+}
+
+export function selectContentHandlerOrUnsupportedMediaType<
+  THandlerOpts extends MinimalHandlerOpts,
+  THandler extends BaseContentTypeHandler<THandlerOpts>,
+>(handlers: THandler[], opts: THandlerOpts) {
+  const headers = new Headers(opts.req.headers as HeadersInit);
+  const contentType = headers.get('content-type');
+
+  if (contentType === null) {
+    return [
+      undefined,
+      new TRPCError({
+        code: 'UNSUPPORTED_MEDIA_TYPE',
+        message:
+          'No Content-Type header detected on the incoming request. This request may not be supported by your tRPC Adapter, or possibly by tRPC at all',
+      }),
+    ] as const;
+  }
+
+  const handler = handlers.find((handler) => handler.isMatch(headers));
+  if (!handler) {
+    return [
+      undefined,
+      new TRPCError({
+        code: 'UNSUPPORTED_MEDIA_TYPE',
+        message: `Invalid Content-Type header '${contentType}'. 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,106 @@
+// @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 { createConcurrentCache } from '../../../content-handlers/concurrentCache';
+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> = () => {
+  const cache = createConcurrentCache();
+
+  return {
+    name: 'fastify-json',
+    isMatch: (headers) => {
+      return !!headers.get('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 cache.concurrentSafeGet('rawInput', () =>
+        getRawProcedureInputOrThrow(),
+      );
+      if (rawInput === undefined) {
+        return undefined;
+      }
+
+      const transformer = opts.router._def._config.transformer;
+
+      if (!info.isBatchCall) {
+        return cache.concurrentSafeGet('input', () =>
+          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',
+        });
+      }
+
+      return cache.concurrentSafeGet(String(info.batch), () =>
+        deserializeInputValue(rawInput[info.batch], 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,90 @@
+// @trpc/server
+import { TRPCError } from '../../../../@trpc/server';
+import type {
+  AnyRouter,
+  CombinedDataTransformer,
+} from '../../../../@trpc/server';
+import type { BaseContentTypeHandler } from '../../../../@trpc/server/http';
+import { createConcurrentCache } from '../../../content-handlers/concurrentCache';
+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> = () => {
+  const cache = createConcurrentCache();
+
+  return {
+    name: 'fetch-json',
+    isMatch: (headers) => {
+      return !!headers.get('content-type')?.startsWith('application/json');
+    },
+    getInputs: async (opts, info) => {
+      async function getRawProcedureInputOrThrow() {
+        try {
+          if (opts.url.searchParams.has('input')) {
+            const input = opts.url.searchParams.get('input');
+            if (!input) {
+              return undefined;
+            }
+
+            return JSON.parse(input);
+          }
+
+          return await opts.req.json();
+        } 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 cache.concurrentSafeGet('rawInput', () =>
+        getRawProcedureInputOrThrow(),
+      );
+      if (rawInput === undefined) {
+        return undefined;
+      }
+
+      const transformer = opts.router._def._config.transformer;
+
+      if (!info.isBatchCall) {
+        return cache.concurrentSafeGet('input', () =>
+          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',
+        });
+      }
+
+      return cache.concurrentSafeGet(String(info.batch), () =>
+        deserializeInputValue(rawInput[info.batch], 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 });
     },