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

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

@@ -9,12 +9,7 @@
  */
 import type * as http from 'http';
 // @trpc/server
-import type {
-  AnyRouter,
-  CreateContextCallback,
-  inferRouterContext,
-  WrapCreateContext,
-} from '../../@trpc/server';
+import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
 // @trpc/server/http
 import type {
   HTTPBaseHandlerOptions,
@@ -22,6 +17,7 @@ import type {
 } from '../../@trpc/server/http';
 // eslint-disable-next-line no-restricted-imports
 import type { MaybePromise } from '../../unstable-core-do-not-import';
+import type { NodeHTTPContentTypeHandler } from './internals/contentType';
 
 interface ParsedQs {
   [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
@@ -43,14 +39,23 @@ export type NodeHTTPResponse = http.ServerResponse & {
   flush?: () => void;
 };
 
-export type NodeHTTPConditionCreateContextOption<
+export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,
   TRequest,
   TResponse,
-> = CreateContextCallback<
-  inferRouterContext<TRouter>,
-  NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>
->;
+> = object extends inferRouterContext<TRouter>
+  ? {
+      /**
+       * @link https://trpc.io/docs/v11/context
+       **/
+      createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+    }
+  : {
+      /**
+       * @link https://trpc.io/docs/v11/context
+       **/
+      createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
+    };
 
 /**
  * @internal
@@ -60,50 +65,45 @@ type ConnectMiddleware<
   TResponse extends NodeHTTPResponse = NodeHTTPResponse,
 > = (req: TRequest, res: TResponse, next: (err?: any) => any) => void;
 
-interface CoreNodeHTTPHandlerOptions<
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
-> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-  /**
-   * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
-   *
-   * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
-   *
-   * ```ts
-   * import cors from 'cors'
-   *
-   * nodeHTTPRequestHandler({
-   *   cors: cors()
-   * })
-   * ```
-   *
-   * You can also use it for other needs which a connect/node.js compatible middleware can solve,
-   *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
-   */
-  middleware?: ConnectMiddleware<TRequest, TResponse>;
-  maxBodySize?: number;
-}
-
-// Public API
 export type NodeHTTPHandlerOptions<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
-> = CoreNodeHTTPHandlerOptions<TRouter, TRequest, TResponse> &
-  NodeHTTPConditionCreateContextOption<TRouter, TRequest, TResponse>;
+> = HTTPBaseHandlerOptions<TRouter, TRequest> &
+  NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
+    /**
+     * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
+     *
+     * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
+     *
+     * ```ts
+     * import cors from 'cors'
+     *
+     * nodeHTTPRequestHandler({
+     *   cors: cors()
+     * })
+     * ```
+     *
+     * You can also use it for other needs which a connect/node.js compatible middleware can solve,
+     *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
+     */
+    middleware?: ConnectMiddleware;
+    maxBodySize?: number;
+    experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<
+      TRequest,
+      TResponse
+    >[];
+  };
 
-// Internal user
 export type NodeHTTPRequestHandlerOptions<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
-> = CoreNodeHTTPHandlerOptions<TRouter, TRequest, TResponse> &
-  WrapCreateContext<NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>> & {
-    req: TRequest;
-    res: TResponse;
-    path: string;
-  };
+> = {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
 
 export type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
   req: TRequest;

package/src/adapters/standalone.ts

@@ -37,7 +37,8 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
     const path = url.pathname.slice(1);
 
     await nodeHTTPRequestHandler({
-      ...opts,
+      // FIXME: no typecasting should be needed here
+      ...(opts as CreateHTTPHandlerOptions<AnyRouter>),
       req,
       res,
       path,

package/src/adapters/ws.ts

@@ -1,10 +1,6 @@
 import type { IncomingMessage } from 'http';
 import type ws from 'ws';
-import type {
-  AnyRouter,
-  CreateContextCallback,
-  inferRouterContext,
-} from '../@trpc/server';
+import type { AnyRouter, inferRouterContext } from '../@trpc/server';
 import {
   callProcedure,
   getErrorShape,
@@ -50,10 +46,19 @@ export type CreateWSSContextFn<TRouter extends AnyRouter> = (
 
 export type WSConnectionHandlerOptions<TRouter extends AnyRouter> =
   BaseHandlerOptions<TRouter, IncomingMessage> &
-    CreateContextCallback<
-      inferRouterContext<TRouter>,
-      CreateWSSContextFn<TRouter>
-    >;
+    (object extends inferRouterContext<TRouter>
+      ? {
+          /**
+           * @link https://trpc.io/docs/v11/context
+           **/
+          createContext?: CreateWSSContextFn<TRouter>;
+        }
+      : {
+          /**
+           * @link https://trpc.io/docs/v11/context
+           **/
+          createContext: CreateWSSContextFn<TRouter>;
+        });
 
 /**
  * Web socket server handler

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

@@ -1,4 +1,16 @@
-import type { TRPCError } from '../error/TRPCError';
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { TRPCError } from '../error/TRPCError';
+import type { AnyRouter } from '../router';
+import type { CombinedDataTransformer } from '../transformer';
+import type { MaybePromise } from '../types';
+import type { HTTPRequest } from './types';
+
+type GetInputs = (opts: {
+  req: HTTPRequest;
+  isBatchCall: boolean;
+  router: AnyRouter;
+  preprocessedBody: boolean;
+}) => MaybePromise<Record<number, unknown>>;
 
 export type BodyResult =
   | {
@@ -12,13 +24,76 @@ export type BodyResult =
   | { ok: false; error: TRPCError };
 
 export type BaseContentTypeHandler<TOptions> = {
-  name: string;
-  isMatch(headers: Headers): boolean;
-  getInputs: (
-    opts: TOptions,
-    info: {
-      isBatchCall: boolean;
-      batch: number;
-    },
-  ) => Promise<unknown>;
+  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 (cause) {
+    throw new TRPCError({
+      code: 'PARSE_ERROR',
+      cause,
+    });
+  }
+}
+
+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/unstable-core-do-not-import/http/index.ts

@@ -24,5 +24,6 @@ export type {
 
 export { getBatchStreamFormatter } from './batchStreamFormatter';
 export type { BaseContentTypeHandler, BodyResult } from './contentType';
+export { getJsonContentTypeInputs } from './contentType';
 
 export { toURL } from './toURL';

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

@@ -9,6 +9,9 @@ import type {
 import { callProcedure } from '../router';
 import type { TRPCResponse } from '../rpc';
 import { transformTRPCResponse } from '../transformer';
+import type { Maybe } from '../types';
+import type { BaseContentTypeHandler } from './contentType';
+import { getJsonContentTypeInputs } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
 import type {
   HTTPBaseHandlerOptions,
@@ -28,6 +31,10 @@ const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
   POST: 'mutation',
 };
 
+const fallbackContentTypeHandler = {
+  getInputs: getJsonContentTypeInputs,
+};
+
 type PartialBy<TBaseType, TKey extends keyof TBaseType> = Omit<
   TBaseType,
   TKey
@@ -41,8 +48,9 @@ interface ResolveHTTPRequestOptions<
   createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
   req: TRequest;
   path: string;
-  getInput: (opts: { isBatchCall: boolean; batch: number }) => Promise<unknown>;
-  error?: TRPCError;
+  error?: Maybe<TRPCError>;
+  contentTypeHandler?: BaseContentTypeHandler<any>;
+  preprocessedBody?: boolean;
   /**
    * Called as soon as the response head is known.
    * When streaming, headers will have been generated
@@ -223,6 +231,8 @@ export async function resolveHTTPResponse<
     unstable_onChunk?.([-1, '']);
     return headResponse;
   }
+  const contentTypeHandler =
+    opts.contentTypeHandler ?? fallbackContentTypeHandler;
   const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
   const allowMethodOverride = opts.allowMethodOverride ?? false;
 
@@ -239,6 +249,9 @@ export async function resolveHTTPResponse<
     req.headers['trpc-batch-mode'] === 'stream';
 
   try {
+    if (opts.error) {
+      throw opts.error;
+    }
     if (isBatchCall && !allowBatching) {
       throw new TRPCError({
         code: 'BAD_REQUEST',
@@ -259,26 +272,22 @@ export async function resolveHTTPResponse<
       });
     }
 
-    const batchesCache: Record<number, unknown> = {};
-    async function getRawInputForBatch(batch: number) {
-      if (!batchesCache.hasOwnProperty(batch)) {
-        batchesCache[batch] = await opts.getInput({
-          isBatchCall,
-          batch,
-        });
-      }
-
-      return batchesCache[batch];
-    }
+    const inputs = await contentTypeHandler.getInputs({
+      isBatchCall,
+      req,
+      router,
+      preprocessedBody: opts.preprocessedBody ?? false,
+    });
 
     paths = isBatchCall
       ? decodeURIComponent(opts.path).split(',')
       : [opts.path];
     const info: TRPCRequestInfo = {
       isBatchCall,
-      calls: paths.map((path) => ({
+      calls: paths.map((path, idx) => ({
         path,
         type,
+        input: inputs[idx] ?? undefined,
       })),
     };
     ctx = await opts.createContext({ info });
@@ -288,22 +297,12 @@ export async function resolveHTTPResponse<
     const promises: Promise<
       TRPCResponse<unknown, inferRouterError<TRouter>>
     >[] = paths.map(async (path, index) => {
-      async function getRawInput() {
-        return await getRawInputForBatch(index);
-      }
-
+      const input = inputs[index];
       try {
-        if (opts.error) {
-          // sometimes an error may be generated above this function in the stack
-          // for instance a 405 error if the method is not supported
-          // But we need to handle it here to ensure the error is formatted correctly
-          throw opts.error;
-        }
-
         const data = await callProcedure({
           procedures: opts.router._def.procedures,
           path,
-          getRawInput: getRawInput,
+          getRawInput: async () => input,
           ctx,
           type,
           allowMethodOverride,
@@ -320,7 +319,7 @@ export async function resolveHTTPResponse<
         opts.onError?.({
           error,
           path,
-          input: getRawInput(),
+          input,
           ctx,
           type: type,
           req: opts.req,
@@ -332,7 +331,7 @@ export async function resolveHTTPResponse<
             error,
             type,
             path,
-            input: getRawInput(),
+            input,
             ctx,
           }),
         };
@@ -411,7 +410,7 @@ export async function resolveHTTPResponse<
         unstable_onChunk([index, body]);
       } catch (cause) {
         const path = paths[index];
-        const input = await getRawInputForBatch(index);
+        const input = inputs[index];
         const { body } = caughtErrorToData(cause, {
           opts,
           ctx,

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

@@ -47,6 +47,7 @@ export interface HTTPRequest {
   method: string;
   query: URLSearchParams;
   headers: HTTPHeaders;
+  body: unknown;
 }
 
 /**
@@ -65,6 +66,7 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
 /** @internal */
 export type ProcedureCall = {
   type: ProcedureType;
+  input?: unknown;
   path: string;
 };
 

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

@@ -149,3 +149,4 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
  * @link https://trpc.io/docs/v11/quickstart
  */
 export const initTRPC = new TRPCBuilder();
+export type { TRPCBuilder };

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

@@ -76,34 +76,3 @@ export type AnyRootTypes = CreateRootTypes<{
   errorShape: any;
   transformer: any;
 }>;
-
-type PartialIf<TCondition extends boolean, TType> = TCondition extends true
-  ? Partial<TType>
-  : TType;
-
-/**
- * Adds a `createContext` option with a given callback function
- * If context is the default value, then the `createContext` option is optional
- */
-export type CreateContextCallback<
-  TContext,
-  TFunction extends (...args: any[]) => any,
-> = PartialIf<
-  object extends TContext ? true : false,
-  {
-    /**
-     * @link https://trpc.io/docs/v11/context
-     **/
-    createContext: TFunction;
-  }
->;
-
-/**
- * @internal
- */
-export type WrapCreateContext<TFunction extends (...args: any[]) => any> = {
-  /**
-   * @link https://trpc.io/docs/v11/context
-   **/
-  createContext?: TFunction;
-};

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

@@ -1,10 +0,0 @@
-import type { AnyRouter } from '../../../../@trpc/server';
-import type { BaseContentTypeHandler, HTTPRequest } from '../../../../@trpc/server/http';
-import { 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 declare const getLambdaHTTPJSONContentTypeHandler: <TRouter extends AnyRouter, TEvent extends APIGatewayEvent>() => LambdaHTTPContentTypeHandler<TRouter, TEvent>;
-//# sourceMappingURL=index.d.ts.map

package/dist/adapters/aws-lambda/content-type/json/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/adapters/aws-lambda/content-type/json/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EAEV,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,sBAAsB,EACtB,WAAW,EACZ,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,4BAA4B,CAC3C,OAAO,SAAS,SAAS,EACzB,MAAM,SAAS,eAAe,CAC9B,SAAQ,sBAAsB,CAC5B,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,WAAW,CAAC;CAClB,CACF;CAAG;AAEN,eAAO,MAAM,mCAAmC,EAAE,CAChD,OAAO,SAAS,SAAS,EACzB,MAAM,SAAS,eAAe,OACzB,4BAA4B,CAAC,OAAO,EAAE,MAAM,CAqEjD,CAAC"}

package/dist/adapters/aws-lambda/content-type/json/index.js

@@ -1,59 +0,0 @@
-'use strict';
-
-var TRPCError = require('../../../../unstable-core-do-not-import/error/TRPCError.js');
-require('../../../../unstable-core-do-not-import/rootConfig.js');
-var utils = require('../../utils.js');
-
-// @trpc/server
-const getLambdaHTTPJSONContentTypeHandler = ()=>({
-        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.method === 'GET') {
-                        const input = req.query.get('input');
-                        if (!input) {
-                            return undefined;
-                        }
-                        return JSON.parse(input);
-                    }
-                    const body = utils.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.TRPCError({
-                        code: 'PARSE_ERROR',
-                        cause
-                    });
-                }
-            }
-            const deserializeInputValue = (rawValue, transformer)=>{
-                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.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);
-        }
-    });
-
-exports.getLambdaHTTPJSONContentTypeHandler = getLambdaHTTPJSONContentTypeHandler;

package/dist/adapters/aws-lambda/content-type/json/index.mjs

@@ -1,57 +0,0 @@
-import { TRPCError } from '../../../../unstable-core-do-not-import/error/TRPCError.mjs';
-import '../../../../unstable-core-do-not-import/rootConfig.mjs';
-import { lambdaEventToHTTPBody } from '../../utils.mjs';
-
-// @trpc/server
-const getLambdaHTTPJSONContentTypeHandler = ()=>({
-        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.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, transformer)=>{
-                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);
-        }
-    });
-
-export { getLambdaHTTPJSONContentTypeHandler };

package/dist/adapters/content-handlers/selectContentHandlerOrUnsupportedMediaType.d.ts

@@ -1,10 +0,0 @@
-import { TRPCError } from '../../@trpc/server';
-import type { BaseContentTypeHandler, HTTPHeaders } from '../../@trpc/server/http';
-interface MinimalHandlerOpts {
-    req: {
-        headers: HTTPHeaders | Headers;
-    };
-}
-export declare function selectContentHandlerOrUnsupportedMediaType<THandlerOpts extends MinimalHandlerOpts, THandler extends BaseContentTypeHandler<THandlerOpts>>(handlers: THandler[], opts: THandlerOpts): readonly [undefined, TRPCError] | readonly [THandler];
-export {};
-//# sourceMappingURL=selectContentHandlerOrUnsupportedMediaType.d.ts.map

package/dist/adapters/content-handlers/selectContentHandlerOrUnsupportedMediaType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectContentHandlerOrUnsupportedMediaType.d.ts","sourceRoot":"","sources":["../../../src/adapters/content-handlers/selectContentHandlerOrUnsupportedMediaType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EACV,sBAAsB,EACtB,WAAW,EACZ,MAAM,yBAAyB,CAAC;AAEjC,UAAU,kBAAkB;IAC1B,GAAG,EAAE;QAGH,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC;KAChC,CAAC;CACH;AAED,wBAAgB,0CAA0C,CACxD,YAAY,SAAS,kBAAkB,EACvC,QAAQ,SAAS,sBAAsB,CAAC,YAAY,CAAC,EACrD,QAAQ,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,YAAY,yDA2BzC"}

package/dist/adapters/content-handlers/selectContentHandlerOrUnsupportedMediaType.js

@@ -1,33 +0,0 @@
-'use strict';
-
-var TRPCError = require('../../unstable-core-do-not-import/error/TRPCError.js');
-require('../../unstable-core-do-not-import/rootConfig.js');
-
-function selectContentHandlerOrUnsupportedMediaType(handlers, opts) {
-    const headers = new Headers(opts.req.headers);
-    const contentType = headers.get('content-type');
-    if (contentType === null) {
-        return [
-            undefined,
-            new TRPCError.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'
-            })
-        ];
-    }
-    const handler = handlers.find((handler)=>handler.isMatch(headers));
-    if (!handler) {
-        return [
-            undefined,
-            new TRPCError.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`
-            })
-        ];
-    }
-    return [
-        handler
-    ];
-}
-
-exports.selectContentHandlerOrUnsupportedMediaType = selectContentHandlerOrUnsupportedMediaType;