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

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

@@ -1,12 +1,14 @@
 'use strict';
 
 var createProxy = require('./unstable-core-do-not-import/createProxy.js');
+var TRPCError = require('./unstable-core-do-not-import/error/TRPCError.js');
 var formatter = require('./unstable-core-do-not-import/error/formatter.js');
 var getErrorShape = require('./unstable-core-do-not-import/error/getErrorShape.js');
-var TRPCError = require('./unstable-core-do-not-import/error/TRPCError.js');
-var getHTTPStatusCode = require('./unstable-core-do-not-import/http/getHTTPStatusCode.js');
-var resolveHTTPResponse = require('./unstable-core-do-not-import/http/resolveHTTPResponse.js');
 var batchStreamFormatter = require('./unstable-core-do-not-import/http/batchStreamFormatter.js');
+var contentType = require('./unstable-core-do-not-import/http/contentType.js');
+var contentTypeParsers = require('./unstable-core-do-not-import/http/contentTypeParsers.js');
+var getHTTPStatusCode = require('./unstable-core-do-not-import/http/getHTTPStatusCode.js');
+var resolveResponse = require('./unstable-core-do-not-import/http/resolveResponse.js');
 var toURL = require('./unstable-core-do-not-import/http/toURL.js');
 var initTRPC = require('./unstable-core-do-not-import/initTRPC.js');
 var middleware = require('./unstable-core-do-not-import/middleware.js');
@@ -25,15 +27,17 @@ var utils = require('./unstable-core-do-not-import/utils.js');
 
 exports.createFlatProxy = createProxy.createFlatProxy;
 exports.createRecursiveProxy = createProxy.createRecursiveProxy;
-exports.defaultFormatter = formatter.defaultFormatter;
-exports.getErrorShape = getErrorShape.getErrorShape;
 exports.TRPCError = TRPCError.TRPCError;
 exports.getCauseFromUnknown = TRPCError.getCauseFromUnknown;
 exports.getTRPCErrorFromUnknown = TRPCError.getTRPCErrorFromUnknown;
+exports.defaultFormatter = formatter.defaultFormatter;
+exports.getErrorShape = getErrorShape.getErrorShape;
+exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
+exports.getRequestInfo = contentType.getRequestInfo;
+exports.octetInputParser = contentTypeParsers.octetInputParser;
 exports.getHTTPStatusCode = getHTTPStatusCode.getHTTPStatusCode;
 exports.getHTTPStatusCodeFromError = getHTTPStatusCode.getHTTPStatusCodeFromError;
-exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
-exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
+exports.resolveResponse = resolveResponse.resolveResponse;
 exports.toURL = toURL.toURL;
 exports.initTRPC = initTRPC.initTRPC;
 exports.createInputMiddleware = middleware.createInputMiddleware;
@@ -44,7 +48,6 @@ exports.middlewareMarker = middleware.middlewareMarker;
 exports.getParseFn = parser.getParseFn;
 exports.procedureTypes = procedure.procedureTypes;
 exports.createBuilder = procedureBuilder.createBuilder;
-exports.unsetMarker = procedureBuilder.unsetMarker;
 exports.isServerDefault = rootConfig.isServerDefault;
 exports.callProcedure = router.callProcedure;
 exports.createCallerFactory = router.createCallerFactory;
@@ -62,3 +65,4 @@ exports.isFunction = utils.isFunction;
 exports.isObject = utils.isObject;
 exports.mergeWithoutOverrides = utils.mergeWithoutOverrides;
 exports.omitPrototype = utils.omitPrototype;
+exports.unsetMarker = utils.unsetMarker;

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

@@ -1,20 +1,22 @@
 export { createFlatProxy, createRecursiveProxy } from './unstable-core-do-not-import/createProxy.mjs';
+export { TRPCError, getCauseFromUnknown, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
 export { defaultFormatter } from './unstable-core-do-not-import/error/formatter.mjs';
 export { getErrorShape } from './unstable-core-do-not-import/error/getErrorShape.mjs';
-export { TRPCError, getCauseFromUnknown, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
-export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
-export { resolveHTTPResponse } from './unstable-core-do-not-import/http/resolveHTTPResponse.mjs';
 export { getBatchStreamFormatter } from './unstable-core-do-not-import/http/batchStreamFormatter.mjs';
+export { getRequestInfo } from './unstable-core-do-not-import/http/contentType.mjs';
+export { octetInputParser } from './unstable-core-do-not-import/http/contentTypeParsers.mjs';
+export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
+export { resolveResponse } from './unstable-core-do-not-import/http/resolveResponse.mjs';
 export { toURL } from './unstable-core-do-not-import/http/toURL.mjs';
 export { initTRPC } from './unstable-core-do-not-import/initTRPC.mjs';
 export { createInputMiddleware, createMiddlewareFactory, createOutputMiddleware, experimental_standaloneMiddleware, middlewareMarker } from './unstable-core-do-not-import/middleware.mjs';
 export { getParseFn } from './unstable-core-do-not-import/parser.mjs';
 export { procedureTypes } from './unstable-core-do-not-import/procedure.mjs';
-export { createBuilder, unsetMarker } from './unstable-core-do-not-import/procedureBuilder.mjs';
+export { createBuilder } from './unstable-core-do-not-import/procedureBuilder.mjs';
 export { isServerDefault } from './unstable-core-do-not-import/rootConfig.mjs';
 export { callProcedure, createCallerFactory, createRouterFactory, mergeRouters } from './unstable-core-do-not-import/router.mjs';
 export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER } from './unstable-core-do-not-import/rpc/codes.mjs';
 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 { isFunction, isObject, mergeWithoutOverrides, omitPrototype } from './unstable-core-do-not-import/utils.mjs';
+export { isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker } from './unstable-core-do-not-import/utils.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.361+5ad570aa5",
+  "version": "11.0.0-rc.363+64448a773",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -58,16 +58,6 @@
       "require": "./dist/adapters/next.js",
       "default": "./dist/adapters/next.js"
     },
-    "./adapters/node-http/content-type/form-data": {
-      "import": "./dist/adapters/node-http/content-type/form-data/index.mjs",
-      "require": "./dist/adapters/node-http/content-type/form-data/index.js",
-      "default": "./dist/adapters/node-http/content-type/form-data/index.js"
-    },
-    "./adapters/node-http/content-type/json": {
-      "import": "./dist/adapters/node-http/content-type/json/index.mjs",
-      "require": "./dist/adapters/node-http/content-type/json/index.js",
-      "default": "./dist/adapters/node-http/content-type/json/index.js"
-    },
     "./adapters/node-http": {
       "import": "./dist/adapters/node-http/index.mjs",
       "require": "./dist/adapters/node-http/index.js",
@@ -128,7 +118,7 @@
   "devDependencies": {
     "@fastify/websocket": "^10.0.1",
     "@tanstack/react-query": "^5.25.0",
-    "@types/aws-lambda": "^8.10.97",
+    "@types/aws-lambda": "^8.10.137",
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
     "@types/node": "^20.10.0",
@@ -159,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "5ad570aa5e1d8951e31900d4c2ee8c1766235e6d"
+  "gitHead": "64448a7739caa0ea7464336316de0c11366161ea"
 }

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

@@ -1,26 +1,21 @@
 export {
   getHTTPStatusCode,
   getHTTPStatusCodeFromError,
+  resolveResponse,
 } from '../../unstable-core-do-not-import';
-export { resolveHTTPResponse } from '../../unstable-core-do-not-import';
 export type {
   BaseHandlerOptions,
   HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  OnErrorFunction,
-  ProcedureCall,
+  HTTPErrorHandler,
+  /**
+   * @deprecated Use `HTTPErrorHandler` instead
+   */
+  HTTPErrorHandler as OnErrorFunction,
   ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
   ResponseMeta,
   ResponseMetaFn,
   TRPCRequestInfo,
 } from '../../unstable-core-do-not-import';
 
 export { getBatchStreamFormatter } from '../../unstable-core-do-not-import';
-export type {
-  BaseContentTypeHandler,
-  BodyResult,
-} from '../../unstable-core-do-not-import';
-export { toURL } from '../../unstable-core-do-not-import';
+export { octetInputParser, toURL } from '../../unstable-core-do-not-import';

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

@@ -33,7 +33,6 @@ export {
   type AnySubscriptionProcedure as AnyTRPCSubscriptionProcedure,
   type ProcedureOptions as TRPCProcedureOptions,
   type CreateContextCallback,
-  type WrapCreateContext,
   type MutationProcedure as TRPCMutationProcedure,
   type QueryProcedure as TRPCQueryProcedure,
   type SubscriptionProcedure as TRPCSubscriptionProcedure,
@@ -104,5 +103,3 @@ export {
  */
 export type inferAsyncReturnType<TFunction extends (...args: any[]) => any> =
   Awaited<ReturnType<TFunction>>;
-
-export { parseOctetInput } from '../../unstable-core-do-not-import/contentTypeParsers';

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

@@ -0,0 +1,191 @@
+import type {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  APIGatewayProxyResult,
+  APIGatewayProxyStructuredResultV2,
+} from 'aws-lambda';
+
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+
+export type APIGatewayResult =
+  | APIGatewayProxyResult
+  | APIGatewayProxyStructuredResultV2;
+
+function determinePayloadFormat(event: LambdaEvent): string {
+  // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+  // According to AWS support, version is is extracted from the version property in the event.
+  // If there is no version property, then the version is implied as 1.0
+  const unknownEvent = event as { version?: string };
+  if (typeof unknownEvent.version === 'undefined') {
+    return '1.0';
+  } else {
+    return unknownEvent.version;
+  }
+}
+
+/** 1:1 mapping of v1 or v2 input events, deduces which is which.
+ * @internal
+ **/
+export type inferAPIGWReturn<TEvent> = TEvent extends APIGatewayProxyEvent
+  ? APIGatewayProxyResult
+  : TEvent extends APIGatewayProxyEventV2
+  ? APIGatewayProxyStructuredResultV2
+  : never;
+
+interface Processor<TEvent extends LambdaEvent> {
+  getTRPCPath: (event: TEvent) => string;
+  url(event: TEvent): Pick<URL, 'hostname' | 'pathname' | 'search'>;
+  getHeaders: (event: TEvent) => Headers;
+  getMethod: (event: TEvent) => string;
+  toResult: (response: Response) => Promise<inferAPIGWReturn<TEvent>>;
+}
+
+const v1Processor: Processor<APIGatewayProxyEvent> = {
+  // same as getPath above
+  getTRPCPath: (event) => {
+    if (!event.pathParameters) {
+      // Then this event was not triggered by a resource denoted with {proxy+}
+      return event.path.split('/').pop() ?? '';
+    }
+    const matches = event.resource.matchAll(/\{(.*?)\}/g);
+    for (const match of matches) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const group = match[1]!;
+      if (group.includes('+') && event.pathParameters) {
+        return event.pathParameters[group.replace('+', '')] ?? '';
+      }
+    }
+    return event.path.slice(1);
+  },
+  url(event) {
+    const hostname: string =
+      event.requestContext.domainName ??
+      event.headers['host'] ??
+      event.multiValueHeaders?.['host']?.[0] ??
+      'localhost';
+
+    const searchParams = new URLSearchParams();
+
+    for (const [key, value] of Object.entries(
+      event.queryStringParameters ?? {},
+    )) {
+      if (value !== undefined) {
+        searchParams.append(key, value);
+      }
+    }
+    const qs = searchParams.toString();
+    return {
+      hostname,
+      pathname: event.path,
+      search: qs && `?${qs}`,
+    };
+  },
+  getHeaders: (event) => {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(event.headers ?? {})) {
+      if (value !== undefined) {
+        headers.append(key, value);
+      }
+    }
+
+    for (const [k, values] of Object.entries(event.multiValueHeaders ?? {})) {
+      if (values) {
+        values.forEach((v) => headers.append(k, v));
+      }
+    }
+
+    return headers;
+  },
+  getMethod: (event) => event.httpMethod,
+  toResult: async (response) => {
+    const result: APIGatewayProxyResult = {
+      statusCode: response.status,
+      body: await response.text(),
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+
+    return result;
+  },
+};
+
+const v2Processor: Processor<APIGatewayProxyEventV2> = {
+  getTRPCPath: (event) => {
+    const matches = event.routeKey.matchAll(/\{(.*?)\}/g);
+    for (const match of matches) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const group = match[1]!;
+      if (group.includes('+') && event.pathParameters) {
+        return event.pathParameters[group.replace('+', '')] ?? '';
+      }
+    }
+    return event.rawPath.slice(1);
+  },
+  url(event) {
+    return {
+      hostname: event.requestContext.domainName,
+      pathname: event.rawPath,
+      search: event.rawQueryString && `?${event.rawQueryString}`,
+    };
+  },
+  getHeaders: (event) => {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(event.headers ?? {})) {
+      if (value !== undefined) {
+        headers.append(key, value);
+      }
+    }
+
+    if (event.cookies) {
+      headers.append('cookie', event.cookies.join('; '));
+    }
+    return headers;
+  },
+  getMethod: (event) => event.requestContext.http.method,
+  toResult: async (response) => {
+    const result: APIGatewayProxyStructuredResultV2 = {
+      statusCode: response.status,
+      body: await response.text(),
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+
+    return result;
+  },
+};
+
+export function getPlanner<TEvent extends LambdaEvent>(event: TEvent) {
+  const version = determinePayloadFormat(event);
+  let processor: Processor<TEvent>;
+  switch (version) {
+    case '1.0':
+      processor = v1Processor as Processor<TEvent>;
+      break;
+    case '2.0':
+      processor = v2Processor as Processor<TEvent>;
+      break;
+    default:
+      throw new Error(`Unsupported version: ${version}`);
+  }
+
+  const urlParts = processor.url(event);
+  const url = `https://${urlParts.hostname}${urlParts.pathname}${urlParts.search}`;
+
+  const init: RequestInit = {
+    headers: processor.getHeaders(event),
+    method: processor.getMethod(event),
+    // @ts-expect-error this is fine
+    duplex: 'half',
+  };
+  if (event.body) {
+    init.body = event.isBase64Encoded
+      ? Buffer.from(event.body, 'base64')
+      : event.body;
+  }
+
+  const request = new Request(url, init);
+
+  return {
+    path: processor.getTRPCPath(event),
+    request,
+    toResult: processor.toResult,
+  };
+}

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

@@ -7,102 +7,58 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type {
-  APIGatewayProxyEvent,
-  APIGatewayProxyEventV2,
-  APIGatewayProxyResult,
-  APIGatewayProxyStructuredResultV2,
-  Context as APIGWContext,
-} from 'aws-lambda';
+import type { Context as APIGWContext } from 'aws-lambda';
 // @trpc/server
-import type { AnyRouter } from '../../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../../@trpc/server';
 // @trpc/server
-import { TRPCError } from '../../@trpc/server';
 import type {
-  HTTPRequest,
-  HTTPResponse,
+  HTTPBaseHandlerOptions,
   ResolveHTTPRequestOptionsContextFn,
+  TRPCRequestInfo,
 } 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,
-  AWSLambdaOptions,
-} from './utils';
-import {
-  getHTTPMethod,
-  getPath,
-  isPayloadV1,
-  isPayloadV2,
-  transformHeaders,
-  UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
-} from './utils';
-
-export * from './utils';
+import { resolveResponse } from '../../@trpc/server/http';
+import type { inferAPIGWReturn, LambdaEvent } from './getPlanner';
+import { getPlanner } from './getPlanner';
 
-function lambdaEventToHTTPRequest(event: APIGatewayEvent): HTTPRequest {
-  const query = new URLSearchParams();
-  for (const [key, value] of Object.entries(
-    event.queryStringParameters ?? {},
-  )) {
-    if (typeof value !== 'undefined') {
-      query.append(key, value);
-    }
-  }
+export type CreateAWSLambdaContextOptions<TEvent extends LambdaEvent> = {
+  event: TEvent;
+  context: APIGWContext;
+  info: TRPCRequestInfo;
+};
 
-  return {
-    method: getHTTPMethod(event),
-    query: query,
-    headers: event.headers,
-  };
-}
+export type AWSLambdaOptions<
+  TRouter extends AnyRouter,
+  TEvent extends LambdaEvent,
+> =
+  | HTTPBaseHandlerOptions<TRouter, TEvent> &
+      CreateContextCallback<
+        inferRouterContext<AnyRouter>,
+        AWSLambdaCreateContextFn<TRouter, TEvent>
+      >;
 
-function tRPCOutputToAPIGatewayOutput<
-  TEvent extends APIGatewayEvent,
-  TResult extends APIGatewayResult,
->(event: TEvent, response: HTTPResponse): TResult {
-  if (isPayloadV1(event)) {
-    const resp: APIGatewayProxyResult = {
-      statusCode: response.status,
-      body: response.body ?? '',
-      headers: transformHeaders(response.headers ?? {}),
-    };
-    return resp as TResult;
-  } else if (isPayloadV2(event)) {
-    const resp: APIGatewayProxyStructuredResultV2 = {
-      statusCode: response.status,
-      body: response.body ?? undefined,
-      headers: transformHeaders(response.headers ?? {}),
-    };
-    return resp as TResult;
-  } else {
-    throw new TRPCError({
-      code: 'INTERNAL_SERVER_ERROR',
-      message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
-    });
-  }
-}
+export type AWSLambdaCreateContextFn<
+  TRouter extends AnyRouter,
+  TEvent extends LambdaEvent,
+> = ({
+  event,
+  context,
+  info,
+}: CreateAWSLambdaContextOptions<TEvent>) =>
+  | inferRouterContext<TRouter>
+  | Promise<inferRouterContext<TRouter>>;
 
-/** 1:1 mapping of v1 or v2 input events, deduces which is which.
- * @internal
- **/
-type inferAPIGWReturn<TType> = TType extends APIGatewayProxyEvent
-  ? APIGatewayProxyResult
-  : TType extends APIGatewayProxyEventV2
-  ? APIGatewayProxyStructuredResultV2
-  : never;
 export function awsLambdaRequestHandler<
   TRouter extends AnyRouter,
-  TEvent extends APIGatewayEvent,
-  TResult extends inferAPIGWReturn<TEvent>,
+  TEvent extends LambdaEvent,
 >(
   opts: AWSLambdaOptions<TRouter, TEvent>,
-): (event: TEvent, context: APIGWContext) => Promise<TResult> {
+): (event: TEvent, context: APIGWContext) => Promise<inferAPIGWReturn<TEvent>> {
   return async (event, context) => {
-    const req = lambdaEventToHTTPRequest(event);
-    const path = getPath(event);
+    const planner = getPlanner(event);
 
     const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
       innerOpts,
@@ -110,32 +66,12 @@ export function awsLambdaRequestHandler<
       return await opts.createContext?.({ event, context, ...innerOpts });
     };
 
-    const [contentTypeHandler, unsupportedMediaTypeError] =
-      selectContentHandlerOrUnsupportedMediaType(
-        [getLambdaHTTPJSONContentTypeHandler<TRouter, TEvent>()],
-        {
-          ...opts,
-          event,
-          req,
-        },
-      );
-
-    const response = await resolveHTTPResponse({
+    const response = await resolveResponse({
       ...opts,
       createContext,
-      req,
-      path,
-      error: unsupportedMediaTypeError,
-      async getInput(info) {
-        return await contentTypeHandler?.getInputs(
-          {
-            ...opts,
-            event,
-            req,
-          },
-          info,
-        );
-      },
+      req: planner.request,
+      path: planner.path,
+      error: null,
       onError(o) {
         opts?.onError?.({
           ...o,
@@ -144,6 +80,6 @@ export function awsLambdaRequestHandler<
       },
     });
 
-    return tRPCOutputToAPIGatewayOutput<TEvent, TResult>(event, response);
+    return await planner.toResult(response);
   };
 }

package/src/adapters/express.ts

@@ -27,7 +27,7 @@ export function createExpressMiddleware<TRouter extends AnyRouter>(
     const endpoint = req.path.slice(1);
 
     await nodeHTTPRequestHandler({
-      ...opts,
+      ...(opts as any),
       req,
       res,
       path: endpoint,