@trpc/server 9.24.0 → 9.25.2

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

@@ -0,0 +1,156 @@
+import type {
+  Context as APIGWContext,
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  APIGatewayProxyResult,
+  APIGatewayProxyStructuredResultV2,
+} from 'aws-lambda';
+import { TRPCError, resolveHTTPResponse } from '../..';
+import { HTTPHeaders, HTTPRequest } from '../../http/internals/types';
+import type { HTTPResponse } from '../../http/internals/types';
+import { AnyRouter, inferRouterContext } from '../../router';
+import {
+  APIGatewayEvent,
+  APIGatewayResult,
+  AWSLambdaOptions,
+  UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+  isPayloadV1,
+  isPayloadV2,
+} from './utils';
+
+export type { CreateAWSLambdaContextOptions, AWSLambdaOptions } from './utils';
+
+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);
+    }
+  }
+
+  return {
+    method: getHTTPMethod(event),
+    query: query,
+    headers: event.headers,
+    body: event.body,
+  };
+}
+
+function getHTTPMethod(event: APIGatewayEvent) {
+  if (isPayloadV1(event)) {
+    return event.httpMethod;
+  }
+  if (isPayloadV2(event)) {
+    return event.requestContext.http.method;
+  }
+  throw new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+  });
+}
+function getPath(event: APIGatewayEvent) {
+  if (isPayloadV1(event)) {
+    return event.path.slice(1);
+  }
+  if (isPayloadV2(event)) {
+    return event.rawPath.slice(1);
+  }
+  throw new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+  });
+}
+function transformHeaders(headers: HTTPHeaders): APIGatewayResult['headers'] {
+  const obj: APIGatewayResult['headers'] = {};
+
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === 'undefined') {
+      continue;
+    }
+    obj[key] = Array.isArray(value) ? value.join(',') : value;
+  }
+  return obj;
+}
+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,
+    });
+  }
+}
+
+/** Will check the createContext of the TRouter and get the parameter of event.
+ * @internal
+ **/
+type inferAPIGWEvent<
+  TRouter extends AnyRouter,
+  TEvent extends APIGatewayEvent,
+> = AWSLambdaOptions<TRouter, TEvent>['createContext'] extends NonNullable<
+  AWSLambdaOptions<TRouter, TEvent>['createContext']
+>
+  ? Parameters<AWSLambdaOptions<TRouter, TEvent>['createContext']>[0]['event']
+  : APIGatewayEvent;
+
+/** 1:1 mapping of v1 or v2 input events, deduces which is which.
+ * @internal
+ **/
+type inferAPIGWReturn<T> = T extends APIGatewayProxyEvent
+  ? APIGatewayProxyResult
+  : T extends APIGatewayProxyEventV2
+  ? APIGatewayProxyStructuredResultV2
+  : never;
+export function awsLambdaRequestHandler<
+  TRouter extends AnyRouter,
+  TEvent extends inferAPIGWEvent<TRouter, TEvent>,
+  TResult extends inferAPIGWReturn<TEvent>,
+>(
+  opts: AWSLambdaOptions<TRouter, TEvent>,
+): (event: TEvent, context: APIGWContext) => Promise<TResult> {
+  return async (event, context) => {
+    const req = lambdaEventToHTTPRequest(event);
+    const path = getPath(event);
+    const createContext = async function _createContext(): Promise<
+      inferRouterContext<TRouter>
+    > {
+      return await opts.createContext?.({ event, context });
+    };
+
+    const response = await resolveHTTPResponse({
+      router: opts.router,
+      batching: opts.batching,
+      responseMeta: opts?.responseMeta,
+      createContext,
+      req,
+      path,
+      error: null,
+      onError(o) {
+        opts?.onError?.({
+          ...o,
+          req: event,
+        });
+      },
+    });
+
+    return tRPCOutputToAPIGatewayOutput<TEvent, TResult>(event, response);
+  };
+}

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

@@ -0,0 +1,91 @@
+import type {
+  Context as APIGWContext,
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  APIGatewayProxyResult,
+  APIGatewayProxyStructuredResultV2,
+} from 'aws-lambda';
+import type { ResponseMetaFn } from '../../http/internals/types';
+import type { AnyRouter, inferRouterContext } from '../../router';
+
+export type APIGatewayEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+export type APIGatewayResult =
+  | APIGatewayProxyResult
+  | APIGatewayProxyStructuredResultV2;
+
+export type CreateAWSLambdaContextOptions<T extends APIGatewayEvent> = {
+  event: T;
+  context: APIGWContext;
+};
+export type AWSLambdaCreateContextFn<
+  TRouter extends AnyRouter,
+  TEvent extends APIGatewayEvent,
+> = ({
+  event,
+  context,
+}: CreateAWSLambdaContextOptions<TEvent>) =>
+  | inferRouterContext<TRouter>
+  | Promise<inferRouterContext<TRouter>>;
+
+export type AWSLambdaOptions<
+  TRouter extends AnyRouter,
+  TEvent extends APIGatewayEvent,
+> =
+  | {
+      router: TRouter;
+      batching?: {
+        enabled: boolean;
+      };
+      onError?: (options: Record<string, unknown>) => void;
+      responseMeta?: ResponseMetaFn<TRouter>;
+    } & (
+      | {
+          /**
+           * @link https://trpc.io/docs/context
+           **/
+          createContext: AWSLambdaCreateContextFn<TRouter, TEvent>;
+        }
+      | {
+          /**
+           * @link https://trpc.io/docs/context
+           **/
+          createContext?: AWSLambdaCreateContextFn<TRouter, TEvent>;
+        }
+    );
+
+export function isPayloadV1(
+  event: APIGatewayEvent,
+): event is APIGatewayProxyEvent {
+  return determinePayloadFormat(event) == '1.0';
+}
+export function isPayloadV2(
+  event: APIGatewayEvent,
+): event is APIGatewayProxyEventV2 {
+  return determinePayloadFormat(event) == '2.0';
+}
+
+function determinePayloadFormat(
+  event: APIGatewayEvent,
+): APIGatewayPayloadFormatVersion {
+  // 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 {
+    if (['1.0', '2.0'].includes(unknownEvent.version)) {
+      return unknownEvent.version as APIGatewayPayloadFormatVersion;
+    } else {
+      return 'custom';
+    }
+  }
+}
+export type DefinedAPIGatewayPayloadFormats = '1.0' | '2.0';
+export type APIGatewayPayloadFormatVersion =
+  | DefinedAPIGatewayPayloadFormats
+  | 'custom';
+
+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';

package/src/adapters/lambda/index.ts

@@ -0,0 +1,18 @@
+import {
+  CreateAWSLambdaContextOptions,
+  awsLambdaRequestHandler,
+} from '../aws-lambda';
+import { APIGatewayEvent } from '../aws-lambda/utils';
+
+export * from '../aws-lambda';
+
+/**
+ * @deprecated use `aws-lambda` instead
+ */
+export type CreateLambdaContextOptions<T extends APIGatewayEvent> =
+  CreateAWSLambdaContextOptions<T>;
+
+/**
+ * @deprecated use `aws-lambda` instead
+ */
+export const lambdaRequestHandler = awsLambdaRequestHandler;

package/src/http/internals/types.ts

@@ -26,7 +26,7 @@ export interface HTTPRequest {
   body: unknown;
 }
 
-type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
   data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
   ctx?: inferRouterContext<TRouter>;
   /**