@trpc/server 11.0.0-alpha-tmp-export-from-main.211 → 11.0.0-alpha-tmp-export-from-main-nuke-core.229

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

@@ -0,0 +1,51 @@
+import type { ProcedureType } from '../procedure';
+import type {
+  TRPC_ERROR_CODE_KEY,
+  TRPC_ERROR_CODE_NUMBER,
+  TRPCErrorShape,
+} from '../rpc';
+import type { TRPCError } from './TRPCError';
+
+/**
+ * @internal
+ */
+export type ErrorFormatter<
+  TContext,
+  TShape extends TRPCErrorShape<number>,
+> = (args: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+  shape: DefaultErrorShape;
+}) => TShape;
+
+export type ErrorFormatterShape<TType> = TType extends ErrorFormatter<
+  any,
+  infer TShape
+>
+  ? TShape
+  : DefaultErrorShape;
+/**
+ * @internal
+ */
+export type DefaultErrorData = {
+  code: TRPC_ERROR_CODE_KEY;
+  httpStatus: number;
+  path?: string;
+  stack?: string;
+};
+
+/**
+ * @internal
+ */
+export interface DefaultErrorShape
+  extends TRPCErrorShape<TRPC_ERROR_CODE_NUMBER, DefaultErrorData> {
+  message: string;
+  code: TRPC_ERROR_CODE_NUMBER;
+}
+
+export const defaultFormatter: ErrorFormatter<any, any> = ({ shape }) => {
+  return shape;
+};

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

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

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

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

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

@@ -0,0 +1,23 @@
+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';