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

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

@@ -13,7 +13,6 @@ import type {
   AnyRouter,
   CreateContextCallback,
   inferRouterContext,
-  WrapCreateContext,
 } from '../../@trpc/server';
 // @trpc/server/http
 import type {
@@ -43,7 +42,7 @@ export type NodeHTTPResponse = http.ServerResponse & {
   flush?: () => void;
 };
 
-export type NodeHTTPConditionCreateContextOption<
+export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,
   TRequest,
   TResponse,
@@ -60,50 +59,41 @@ type ConnectMiddleware<
   TResponse extends NodeHTTPResponse = NodeHTTPResponse,
 > = (req: TRequest, res: TResponse, next: (err?: any) => any) => void;
 
-interface CoreNodeHTTPHandlerOptions<
-  TRouter extends AnyRouter,
-  TRequest extends NodeHTTPRequest,
-  TResponse extends NodeHTTPResponse,
-> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-  /**
-   * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
-   *
-   * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
-   *
-   * ```ts
-   * import cors from 'cors'
-   *
-   * nodeHTTPRequestHandler({
-   *   cors: cors()
-   * })
-   * ```
-   *
-   * You can also use it for other needs which a connect/node.js compatible middleware can solve,
-   *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
-   */
-  middleware?: ConnectMiddleware<TRequest, TResponse>;
-  maxBodySize?: number;
-}
-
-// Public API
 export type NodeHTTPHandlerOptions<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
-> = CoreNodeHTTPHandlerOptions<TRouter, TRequest, TResponse> &
-  NodeHTTPConditionCreateContextOption<TRouter, TRequest, TResponse>;
+> = HTTPBaseHandlerOptions<TRouter, TRequest> &
+  NodeHTTPCreateContextOption<TRouter, TRequest, TResponse> & {
+    /**
+     * By default, http `OPTIONS` requests are not handled, and CORS headers are not returned.
+     *
+     * This can be used to handle them manually or via the `cors` npm package: https://www.npmjs.com/package/cors
+     *
+     * ```ts
+     * import cors from 'cors'
+     *
+     * nodeHTTPRequestHandler({
+     *   cors: cors()
+     * })
+     * ```
+     *
+     * You can also use it for other needs which a connect/node.js compatible middleware can solve,
+     *  though you might wish to consider an alternative solution like the Express adapter if your needs are complex.
+     */
+    middleware?: ConnectMiddleware;
+    maxBodySize?: number;
+  };
 
-// Internal user
 export type NodeHTTPRequestHandlerOptions<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
-> = CoreNodeHTTPHandlerOptions<TRouter, TRequest, TResponse> &
-  WrapCreateContext<NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>> & {
-    req: TRequest;
-    res: TResponse;
-    path: string;
-  };
+> = {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
 
 export type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
   req: TRequest;

package/src/adapters/standalone.ts

@@ -37,7 +37,7 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
     const path = url.pathname.slice(1);
 
     await nodeHTTPRequestHandler({
-      ...opts,
+      ...(opts as any),
       req,
       res,
       path,

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

@@ -1,24 +1,216 @@
-import type { TRPCError } from '../error/TRPCError';
-
-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> = {
-  name: string;
-  isMatch(headers: Headers): boolean;
-  getInputs: (
-    opts: TOptions,
-    info: {
-      isBatchCall: boolean;
-      batch: number;
+import { TRPCError } from '../error/TRPCError';
+import type { RootConfig } from '../rootConfig';
+import { isObject, unsetMarker } from '../utils';
+import type { TRPCRequestInfo } from './types';
+
+type ContentTypeHandler = {
+  isMatch: (opts: Request) => boolean;
+  parse: (opts: {
+    path: string;
+    req: Request;
+    searchParams: URLSearchParams;
+    config: RootConfig<any>;
+  }) => TRPCRequestInfo;
+};
+
+/**
+ * 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;
+      }
+      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;
     },
-  ) => Promise<unknown>;
+    /**
+     * Get an already stored result
+     */
+    result: (): TReturn | undefined => {
+      return value !== unsetMarker ? value : undefined;
+    },
+  };
+}
+
+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];
+
+    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;
+    });
+
+    return {
+      isBatchCall,
+      calls: paths.map((path, index) => ({
+        path,
+        getRawInput: async () => {
+          const inputs = await getInputs.read();
+          return inputs[index];
+        },
+        result: () => {
+          return getInputs.result()?.[index];
+        },
+      })),
+    };
+  },
+};
+
+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;
+    });
+    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 handlers = [
+  jsonContentTypeHandler,
+  formDataContentTypeHandler,
+  octetStreamContentTypeHandler,
+];
+
+function getContentTypeHandler(req: Request): ContentTypeHandler {
+  const handler = handlers.find((handler) => handler.isMatch(req));
+  if (handler) {
+    return handler;
+  }
+
+  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