@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.239 → 11.0.0-alpha-tmp-export-from-main.219

package/src/unstable-core-do-not-import/error/getErrorShape.ts

@@ -1,36 +0,0 @@
-import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
-import type { ProcedureType } from '../procedure';
-import type { AnyRootConfig } from '../rootConfig';
-import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
-import type { DefaultErrorShape } from './formatter';
-import type { TRPCError } from './TRPCError';
-
-/**
- * @internal
- */
-export function getErrorShape<TConfig extends AnyRootConfig>(opts: {
-  config: TConfig;
-  error: TRPCError;
-  type: ProcedureType | 'unknown';
-  path: string | undefined;
-  input: unknown;
-  ctx: TConfig['$types']['ctx'] | undefined;
-}): TConfig['$types']['errorShape'] {
-  const { path, error, config } = opts;
-  const { code } = opts.error;
-  const shape: DefaultErrorShape = {
-    message: error.message,
-    code: TRPC_ERROR_CODES_BY_KEY[code],
-    data: {
-      code,
-      httpStatus: getHTTPStatusCodeFromError(error),
-    },
-  };
-  if (config.isDev && typeof opts.error.stack === 'string') {
-    shape.data.stack = opts.error.stack;
-  }
-  if (typeof path === 'string') {
-    shape.data.path = path;
-  }
-  return config.errorFormatter({ ...opts, shape });
-}

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

@@ -1,29 +0,0 @@
-/**
- * Format a batch response as a line-delimited JSON stream
- * that the `unstable_httpBatchStreamLink` can parse:
- *
- * @example
- * ```ts
- * const formatter = getBatchStreamFormatter();
- * res.send(formatter(1, 'response #2'));
- * res.send(formatter(0, 'response #1'));
- * res.send(formatter.end());
- * ```
- *
- * Expected format:
- * ```json
- * {"1":"response #2"
- * ,"0":"response #1"
- * }
- * ```
- */
-export function getBatchStreamFormatter() {
-  let first = true;
-  function format(index: number, string: string) {
-    const prefix = first ? '{' : ',';
-    first = false;
-    return `${prefix}"${index}":${string}\n`;
-  }
-  format.end = () => '}';
-  return format;
-}

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

@@ -1,99 +0,0 @@
-/* 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 =
-  | {
-      ok: true;
-      data: unknown;
-      /**
-       * If the HTTP handler has already parsed the body
-       */
-      preprocessed: boolean;
-    }
-  | { ok: false; error: TRPCError };
-
-export type BaseContentTypeHandler<TOptions> = {
-  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/getHTTPStatusCode.ts

@@ -1,57 +0,0 @@
-import type { TRPCError } from '../error/TRPCError';
-import type { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
-import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc';
-
-const JSONRPC2_TO_HTTP_CODE: Record<
-  keyof typeof TRPC_ERROR_CODES_BY_KEY,
-  number
-> = {
-  PARSE_ERROR: 400,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  NOT_FOUND: 404,
-  FORBIDDEN: 403,
-  METHOD_NOT_SUPPORTED: 405,
-  TIMEOUT: 408,
-  CONFLICT: 409,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  UNPROCESSABLE_CONTENT: 422,
-  TOO_MANY_REQUESTS: 429,
-  CLIENT_CLOSED_REQUEST: 499,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-};
-
-function getStatusCodeFromKey(code: keyof typeof TRPC_ERROR_CODES_BY_KEY) {
-  return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
-}
-
-export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
-  const arr = Array.isArray(json) ? json : [json];
-  const httpStatuses = new Set(
-    arr.map((res) => {
-      if ('error' in res) {
-        const data = res.error.data;
-        if (typeof data['httpStatus'] === 'number') {
-          return data['httpStatus'];
-        }
-        const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
-        return getStatusCodeFromKey(code);
-      }
-      return 200;
-    }),
-  );
-
-  if (httpStatuses.size !== 1) {
-    return 207;
-  }
-
-  const httpStatus = httpStatuses.values().next().value;
-
-  return httpStatus;
-}
-
-export function getHTTPStatusCodeFromError(error: TRPCError) {
-  return getStatusCodeFromKey(error.code);
-}

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

@@ -1,23 +0,0 @@
-export {
-  getHTTPStatusCode,
-  getHTTPStatusCodeFromError,
-} from './getHTTPStatusCode';
-export { resolveHTTPResponse } from './resolveHTTPResponse';
-export type {
-  BaseHandlerOptions,
-  HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  OnErrorFunction,
-  ProcedureCall,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-  ResponseMeta,
-  ResponseMetaFn,
-  TRPCRequestInfo,
-} from './types';
-
-export { getBatchStreamFormatter } from './batchStreamFormatter';
-export type { BaseContentTypeHandler, BodyResult } from './contentType';
-export { getJsonContentTypeInputs } from './contentType';

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

@@ -1,458 +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 type { Maybe } from '../types';
-import type { BaseContentTypeHandler } from './contentType';
-import { getJsonContentTypeInputs } from './contentType';
-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',
-};
-
-const fallbackContentTypeHandler = {
-  getInputs: getJsonContentTypeInputs,
-};
-
-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;
-  error?: Maybe<TRPCError>;
-  contentTypeHandler?: BaseContentTypeHandler<any>;
-  preprocessedBody?: boolean;
-  /**
-   * 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,
-  };
-}
-
-async function inputToProcedureCall<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(procedureOpts: {
-  opts: Pick<
-    ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'onError' | 'req' | 'router'
-  >;
-  ctx: inferRouterContext<TRouter> | undefined;
-  type: 'mutation' | 'query';
-  input: unknown;
-  path: string;
-}): Promise<TRPCResponse<unknown, inferRouterError<TRouter>>> {
-  const { opts, ctx, type, input, path } = procedureOpts;
-  try {
-    const data = await callProcedure({
-      procedures: opts.router._def.procedures,
-      path,
-      getRawInput: async () => input,
-      ctx,
-      type,
-    });
-    return {
-      result: {
-        data,
-      },
-    };
-  } catch (cause) {
-    const error = getTRPCErrorFromUnknown(cause);
-
-    opts.onError?.({ error, path, input, ctx, type: type, req: opts.req });
-
-    return {
-      error: getErrorShape({
-        config: opts.router._def._config,
-        error,
-        type,
-        path,
-        input,
-        ctx,
-      }),
-    };
-  }
-}
-
-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 contentTypeHandler =
-    opts.contentTypeHandler ?? fallbackContentTypeHandler;
-  const batchingEnabled = opts.batching?.enabled ?? true;
-  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 (opts.error) {
-      throw opts.error;
-    }
-    if (isBatchCall && !batchingEnabled) {
-      throw new Error(`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',
-      });
-    }
-
-    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, idx) => ({
-        path,
-        type,
-        input: inputs[idx] ?? undefined,
-      })),
-    };
-    ctx = await opts.createContext({ info });
-    const promises = paths.map((path, index) =>
-      inputToProcedureCall({ opts, ctx, type, input: inputs[index], path }),
-    );
-
-    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 errors = untransformedJSON.flatMap((response) =>
-        'error' in response ? [response.error] : [],
-      );
-
-      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 = inputs[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,
-    };
-  }
-}