@trpc/server 10.22.0 → 10.23.0

package/src/adapters/node-http/internals/contentType.ts

@@ -0,0 +1,29 @@
+import { AnyRouter } from '../../../core';
+import { BaseContentTypeHandler } from '../../../http/contentType';
+import {
+  NodeHTTPRequest,
+  NodeHTTPRequestHandlerOptions,
+  NodeHTTPResponse,
+} from '../types';
+
+export interface NodeHTTPContentTypeHandler<
+  TRequest extends NodeHTTPRequest,
+  TResponse extends NodeHTTPResponse,
+> extends BaseContentTypeHandler<
+    NodeHTTPRequestHandlerOptions<AnyRouter, TRequest, TResponse> & {
+      query: URLSearchParams;
+    }
+  > {}
+
+export function createNodeHTTPContentTypeHandler(
+  contentTypeHandler: NodeHTTPContentTypeHandler<
+    NodeHTTPRequest,
+    NodeHTTPResponse
+  >,
+) {
+  return <
+    TRequest extends NodeHTTPRequest,
+    TResponse extends NodeHTTPResponse,
+  >(): NodeHTTPContentTypeHandler<TRequest, TResponse> =>
+    contentTypeHandler as any;
+}

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

@@ -3,52 +3,59 @@ import { AnyRouter } from '../../core';
 import { inferRouterContext } from '../../core/types';
 import { HTTPRequest } from '../../http';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
-import { getPostBody } from './internals/getPostBody';
+import { nodeHTTPJSONContentTypeHandler } from './content-type/json';
+import { NodeHTTPContentTypeHandler } from './internals/contentType';
 import {
-  NodeHTTPHandlerOptions,
   NodeHTTPRequest,
+  NodeHTTPRequestHandlerOptions,
   NodeHTTPResponse,
 } from './types';
 
-type NodeHTTPRequestHandlerOptions<
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
-> = {
-  req: TRequest;
-  res: TResponse;
-  path: string;
-} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
+const defaultJSONContentTypeHandler = nodeHTTPJSONContentTypeHandler();
 
 export async function nodeHTTPRequestHandler<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
 >(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>) {
-  const handleViaMiddleware =
-    opts.middleware ??
-    ((_req, _res, next) => {
-      return next();
-    });
+  const handleViaMiddleware = opts.middleware ?? ((_req, _res, next) => next());
 
   return handleViaMiddleware(opts.req, opts.res, async (err) => {
-    if (err) {
-      throw err;
-    }
+    if (err) throw err;
 
-    //
-    // Build tRPC dependencies
-
-    async function createContext(): Promise<inferRouterContext<TRouter>> {
+    const createContext = async (): Promise<inferRouterContext<TRouter>> => {
       return await opts.createContext?.(opts);
-    }
-
-    const bodyResult = await getPostBody(opts);
+    };
 
     const query = opts.req.query
       ? new URLSearchParams(opts.req.query as any)
       : new URLSearchParams(opts.req.url!.split('?')[1]);
 
+    const jsonContentTypeHandler =
+      defaultJSONContentTypeHandler as unknown as NodeHTTPContentTypeHandler<
+        TRequest,
+        TResponse
+      >;
+
+    const contentTypeHandlers = opts.experimental_contentTypeHandlers ?? [
+      jsonContentTypeHandler,
+    ];
+
+    const contentTypeHandler =
+      contentTypeHandlers.find((handler) =>
+        handler.isMatch({
+          ...opts,
+          query,
+        }),
+      ) ??
+      // fallback to json
+      jsonContentTypeHandler;
+
+    const bodyResult = await contentTypeHandler.getBody({
+      ...opts,
+      query,
+    });
+
     const req: HTTPRequest = {
       method: opts.req.method!,
       headers: opts.req.headers,
@@ -56,9 +63,6 @@ export async function nodeHTTPRequestHandler<
       body: bodyResult.ok ? bodyResult.data : undefined,
     };
 
-    //
-    // Invoke tRPC
-
     const result = await resolveHTTPResponse({
       batching: opts.batching,
       responseMeta: opts.responseMeta,
@@ -74,24 +78,19 @@ export async function nodeHTTPRequestHandler<
           req: opts.req,
         });
       },
+      contentTypeHandler,
     });
 
-    //
-    // Handle result
-
     const { res } = opts;
     if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
       res.statusCode = result.status;
     }
-
     for (const [key, value] of Object.entries(result.headers ?? {})) {
       if (typeof value === 'undefined') {
         continue;
       }
-
       res.setHeader(key, value);
     }
-
     res.end(result.body);
   });
 }

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

@@ -2,6 +2,7 @@ import { IncomingMessage, ServerResponse } from 'http';
 import { AnyRouter, inferRouterContext } from '../../core';
 import { HTTPBaseHandlerOptions } from '../../http';
 import { MaybePromise } from '../../types';
+import { NodeHTTPContentTypeHandler } from './internals/contentType';
 
 interface ParsedQs {
   [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
@@ -64,8 +65,22 @@ export type NodeHTTPHandlerOptions<
    */
   middleware?: ConnectMiddleware;
   maxBodySize?: number;
+  experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<
+    TRequest,
+    TResponse
+  >[];
 } & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
 
+export type NodeHTTPRequestHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends NodeHTTPRequest,
+  TResponse extends NodeHTTPResponse,
+> = {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
+
 export type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
   req: TRequest;
   res: TResponse;

package/src/core/index.ts

@@ -18,6 +18,6 @@ export type {
 } from './procedure';
 export type { inferParser } from './parser';
 export { createInputMiddleware, createOutputMiddleware } from './middleware';
-
+export type { MiddlewareFunction, MiddlewareBuilder } from './middleware';
 export { initTRPC } from './initTRPC';
 export * from './types';

package/src/core/internals/procedureBuilder.ts

@@ -333,7 +333,12 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
 
     // run the middlewares recursively with the resolver as the last one
     const callRecursive = async (
-      callOpts: { ctx: any; index: number; input?: unknown } = {
+      callOpts: {
+        ctx: any;
+        index: number;
+        input?: unknown;
+        rawInput?: unknown;
+      } = {
         index: 0,
         ctx: opts.ctx,
       },
@@ -345,11 +350,19 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
           ctx: callOpts.ctx,
           type: opts.type,
           path: opts.path,
-          rawInput: opts.rawInput,
+          rawInput: callOpts.rawInput ?? opts.rawInput,
           meta: _def.meta,
           input: callOpts.input,
-          next: async (nextOpts?: { ctx: any; input?: any }) => {
-            return await callRecursive({
+          next(_nextOpts?: any) {
+            const nextOpts = _nextOpts as
+              | {
+                  ctx?: Record<string, unknown>;
+                  input?: unknown;
+                  rawInput?: unknown;
+                }
+              | undefined;
+
+            return callRecursive({
               index: callOpts.index + 1,
               ctx:
                 nextOpts && 'ctx' in nextOpts
@@ -359,6 +372,10 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
                 nextOpts && 'input' in nextOpts
                   ? nextOpts.input
                   : callOpts.input,
+              rawInput:
+                nextOpts && 'rawInput' in nextOpts
+                  ? nextOpts.rawInput
+                  : callOpts.rawInput,
             });
           },
         });

package/src/core/middleware.ts

@@ -148,6 +148,7 @@ export type MiddlewareFunction<
           _meta: TParams['_meta'];
         }>
       >;
+      (opts: { rawInput: unknown }): Promise<MiddlewareResult<TParams>>;
     };
   }): Promise<MiddlewareResult<TParamsAfter>>;
   _type?: string | undefined;

package/src/http/contentType.ts

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { AnyRouter } from '../core';
+import { TRPCError } from '../error/TRPCError';
+import { getCauseFromUnknown } from '../error/utils';
+import { CombinedDataTransformer } from '../transformer';
+import { MaybePromise } from '../types';
+import { HTTPRequest } from './types';
+
+type GetInputs = (opts: {
+  req: HTTPRequest;
+  isBatchCall: boolean;
+  router: AnyRouter;
+  preprocessedBody: boolean;
+}) => MaybePromise<Record<number, unknown>>;
+
+export type BodyResult =
+  | {
+      ok: true;
+      data: unknown;
+      /**
+       * If the HTTP handler has already parsed the body
+       */
+      preprocessed: boolean;
+    }
+  | { ok: false; error: TRPCError };
+
+export type BaseContentTypeHandler<TOptions> = {
+  isMatch(opts: TOptions): boolean;
+  getBody: (opts: TOptions) => MaybePromise<BodyResult>;
+  getInputs: GetInputs;
+};
+
+function getRawProcedureInputOrThrow(opts: {
+  req: HTTPRequest;
+  preprocessedBody: boolean;
+}) {
+  const { req } = opts;
+  try {
+    if (req.method === 'GET') {
+      if (!req.query.has('input')) {
+        return undefined;
+      }
+      const raw = req.query.get('input');
+      return JSON.parse(raw!);
+    }
+    if (!opts.preprocessedBody && typeof req.body === 'string') {
+      // A mutation with no inputs will have req.body === ''
+      return req.body.length === 0 ? undefined : JSON.parse(req.body);
+    }
+    return req.body;
+  } catch (err) {
+    throw new TRPCError({
+      code: 'PARSE_ERROR',
+      cause: getCauseFromUnknown(err),
+    });
+  }
+}
+
+const deserializeInputValue = (
+  rawValue: unknown,
+  transformer: CombinedDataTransformer,
+) => {
+  return typeof rawValue !== 'undefined'
+    ? transformer.input.deserialize(rawValue)
+    : rawValue;
+};
+
+export const getJsonContentTypeInputs: GetInputs = (opts) => {
+  const rawInput = getRawProcedureInputOrThrow(opts);
+  const transformer = opts.router._def._config.transformer;
+
+  if (!opts.isBatchCall) {
+    return {
+      0: 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 input: Record<number, unknown> = {};
+  for (const key in rawInput) {
+    const k = key as any as number;
+    const rawValue = rawInput[k];
+
+    const value = deserializeInputValue(rawValue, transformer);
+
+    input[k] = value;
+  }
+
+  return input;
+};

package/src/http/resolveHTTPResponse.ts

@@ -7,10 +7,13 @@ import {
   inferRouterError,
 } from '../core';
 import { TRPCError, getTRPCErrorFromUnknown } from '../error/TRPCError';
-import { getCauseFromUnknown } from '../error/utils';
 import { TRPCResponse } from '../rpc';
-import { transformTRPCResponse } from '../shared/transformTRPCResponse';
+import { transformTRPCResponse } from '../shared';
 import { Maybe } from '../types';
+import {
+  BaseContentTypeHandler,
+  getJsonContentTypeInputs,
+} from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
 import { HTTPHeaders, HTTPResponse } from './internals/types';
 import { HTTPBaseHandlerOptions, HTTPRequest } from './types';
@@ -22,31 +25,10 @@ const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
   GET: 'query',
   POST: 'mutation',
 };
-function getRawProcedureInputOrThrow(opts: {
-  req: HTTPRequest;
-  preprocessed?: boolean;
-}) {
-  const { req } = opts;
-  try {
-    if (req.method === 'GET') {
-      if (!req.query.has('input')) {
-        return undefined;
-      }
-      const raw = req.query.get('input');
-      return JSON.parse(raw!);
-    }
-    if (!opts.preprocessed && typeof req.body === 'string') {
-      // A mutation with no inputs will have req.body === ''
-      return req.body.length === 0 ? undefined : JSON.parse(req.body);
-    }
-    return req.body;
-  } catch (err) {
-    throw new TRPCError({
-      code: 'PARSE_ERROR',
-      cause: getCauseFromUnknown(err),
-    });
-  }
-}
+
+const fallbackContentTypeHandler = {
+  getInputs: getJsonContentTypeInputs,
+};
 
 interface ResolveHTTPRequestOptions<
   TRouter extends AnyRouter,
@@ -56,6 +38,7 @@ interface ResolveHTTPRequestOptions<
   req: TRequest;
   path: string;
   error?: Maybe<TRPCError>;
+  contentTypeHandler?: BaseContentTypeHandler<any>;
   preprocessedBody?: boolean;
 }
 
@@ -64,6 +47,9 @@ export async function resolveHTTPResponse<
   TRequest extends HTTPRequest,
 >(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<HTTPResponse> {
   const { router, req } = opts;
+  const contentTypeHandler =
+    opts.contentTypeHandler ?? fallbackContentTypeHandler;
+
   const batchingEnabled = opts.batching?.enabled ?? true;
   if (req.method === 'HEAD') {
     // can be used for lambda warmup
@@ -138,50 +124,17 @@ export async function resolveHTTPResponse<
         code: 'METHOD_NOT_SUPPORTED',
       });
     }
-    const rawInput = getRawProcedureInputOrThrow({
+
+    const inputs = await contentTypeHandler.getInputs({
+      isBatchCall,
       req,
-      preprocessed: opts.preprocessedBody,
+      router,
+      preprocessedBody: opts.preprocessedBody ?? false,
     });
 
     paths = isBatchCall ? opts.path.split(',') : [opts.path];
     ctx = await opts.createContext();
 
-    const deserializeInputValue = (rawValue: unknown) => {
-      return typeof rawValue !== 'undefined'
-        ? router._def._config.transformer.input.deserialize(rawValue)
-        : rawValue;
-    };
-    const getInputs = (): Record<number, unknown> => {
-      if (!isBatchCall) {
-        return {
-          0: deserializeInputValue(rawInput),
-        };
-      }
-
-      /* istanbul ignore if -- @preserve */
-      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 input: Record<number, unknown> = {};
-      for (const key in rawInput) {
-        const k = key as any as number;
-        const rawValue = rawInput[k];
-
-        const value = deserializeInputValue(rawValue);
-
-        input[k] = value;
-      }
-      return input;
-    };
-    const inputs = getInputs();
-
     const rawResults = await Promise.all(
       paths.map(async (path, index) => {
         const input = inputs[index];

package/dist/adapters/node-http/internals/getPostBody.d.ts

@@ -1,14 +0,0 @@
-import { TRPCError } from '../../../error/TRPCError';
-import { NodeHTTPRequest } from '../types';
-export declare function getPostBody(opts: {
-    req: NodeHTTPRequest;
-    maxBodySize?: number;
-}): Promise<{
-    ok: true;
-    data: unknown;
-    preprocessed: boolean;
-} | {
-    ok: false;
-    error: TRPCError;
-}>;
-//# sourceMappingURL=getPostBody.d.ts.map

package/dist/adapters/node-http/internals/getPostBody.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getPostBody.d.ts","sourceRoot":"","sources":["../../../../src/adapters/node-http/internals/getPostBody.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACtC,GAAG,EAAE,eAAe,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;QAGW,IAAI;UAAQ,OAAO;kBAAgB,OAAO;;QAC1C,KAAK;WAAS,SAAS;GA2BlC"}