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

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

@@ -1,100 +0,0 @@
-// @trpc/server
-import { TRPCError } from '../../../../@trpc/server';
-import type {
-  AnyRouter,
-  CombinedDataTransformer,
-} from '../../../../@trpc/server';
-import { createConcurrentCache } from '../../../content-handlers/concurrentCache';
-import type { NodeHTTPRequest, NodeHTTPResponse } from '../../types';
-import type { NodeHTTPContentTypeHandler } from '../types';
-import { getPostBody } from './getPostBody';
-
-export const getNodeHTTPJSONContentTypeHandler: <
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
->() => NodeHTTPContentTypeHandler<TRouter, TRequest, TResponse> = () => {
-  const cache = createConcurrentCache();
-
-  return {
-    name: 'node-http-json',
-    isMatch: (headers) => {
-      return !!headers.get('content-type')?.startsWith('application/json');
-    },
-    getInputs: async (opts, info) => {
-      async function getRawProcedureInputOrThrow() {
-        const bodyResult = await getPostBody(opts);
-        if (!bodyResult.ok) {
-          throw bodyResult.error;
-        }
-
-        const preprocessedBody = bodyResult.preprocessed;
-        const body = bodyResult.data;
-
-        try {
-          if (opts.req.method === 'GET') {
-            const input = opts.query.get('input');
-            if (!input) {
-              return undefined;
-            }
-
-            return JSON.parse(input);
-          }
-
-          if (preprocessedBody || typeof body !== 'string') {
-            // Some tools like nextjs may parse json
-            // requests before they reach us. So we just use them as is
-            return body;
-          } else {
-            return JSON.parse(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/node-http/content-type/octet/index.ts

@@ -1,27 +0,0 @@
-import { Stream } from 'stream';
-// @trpc/server
-import type { AnyRouter } from '../../../../@trpc/server';
-import type { NodeHTTPRequest, NodeHTTPResponse } from '../../types';
-import type { NodeHTTPContentTypeHandler } from '../types';
-
-export const getOctetContentTypeHandler: <
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
->() => NodeHTTPContentTypeHandler<TRouter, TRequest, TResponse> = () => ({
-  name: 'node-http-octet',
-  isMatch: (headers) => {
-    return !!headers
-      .get('content-type')
-      ?.startsWith('application/octet-stream');
-  },
-  async getInputs(opts, inputOpts) {
-    if (inputOpts.isBatchCall) {
-      throw new Error('Batch calls not supported for octet-stream');
-    }
-
-    const stream = Stream.Readable.toWeb(opts.req);
-
-    return stream;
-  },
-});

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

@@ -1,19 +0,0 @@
-// @trpc/server
-import type { AnyRouter } from '../../../@trpc/server';
-// @trpc/server/http
-import type { BaseContentTypeHandler } from '../../../@trpc/server/http';
-import type {
-  NodeHTTPRequest,
-  NodeHTTPRequestHandlerOptions,
-  NodeHTTPResponse,
-} from '../types';
-
-export interface NodeHTTPContentTypeHandler<
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
-> extends BaseContentTypeHandler<
-    NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse> & {
-      query: URLSearchParams;
-    }
-  > {}

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

@@ -1,37 +0,0 @@
-import { TRPCError } from './error/TRPCError';
-import type { ParserZodEsque } from './parser';
-
-export type UtilityParser<TInput, TOutput> = ParserZodEsque<TInput, TOutput> & {
-  parse: (input: unknown) => TOutput;
-};
-
-// Should be the same possible types as packages/client/src/links/internals/contentTypes.ts isOctetType
-
-/**
- * File is only available from Node19+ but it always extends Blob so we can use that as a type until we eventually drop Node18
- */
-interface FileLike extends Blob {
-  readonly name: string;
-}
-
-/**
- * When expecting a supported octet type to be passed from the frontend, this parser may be used to validate the type for your procedure. Note: the output is always a `Readable` stream.
- */
-export function parseOctetInput<
-  TInput extends Blob | Uint8Array | FileLike,
->(): UtilityParser<TInput, ReadableStream> {
-  return {
-    _input: null as any as TInput,
-    _output: null as any as ReadableStream,
-    parse(input: unknown) {
-      if (input instanceof ReadableStream) {
-        return input;
-      }
-
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        cause: `Parsed input was expected to be a ReadableStream but was: ${typeof input}`,
-      });
-    },
-  };
-}

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

@@ -1,28 +0,0 @@
-export {
-  getHTTPStatusCode,
-  getHTTPStatusCodeFromError,
-} from './getHTTPStatusCode';
-export { resolveHTTPResponse } from './resolveHTTPResponse';
-export type {
-  BaseHandlerOptions,
-  HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  /**
-   * @deprecated Use `HTTPErrorHandler` instead
-   */
-  HTTPErrorHandler as OnErrorFunction,
-  HTTPErrorHandler,
-  ProcedureCall,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-  ResponseMeta,
-  ResponseMetaFn,
-  TRPCRequestInfo,
-} from './types';
-
-export { getBatchStreamFormatter } from './batchStreamFormatter';
-export type { BaseContentTypeHandler, BodyResult } from './contentType';
-
-export { toURL } from './toURL';

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

@@ -1,461 +0,0 @@
-import { getErrorShape } from '../error/getErrorShape';
-import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
-import type { ProcedureType } from '../procedure';
-import type {
-  AnyRouter,
-  inferRouterContext,
-  inferRouterError,
-} from '../router';
-import { callProcedure } from '../router';
-import type { TRPCResponse } from '../rpc';
-import { transformTRPCResponse } from '../transformer';
-import { getHTTPStatusCode } from './getHTTPStatusCode';
-import type {
-  HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-  TRPCRequestInfo,
-} from './types';
-
-const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
-  string,
-  ProcedureType | undefined
-> = {
-  GET: 'query',
-  POST: 'mutation',
-};
-
-type PartialBy<TBaseType, TKey extends keyof TBaseType> = Omit<
-  TBaseType,
-  TKey
-> &
-  Partial<Pick<TBaseType, TKey>>;
-
-interface ResolveHTTPRequestOptions<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
-> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-  createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
-  req: TRequest;
-  path: string;
-  getInput: (opts: { isBatchCall: boolean; batch: number }) => Promise<unknown>;
-  error?: TRPCError;
-  /**
-   * Called as soon as the response head is known.
-   * When streaming, headers will have been generated
-   * **without** knowing the response body.
-   *
-   * Without this callback, streaming is disabled.
-   */
-  unstable_onHead: (
-    headResponse: Omit<HTTPResponse, 'body'>,
-    isStreaming: boolean,
-  ) => void;
-  /**
-   * Called for every procedure with `[index, result]`.
-   *
-   * Will be called a single time with `index = -1` if
-   * - response is an error
-   * - response is empty (HEAD request)
-   *
-   * Without this callback, streaming is disabled.
-   */
-  unstable_onChunk: (chunk: ResponseChunk) => void;
-}
-
-function initResponse<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(initOpts: {
-  ctx: inferRouterContext<TRouter> | undefined;
-  paths: string[] | undefined;
-  type: ProcedureType | 'unknown';
-  responseMeta?: HTTPBaseHandlerOptions<TRouter, TRequest>['responseMeta'];
-  untransformedJSON?:
-    | TRPCResponse<unknown, inferRouterError<TRouter>>
-    | TRPCResponse<unknown, inferRouterError<TRouter>>[]
-    | undefined;
-  errors?: TRPCError[];
-}): HTTPResponse {
-  const {
-    ctx,
-    paths,
-    type,
-    responseMeta,
-    untransformedJSON,
-    errors = [],
-  } = initOpts;
-
-  let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
-  const headers: HTTPHeaders = {
-    'Content-Type': 'application/json',
-  };
-
-  const eagerGeneration = !untransformedJSON;
-  const data = eagerGeneration
-    ? []
-    : Array.isArray(untransformedJSON)
-    ? untransformedJSON
-    : [untransformedJSON];
-
-  const meta =
-    responseMeta?.({
-      ctx,
-      paths,
-      type,
-      data,
-      errors,
-      eagerGeneration,
-    }) ?? {};
-
-  for (const [key, value] of Object.entries(meta.headers ?? {})) {
-    headers[key] = value;
-  }
-  if (meta.status) {
-    status = meta.status;
-  }
-
-  return {
-    status,
-    headers,
-  };
-}
-
-function caughtErrorToData<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(
-  cause: unknown,
-  errorOpts: {
-    opts: Pick<
-      ResolveHTTPRequestOptions<TRouter, TRequest>,
-      'onError' | 'req' | 'router'
-    >;
-    ctx: inferRouterContext<TRouter> | undefined;
-    type: ProcedureType | 'unknown';
-    path?: string;
-    input?: unknown;
-  },
-) {
-  const { router, req, onError } = errorOpts.opts;
-  const error = getTRPCErrorFromUnknown(cause);
-  onError?.({
-    error,
-    path: errorOpts.path,
-    input: errorOpts.input,
-    ctx: errorOpts.ctx,
-    type: errorOpts.type,
-    req,
-  });
-  const untransformedJSON = {
-    error: getErrorShape({
-      config: router._def._config,
-      error,
-      type: errorOpts.type,
-      path: errorOpts.path,
-      input: errorOpts.input,
-      ctx: errorOpts.ctx,
-    }),
-  };
-  const transformedJSON = transformTRPCResponse(
-    router._def._config,
-    untransformedJSON,
-  );
-  const body = JSON.stringify(transformedJSON);
-  return {
-    error,
-    untransformedJSON,
-    body,
-  };
-}
-
-/**
- * Since `resolveHTTPResponse` is a public API (community adapters),
- * let's give it a strong type signature to increase discoverability.
- */
-
-/**
- * Non-streaming signature for `resolveHTTPResponse`:
- * @param opts.unstable_onHead `undefined`
- * @param opts.unstable_onChunk `undefined`
- * @returns `Promise<HTTPResponse>`
- */
-export async function resolveHTTPResponse<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(
-  opts: Omit<
-    ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'unstable_onChunk' | 'unstable_onHead'
-  >,
-): Promise<HTTPResponse>;
-/**
- * Streaming signature for `resolveHTTPResponse`:
- * @param opts.unstable_onHead called as soon as the response head is known
- * @param opts.unstable_onChunk called for every procedure with `[index, result]`
- * @returns `Promise<void>` since the response is streamed
- */
-export async function resolveHTTPResponse<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<void>;
-// implementation
-export async function resolveHTTPResponse<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(
-  opts: PartialBy<
-    ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'unstable_onChunk' | 'unstable_onHead'
-  >,
-): Promise<HTTPResponse | void> {
-  const { router, req, unstable_onHead, unstable_onChunk } = opts;
-
-  if (req.method === 'HEAD') {
-    // can be used for lambda warmup
-    const headResponse: HTTPResponse = {
-      status: 204,
-    };
-    unstable_onHead?.(headResponse, false);
-    unstable_onChunk?.([-1, '']);
-    return headResponse;
-  }
-  const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
-  const allowMethodOverride = opts.allowMethodOverride ?? false;
-
-  const type =
-    HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? ('unknown' as const);
-  let ctx: inferRouterContext<TRouter> | undefined = undefined;
-  let paths: string[] | undefined;
-
-  const isBatchCall = !!req.query.get('batch');
-  const isStreamCall =
-    isBatchCall &&
-    unstable_onHead &&
-    unstable_onChunk &&
-    req.headers['trpc-batch-mode'] === 'stream';
-
-  try {
-    if (isBatchCall && !allowBatching) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        message: `Batching is not enabled on the server`,
-      });
-    }
-    /* istanbul ignore if -- @preserve */
-    if (type === 'subscription') {
-      throw new TRPCError({
-        message: 'Subscriptions should use wsLink',
-        code: 'METHOD_NOT_SUPPORTED',
-      });
-    }
-    if (type === 'unknown') {
-      throw new TRPCError({
-        message: `Unexpected request method ${req.method}`,
-        code: 'METHOD_NOT_SUPPORTED',
-      });
-    }
-
-    paths = isBatchCall
-      ? decodeURIComponent(opts.path).split(',')
-      : [opts.path];
-    const info: TRPCRequestInfo = {
-      isBatchCall,
-      calls: paths.map((path) => ({
-        path,
-        type,
-      })),
-    };
-    ctx = await opts.createContext({ info });
-
-    const errors: TRPCError[] = [];
-
-    const promises: Promise<
-      TRPCResponse<unknown, inferRouterError<TRouter>>
-    >[] = paths.map(async (path, index) => {
-      async function getRawInput() {
-        return await opts.getInput({
-          isBatchCall,
-          batch: 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,
-          ctx,
-          type,
-          allowMethodOverride,
-        });
-        return {
-          result: {
-            data,
-          },
-        };
-      } catch (cause) {
-        const error = getTRPCErrorFromUnknown(cause);
-        errors.push(error);
-
-        let input: unknown;
-        try {
-          input = await getRawInput();
-        } catch (e) {
-          // if `getRawInput` fails, we can't include the input in the error
-          input = undefined;
-        }
-
-        opts.onError?.({
-          error,
-          path,
-          input,
-          ctx,
-          type: type,
-          req: opts.req,
-        });
-
-        return {
-          error: getErrorShape({
-            config: opts.router._def._config,
-            error,
-            type,
-            path,
-            input,
-            ctx,
-          }),
-        };
-      }
-    });
-
-    if (!isStreamCall) {
-      /**
-       * Non-streaming response:
-       * - await all responses in parallel, blocking on the slowest one
-       * - create headers with known response body
-       * - return a complete HTTPResponse
-       */
-
-      const untransformedJSON = await Promise.all(promises);
-
-      const headResponse = initResponse({
-        ctx,
-        paths,
-        type,
-        responseMeta: opts.responseMeta,
-        untransformedJSON,
-        errors,
-      });
-      unstable_onHead?.(headResponse, false);
-
-      // return body stuff
-      const result = isBatchCall ? untransformedJSON : untransformedJSON[0]!; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
-      const transformedJSON = transformTRPCResponse(
-        router._def._config,
-        result,
-      );
-      const body = JSON.stringify(transformedJSON);
-      unstable_onChunk?.([-1, body]);
-
-      return {
-        status: headResponse.status,
-        headers: headResponse.headers,
-        body,
-      };
-    }
-
-    /**
-     * Streaming response:
-     * - block on none, call `onChunk` as soon as each response is ready
-     * - create headers with minimal data (cannot know the response body in advance)
-     * - return void
-     */
-    const headResponse = initResponse({
-      ctx,
-      paths,
-      type,
-      responseMeta: opts.responseMeta,
-    });
-    unstable_onHead(headResponse, true);
-
-    const indexedPromises = new Map(
-      promises.map((promise, index) => [
-        index,
-        promise.then((r) => [index, r] as const),
-      ]),
-    );
-    for (const _ of paths) {
-      const [index, untransformedJSON] = await Promise.race(
-        indexedPromises.values(),
-      );
-      indexedPromises.delete(index);
-
-      try {
-        const transformedJSON = transformTRPCResponse(
-          router._def._config,
-          untransformedJSON,
-        );
-        const body = JSON.stringify(transformedJSON);
-
-        unstable_onChunk([index, body]);
-      } catch (cause) {
-        const path = paths[index];
-        const input = await opts.getInput({
-          isBatchCall,
-          batch: index,
-        });
-        const { body } = caughtErrorToData(cause, {
-          opts,
-          ctx,
-          type,
-          path,
-          input,
-        });
-
-        unstable_onChunk([index, body]);
-      }
-    }
-    return;
-  } catch (cause) {
-    // we get here if
-    // - batching is called when it's not enabled
-    // - `createContext()` throws
-    // - `router._def._config.transformer.output.serialize()` throws
-    // - post body is too large
-    // - input deserialization fails
-    // - `errorFormatter` return value is malformed
-    const { error, untransformedJSON, body } = caughtErrorToData(cause, {
-      opts,
-      ctx,
-      type,
-    });
-
-    const headResponse = initResponse({
-      ctx,
-      paths,
-      type,
-      responseMeta: opts.responseMeta,
-      untransformedJSON,
-      errors: [error],
-    });
-    unstable_onHead?.(headResponse, false);
-
-    unstable_onChunk?.([-1, body]);
-
-    return {
-      status: headResponse.status,
-      headers: headResponse.headers,
-      body,
-    };
-  }
-}