@trpc/server 11.0.0-rc.359 → 11.0.0-rc.362

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

@@ -1,99 +1,216 @@
-/* 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 };
+import type { RootConfig } from '../rootConfig';
+import { isObject, unsetMarker } from '../utils';
+import type { TRPCRequestInfo } from './types';
 
-export type BaseContentTypeHandler<TOptions> = {
-  isMatch(opts: TOptions): boolean;
-  getBody: (opts: TOptions) => MaybePromise<BodyResult>;
-  getInputs: GetInputs;
+type ContentTypeHandler = {
+  isMatch: (opts: Request) => boolean;
+  parse: (opts: {
+    path: string;
+    req: Request;
+    searchParams: URLSearchParams;
+    config: RootConfig<any>;
+  }) => TRPCRequestInfo;
 };
 
-function getRawProcedureInputOrThrow(opts: {
-  req: HTTPRequest;
-  preprocessedBody: boolean;
-}) {
-  const { req } = opts;
-  try {
-    if (req.method === 'GET') {
-      if (!req.query.has('input')) {
-        return undefined;
+/**
+ * Memoize a function that takes no arguments
+ * @internal
+ */
+function memo<TReturn>(fn: () => Promise<TReturn>) {
+  let promise: Promise<TReturn> | null = null;
+  let value: TReturn | typeof unsetMarker = unsetMarker;
+  return {
+    /**
+     * Lazily read the value
+     */
+    read: async (): Promise<TReturn> => {
+      if (value !== unsetMarker) {
+        return value;
       }
-      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,
-    });
-  }
+      if (promise === null) {
+        // dedupes promises and catches errors
+        promise = fn().catch((cause) => {
+          if (cause instanceof TRPCError) {
+            throw cause;
+          }
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: cause instanceof Error ? cause.message : 'Invalid input',
+            cause,
+          });
+        });
+      }
+
+      value = await promise;
+      promise = null;
+
+      return value;
+    },
+    /**
+     * Get an already stored result
+     */
+    result: (): TReturn | undefined => {
+      return value !== unsetMarker ? value : undefined;
+    },
+  };
 }
 
-const deserializeInputValue = (
-  rawValue: unknown,
-  transformer: CombinedDataTransformer,
-) => {
-  return typeof rawValue !== 'undefined'
-    ? transformer.input.deserialize(rawValue)
-    : rawValue;
-};
+const jsonContentTypeHandler: ContentTypeHandler = {
+  isMatch(req) {
+    return !!req.headers.get('content-type')?.startsWith('application/json');
+  },
+  parse(opts) {
+    const { req } = opts;
+    const isBatchCall = opts.searchParams.get('batch') === '1';
+    const paths = isBatchCall ? opts.path.split(',') : [opts.path];
 
-export const getJsonContentTypeInputs: GetInputs = (opts) => {
-  const rawInput = getRawProcedureInputOrThrow(opts);
-  const transformer = opts.router._def._config.transformer;
+    type InputRecord = Record<number, unknown>;
+    const getInputs = memo(async (): Promise<InputRecord> => {
+      let inputs: unknown = undefined;
+      if (req.method === 'GET') {
+        const queryInput = opts.searchParams.get('input');
+        if (queryInput) {
+          inputs = JSON.parse(queryInput);
+        }
+      } else {
+        inputs = await req.json();
+      }
+      if (inputs === undefined) {
+        return {};
+      }
+
+      if (!isBatchCall) {
+        return {
+          0: opts.config.transformer.input.deserialize(inputs),
+        };
+      }
+
+      if (!isObject(inputs)) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: '"input" needs to be an object when doing a batch call',
+        });
+      }
+      const acc: InputRecord = {};
+      for (const index of paths.keys()) {
+        const input = inputs[index];
+        if (input !== undefined) {
+          acc[index] = opts.config.transformer.input.deserialize(input);
+        }
+      }
+
+      return acc;
+    });
 
-  if (!opts.isBatchCall) {
     return {
-      0: deserializeInputValue(rawInput, transformer),
+      isBatchCall,
+      calls: paths.map((path, index) => ({
+        path,
+        getRawInput: async () => {
+          const inputs = await getInputs.read();
+          return inputs[index];
+        },
+        result: () => {
+          return getInputs.result()?.[index];
+        },
+      })),
     };
-  }
+  },
+};
 
-  /* 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 formDataContentTypeHandler: ContentTypeHandler = {
+  isMatch(req) {
+    return !!req.headers.get('content-type')?.startsWith('multipart/form-data');
+  },
+  parse(opts) {
+    const { req } = opts;
+    if (req.method !== 'POST') {
+      throw new TRPCError({
+        code: 'METHOD_NOT_SUPPORTED',
+        message:
+          'Only POST requests are supported for multipart/form-data requests',
+      });
+    }
+    const getInputs = memo(async () => {
+      const fd = await req.formData();
+      return fd;
     });
-  }
-  const input: Record<number, unknown> = {};
-  for (const key in rawInput) {
-    const k = key as any as number;
-    const rawValue = rawInput[k];
+    return {
+      calls: [
+        {
+          path: opts.path,
+          getRawInput: getInputs.read,
+          result: getInputs.result,
+        },
+      ],
+      isBatchCall: false,
+    };
+  },
+};
+
+const octetStreamContentTypeHandler: ContentTypeHandler = {
+  isMatch(req) {
+    return !!req.headers
+      .get('content-type')
+      ?.startsWith('application/octet-stream');
+  },
+  parse(opts) {
+    const { req } = opts;
+    if (req.method !== 'POST') {
+      throw new TRPCError({
+        code: 'METHOD_NOT_SUPPORTED',
+        message:
+          'Only POST requests are supported for application/octet-stream requests',
+      });
+    }
+    const getInputs = memo(async () => {
+      return req.body;
+    });
+    return {
+      calls: [
+        {
+          path: opts.path,
+          getRawInput: getInputs.read,
+          result: getInputs.result,
+        },
+      ],
+      isBatchCall: false,
+    };
+  },
+};
 
-    const value = deserializeInputValue(rawValue, transformer);
+const handlers = [
+  jsonContentTypeHandler,
+  formDataContentTypeHandler,
+  octetStreamContentTypeHandler,
+];
 
-    input[k] = value;
+function getContentTypeHandler(req: Request): ContentTypeHandler {
+  const handler = handlers.find((handler) => handler.isMatch(req));
+  if (handler) {
+    return handler;
   }
 
-  return input;
-};
+  if (!handler && req.method === 'GET') {
+    // fallback to JSON for get requests so GET-requests can be opened in browser easily
+    return jsonContentTypeHandler;
+  }
+
+  throw new TRPCError({
+    code: 'UNSUPPORTED_MEDIA_TYPE',
+    message: req.headers.has('content-type')
+      ? `Unsupported content-type "${req.headers.get('content-type')}`
+      : 'Missing content-type header',
+  });
+}
+
+export function getRequestInfo(opts: {
+  path: string;
+  req: Request;
+  searchParams: URLSearchParams;
+  config: RootConfig<any>;
+}): TRPCRequestInfo {
+  const handler = getContentTypeHandler(opts.req);
+  return handler.parse(opts);
+}

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

@@ -0,0 +1,29 @@
+import type { ParserZodEsque } from '../parser';
+
+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;
+}
+
+type OctetInput = Blob | Uint8Array | FileLike;
+export const octetInputParser: UtilityParser<OctetInput, ReadableStream> = {
+  _input: null as any as OctetInput,
+  _output: null as any as ReadableStream,
+  parse(input) {
+    if (input instanceof ReadableStream) {
+      return input;
+    }
+
+    throw new Error(
+      `Parsed input was expected to be a ReadableStream but was: ${typeof input}`,
+    );
+  },
+};

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

@@ -29,9 +29,9 @@ function getStatusCodeFromKey(code: keyof typeof TRPC_ERROR_CODES_BY_KEY) {
   return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
 }
 
-export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
+export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): number {
   const arr = Array.isArray(json) ? json : [json];
-  const httpStatuses = new Set(
+  const httpStatuses = new Set<number>(
     arr.map((res) => {
       if ('error' in res) {
         const data = res.error.data as