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

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

@@ -1,108 +0,0 @@
-// @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/utils.ts

@@ -1,170 +0,0 @@
-/**
- * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
- *
- * @example
- * ```ts
- * import type { AnyTRPCRouter } from '@trpc/server'
- * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
- * ```
- */
-import type {
-  APIGatewayProxyEvent,
-  APIGatewayProxyEventV2,
-  APIGatewayProxyResult,
-  APIGatewayProxyStructuredResultV2,
-  Context as APIGWContext,
-} from 'aws-lambda';
-import type {
-  AnyRouter,
-  CreateContextCallback,
-  inferRouterContext,
-} from '../../@trpc/server';
-// import @trpc/server
-
-// @trpc/server
-import { TRPCError } from '../../@trpc/server';
-import type {
-  HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  TRPCRequestInfo,
-} from '../../@trpc/server/http';
-
-export type APIGatewayEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
-export type APIGatewayResult =
-  | APIGatewayProxyResult
-  | APIGatewayProxyStructuredResultV2;
-
-export type CreateAWSLambdaContextOptions<TEvent extends APIGatewayEvent> = {
-  event: TEvent;
-  context: APIGWContext;
-  info: TRPCRequestInfo;
-};
-export type AWSLambdaCreateContextFn<
-  TRouter extends AnyRouter,
-  TEvent extends APIGatewayEvent,
-> = ({
-  event,
-  context,
-  info,
-}: CreateAWSLambdaContextOptions<TEvent>) =>
-  | inferRouterContext<TRouter>
-  | Promise<inferRouterContext<TRouter>>;
-
-export type AWSLambdaOptions<
-  TRouter extends AnyRouter,
-  TEvent extends APIGatewayEvent,
-> =
-  | HTTPBaseHandlerOptions<TRouter, TEvent> &
-      CreateContextCallback<
-        inferRouterContext<AnyRouter>,
-        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 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,
-  });
-}
-
-export function getPath(event: APIGatewayEvent) {
-  if (isPayloadV1(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);
-  }
-  if (isPayloadV2(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);
-  }
-  throw new TRPCError({
-    code: 'INTERNAL_SERVER_ERROR',
-    message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
-  });
-}
-
-export 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;
-}
-
-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';
-
-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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,45 +0,0 @@
-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/fastify/content-type/json/index.ts

@@ -1,106 +0,0 @@
-// @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/types.ts

@@ -1,22 +0,0 @@
-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

@@ -1,90 +0,0 @@
-// @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/node-http/content-type/form-data/index.ts

@@ -1,37 +0,0 @@
-import { Readable } from 'stream';
-// @trpc/server
-import type { AnyRouter } from '../../../../@trpc/server';
-import type { NodeHTTPRequest, NodeHTTPResponse } from '../../types';
-import type { NodeHTTPContentTypeHandler } from '../types';
-
-export const getFormDataContentTypeHandler: <
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
->() => NodeHTTPContentTypeHandler<TRouter, TRequest, TResponse> = () => ({
-  name: 'node-http-formdata',
-  isMatch: (headers) => {
-    return !!headers.get('content-type')?.startsWith('multipart/form-data');
-  },
-  async getInputs(opts, inputOpts) {
-    if (inputOpts.isBatchCall) {
-      throw new Error('Batch calls not supported for form-data');
-    }
-
-    const contentType = opts.req.headers['content-type'];
-    if (!contentType) {
-      // Should be unreachable given the isMatch check
-      throw new Error('No content-type header found');
-    }
-
-    const form = await new Request('https://unused.com', {
-      method: 'POST',
-      headers: { 'content-type': contentType },
-      body: Readable.toWeb(opts.req) as ReadableStream,
-      // @ts-expect-error - outdated types? this exists
-      duplex: 'half',
-    }).formData();
-
-    return form;
-  },
-});

package/src/adapters/node-http/content-type/json/getPostBody.ts

@@ -1,49 +0,0 @@
-// @trpc/server
-import { TRPCError } from '../../../../@trpc/server';
-import type { BodyResult } from '../../../../@trpc/server/http';
-import type { NodeHTTPRequest } from '../../types';
-
-export async function getPostBody(opts: {
-  req: NodeHTTPRequest;
-  maxBodySize?: number;
-}): Promise<BodyResult> {
-  const { req, maxBodySize = Infinity } = opts;
-  return new Promise((resolve) => {
-    if ('body' in req) {
-      resolve({
-        ok: true,
-        data: req.body,
-        // If the request headers specifies a content-type, we assume that the body has been preprocessed
-        preprocessed:
-          !!req.headers['content-type']?.startsWith('application/json'),
-      });
-      return;
-    }
-
-    let body = '';
-    let hasBody = false;
-
-    function onData(data: any) {
-      body += data;
-      hasBody = true;
-      if (body.length > maxBodySize) {
-        req.off('data', onData);
-
-        resolve({
-          ok: false,
-          error: new TRPCError({ code: 'PAYLOAD_TOO_LARGE' }),
-        });
-      }
-    }
-
-    req.on('data', onData);
-
-    req.on('end', () => {
-      resolve({
-        ok: true,
-        data: hasBody ? body : undefined,
-        preprocessed: false,
-      });
-    });
-  });
-}