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

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

@@ -9,7 +9,12 @@
  */
 import type * as http from 'http';
 // @trpc/server
-import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+  WrapCreateContext,
+} from '../../@trpc/server';
 // @trpc/server/http
 import type {
   HTTPBaseHandlerOptions,
@@ -17,7 +22,6 @@ import type {
 } from '../../@trpc/server/http';
 // eslint-disable-next-line no-restricted-imports
 import type { MaybePromise } from '../../unstable-core-do-not-import';
-import type { NodeHTTPContentTypeHandler } from './internals/contentType';
 
 interface ParsedQs {
   [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
@@ -39,23 +43,14 @@ export type NodeHTTPResponse = http.ServerResponse & {
   flush?: () => void;
 };
 
-export type NodeHTTPCreateContextOption<
+export type NodeHTTPConditionCreateContextOption<
   TRouter extends AnyRouter,
   TRequest,
   TResponse,
-> = object extends inferRouterContext<TRouter>
-  ? {
-      /**
-       * @link https://trpc.io/docs/v11/context
-       **/
-      createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
-    }
-  : {
-      /**
-       * @link https://trpc.io/docs/v11/context
-       **/
-      createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
-    };
+> = CreateContextCallback<
+  inferRouterContext<TRouter>,
+  NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>
+>;
 
 /**
  * @internal
@@ -65,45 +60,50 @@ 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,
-> = 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;
-    experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<
-      TRequest,
-      TResponse
-    >[];
-  };
+> = CoreNodeHTTPHandlerOptions<TRouter, TRequest, TResponse> &
+  NodeHTTPConditionCreateContextOption<TRouter, TRequest, TResponse>;
 
+// Internal user
 export type NodeHTTPRequestHandlerOptions<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
-> = {
-  req: TRequest;
-  res: TResponse;
-  path: string;
-} & NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>;
+> = CoreNodeHTTPHandlerOptions<TRouter, TRequest, TResponse> &
+  WrapCreateContext<NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>> & {
+    req: TRequest;
+    res: TResponse;
+    path: string;
+  };
 
 export type NodeHTTPCreateContextFnOptions<TRequest, TResponse> = {
   req: TRequest;

package/src/adapters/standalone.ts

@@ -37,8 +37,7 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
     const path = url.pathname.slice(1);
 
     await nodeHTTPRequestHandler({
-      // FIXME: no typecasting should be needed here
-      ...(opts as CreateHTTPHandlerOptions<AnyRouter>),
+      ...opts,
       req,
       res,
       path,

package/src/adapters/ws.ts

@@ -1,6 +1,10 @@
 import type { IncomingMessage } from 'http';
 import type ws from 'ws';
-import type { AnyRouter, inferRouterContext } from '../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../@trpc/server';
 import {
   callProcedure,
   getErrorShape,
@@ -46,19 +50,10 @@ export type CreateWSSContextFn<TRouter extends AnyRouter> = (
 
 export type WSConnectionHandlerOptions<TRouter extends AnyRouter> =
   BaseHandlerOptions<TRouter, IncomingMessage> &
-    (object extends inferRouterContext<TRouter>
-      ? {
-          /**
-           * @link https://trpc.io/docs/v11/context
-           **/
-          createContext?: CreateWSSContextFn<TRouter>;
-        }
-      : {
-          /**
-           * @link https://trpc.io/docs/v11/context
-           **/
-          createContext: CreateWSSContextFn<TRouter>;
-        });
+    CreateContextCallback<
+      inferRouterContext<TRouter>,
+      CreateWSSContextFn<TRouter>
+    >;
 
 /**
  * Web socket server handler

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

@@ -0,0 +1,37 @@
+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/contentType.ts

@@ -1,16 +1,4 @@
-/* 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>>;
+import type { TRPCError } from '../error/TRPCError';
 
 export type BodyResult =
   | {
@@ -24,76 +12,13 @@ export type BodyResult =
   | { 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;
+  name: string;
+  isMatch(headers: Headers): boolean;
+  getInputs: (
+    opts: TOptions,
+    info: {
+      isBatchCall: boolean;
+      batch: number;
+    },
+  ) => Promise<unknown>;
 };

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

@@ -24,6 +24,5 @@ export type {
 
 export { getBatchStreamFormatter } from './batchStreamFormatter';
 export type { BaseContentTypeHandler, BodyResult } from './contentType';
-export { getJsonContentTypeInputs } from './contentType';
 
 export { toURL } from './toURL';

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

@@ -9,9 +9,6 @@ import type {
 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,
@@ -31,10 +28,6 @@ const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
   POST: 'mutation',
 };
 
-const fallbackContentTypeHandler = {
-  getInputs: getJsonContentTypeInputs,
-};
-
 type PartialBy<TBaseType, TKey extends keyof TBaseType> = Omit<
   TBaseType,
   TKey
@@ -48,9 +41,8 @@ interface ResolveHTTPRequestOptions<
   createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
   req: TRequest;
   path: string;
-  error?: Maybe<TRPCError>;
-  contentTypeHandler?: BaseContentTypeHandler<any>;
-  preprocessedBody?: boolean;
+  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
@@ -231,8 +223,6 @@ export async function resolveHTTPResponse<
     unstable_onChunk?.([-1, '']);
     return headResponse;
   }
-  const contentTypeHandler =
-    opts.contentTypeHandler ?? fallbackContentTypeHandler;
   const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
   const allowMethodOverride = opts.allowMethodOverride ?? false;
 
@@ -249,9 +239,6 @@ export async function resolveHTTPResponse<
     req.headers['trpc-batch-mode'] === 'stream';
 
   try {
-    if (opts.error) {
-      throw opts.error;
-    }
     if (isBatchCall && !allowBatching) {
       throw new TRPCError({
         code: 'BAD_REQUEST',
@@ -272,22 +259,14 @@ export async function resolveHTTPResponse<
       });
     }
 
-    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) => ({
+      calls: paths.map((path) => ({
         path,
         type,
-        input: inputs[idx] ?? undefined,
       })),
     };
     ctx = await opts.createContext({ info });
@@ -297,12 +276,25 @@ export async function resolveHTTPResponse<
     const promises: Promise<
       TRPCResponse<unknown, inferRouterError<TRouter>>
     >[] = paths.map(async (path, index) => {
-      const input = inputs[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: async () => input,
+          getRawInput: getRawInput,
           ctx,
           type,
           allowMethodOverride,
@@ -316,6 +308,14 @@ export async function resolveHTTPResponse<
         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,
@@ -410,7 +410,10 @@ export async function resolveHTTPResponse<
         unstable_onChunk([index, body]);
       } catch (cause) {
         const path = paths[index];
-        const input = inputs[index];
+        const input = await opts.getInput({
+          isBatchCall,
+          batch: index,
+        });
         const { body } = caughtErrorToData(cause, {
           opts,
           ctx,

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

@@ -47,7 +47,6 @@ export interface HTTPRequest {
   method: string;
   query: URLSearchParams;
   headers: HTTPHeaders;
-  body: unknown;
 }
 
 /**
@@ -66,7 +65,6 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
 /** @internal */
 export type ProcedureCall = {
   type: ProcedureType;
-  input?: unknown;
   path: string;
 };
 

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

@@ -76,3 +76,34 @@ export type AnyRootTypes = CreateRootTypes<{
   errorShape: any;
   transformer: any;
 }>;
+
+type PartialIf<TCondition extends boolean, TType> = TCondition extends true
+  ? Partial<TType>
+  : TType;
+
+/**
+ * Adds a `createContext` option with a given callback function
+ * If context is the default value, then the `createContext` option is optional
+ */
+export type CreateContextCallback<
+  TContext,
+  TFunction extends (...args: any[]) => any,
+> = PartialIf<
+  object extends TContext ? true : false,
+  {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: TFunction;
+  }
+>;
+
+/**
+ * @internal
+ */
+export type WrapCreateContext<TFunction extends (...args: any[]) => any> = {
+  /**
+   * @link https://trpc.io/docs/v11/context
+   **/
+  createContext?: TFunction;
+};

package/dist/adapters/node-http/content-type/form-data/fileUploadHandler.d.ts

@@ -1,73 +0,0 @@
-/// <reference types="node" />
-import type { UploadHandler } from './uploadHandler';
-export declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
-export type FileUploadHandlerFilterArgs = {
-    filename: string;
-    contentType: string;
-    name: string;
-};
-export type FileUploadHandlerPathResolverArgs = {
-    filename: string;
-    contentType: string;
-    name: string;
-};
-/**
- * Chooses the path of the file to be uploaded. If a string is not
- * returned the file will not be written.
- */
-export type FileUploadHandlerPathResolver = (args: FileUploadHandlerPathResolverArgs) => string | undefined;
-export type FileUploadHandlerOptions = {
-    /**
-     * Avoid file conflicts by appending a count on the end of the filename
-     * if it already exists on disk. Defaults to `true`.
-     */
-    avoidFileConflicts?: boolean;
-    /**
-     * The directory to write the upload.
-     */
-    directory?: FileUploadHandlerPathResolver | string;
-    /**
-     * The name of the file in the directory. Can be a relative path, the directory
-     * structure will be created if it does not exist.
-     */
-    file?: FileUploadHandlerPathResolver;
-    /**
-     * The maximum upload size allowed. If the size is exceeded an error will be thrown.
-     * Defaults to 3000000B (3MB).
-     */
-    maxPartSize?: number;
-    /**
-     *
-     * @param filename
-     * @param contentType
-     * @param name
-     */
-    filter?(args: FileUploadHandlerFilterArgs): Promise<boolean> | boolean;
-};
-export declare function createFileUploadHandler({ directory, avoidFileConflicts, file, filter, maxPartSize, }?: FileUploadHandlerOptions): UploadHandler;
-type NodeJSReadableStreamEsque = {
-    on(eventName: string | symbol, listener: (...args: any[]) => void): NodeJSReadableStreamEsque;
-};
-export declare class NodeOnDiskFile {
-    private filepath;
-    type: string;
-    private slicer?;
-    name: string;
-    lastModified: number;
-    webkitRelativePath: string;
-    constructor(filepath: string, type: string, slicer?: {
-        start: number;
-        end: number;
-    } | undefined);
-    get size(): number;
-    slice(start?: number, end?: number, type?: string): NodeOnDiskFile;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    stream(): ReadableStream<any>;
-    stream(): NodeJSReadableStreamEsque;
-    text(): Promise<string>;
-    readonly [Symbol.toStringTag] = "File";
-    remove(): Promise<void>;
-    getFilePath(): string;
-}
-export {};
-//# sourceMappingURL=fileUploadHandler.d.ts.map

package/dist/adapters/node-http/content-type/form-data/fileUploadHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fileUploadHandler.d.ts","sourceRoot":"","sources":["../../../../../src/adapters/node-http/content-type/form-data/fileUploadHandler.ts"],"names":[],"mappings":";AAoBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,QAAQ,CAAC,EAAE,cAAc,mBAoB1B;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAC1C,IAAI,EAAE,iCAAiC,KACpC,MAAM,GAAG,SAAS,CAAC;AAExB,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,6BAA6B,GAAG,MAAM,CAAC;IACnD;;;OAGG;IACH,IAAI,CAAC,EAAE,6BAA6B,CAAC;IACrC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,MAAM,CAAC,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACxE,CAAC;AA4BF,wBAAgB,uBAAuB,CAAC,EACtC,SAAoB,EACpB,kBAAyB,EACzB,IAA8B,EAC9B,MAAM,EACN,WAAqB,GACtB,GAAE,wBAA6B,GAAG,aAAa,CAyD/C;AACD,KAAK,yBAAyB,GAAG;IAC/B,EAAE,CACA,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GACjC,yBAAyB,CAAC;CAC9B,CAAC;AAEF,qBAAa,cAAc;IAMvB,OAAO,CAAC,QAAQ;IACT,IAAI,EAAE,MAAM;IACnB,OAAO,CAAC,MAAM,CAAC;IAPjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,SAAK;IACjB,kBAAkB,SAAM;gBAGd,QAAQ,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACX,MAAM,CAAC;eAAW,MAAM;aAAO,MAAM;iBAAE;IAKjD,IAAI,IAAI,IAAI,MAAM,CASjB;IAED,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,cAAc;IAkB5D,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAkBzC,MAAM,IAAI,cAAc,CAAC,GAAG,CAAC;IAC7B,MAAM,IAAI,yBAAyB;IAU7B,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAI7B,SAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU;IAE9C,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAGvB,WAAW,IAAI,MAAM;CAGtB"}