@trpc/server 11.0.0-next.92 → 11.0.0-rc.330

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -1,12 +1,27 @@
-import { AnyRouter } from '../../core';
-import {
-  getBatchStreamFormatter,
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+// @trpc/server
+
+import type { AnyRouter } from '../../@trpc/server';
+import type {
   HTTPRequest,
+  HTTPResponse,
   ResolveHTTPRequestOptionsContextFn,
-} from '../../http';
-import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
-import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
-import { FetchHandlerOptions } from './types';
+  ResponseChunk,
+} from '../../@trpc/server/http';
+import {
+  getBatchStreamFormatter,
+  resolveHTTPResponse,
+  toURL,
+} from '../../@trpc/server/http';
+import type { FetchHandlerOptions } from './types';
 
 export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
   FetchHandlerOptions<TRouter> & {
@@ -14,6 +29,13 @@ export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
     endpoint: string;
   };
 
+const trimSlashes = (path: string): string => {
+  path = path.startsWith('/') ? path.slice(1) : path;
+  path = path.endsWith('/') ? path.slice(0, -1) : path;
+
+  return path;
+};
+
 export async function fetchRequestHandler<TRouter extends AnyRouter>(
   opts: FetchHandlerRequestOptions<TRouter>,
 ): Promise<Response> {
@@ -25,8 +47,12 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
     return opts.createContext?.({ req: opts.req, resHeaders, ...innerOpts });
   };
 
-  const url = new URL(opts.req.url);
-  const path = url.pathname.slice(opts.endpoint.length + 1);
+  const url = toURL(opts.req.url);
+
+  const pathname = trimSlashes(url.pathname);
+  const endpoint = trimSlashes(opts.endpoint);
+  const path = trimSlashes(pathname.slice(endpoint.length));
+
   const req: HTTPRequest = {
     query: url.searchParams,
     method: opts.req.method,
@@ -92,12 +118,10 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
   };
 
   resolveHTTPResponse({
+    ...opts,
     req,
     createContext,
     path,
-    router: opts.router,
-    batching: opts.batching,
-    responseMeta: opts.responseMeta,
     onError(o) {
       opts?.onError?.({ ...o, req: opts.req });
     },

package/src/adapters/fetch/types.ts

@@ -1,5 +1,19 @@
-import { AnyRouter, inferRouterContext } from '../../core';
-import { HTTPBaseHandlerOptions, TRPCRequestInfo } from '../../http';
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+// @trpc/server
+import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
+// @trpc/server/http
+import type {
+  HTTPBaseHandlerOptions,
+  TRPCRequestInfo,
+} from '../../@trpc/server/http';
 
 export type FetchCreateContextFnOptions = {
   req: Request;
@@ -15,13 +29,13 @@ export type FetchCreateContextOption<TRouter extends AnyRouter> =
   unknown extends inferRouterContext<TRouter>
     ? {
         /**
-         * @link https://trpc.io/docs/context
+         * @link https://trpc.io/docs/v11/context
          **/
         createContext?: FetchCreateContextFn<TRouter>;
       }
     : {
         /**
-         * @link https://trpc.io/docs/context
+         * @link https://trpc.io/docs/v11/context
          **/
         createContext: FetchCreateContextFn<TRouter>;
       };

package/src/adapters/next-app-dir/formDataToObject.ts

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+function set(
+  obj: Record<string, any>,
+  path: string[] | string,
+  value: unknown,
+): void {
+  if (typeof path === 'string') {
+    path = path.split(/[\.\[\]]/).filter(Boolean);
+  }
+
+  if (path.length > 1) {
+    const p = path.shift()!;
+    const isArrayIndex = /^\d+$/.test(path[0]!);
+    obj[p] = obj[p] || (isArrayIndex ? [] : {});
+    set(obj[p], path, value);
+    return;
+  }
+  const p = path[0]!;
+  if (obj[p] === undefined) {
+    obj[p] = value;
+  } else if (Array.isArray(obj[p])) {
+    obj[p].push(value);
+  } else {
+    obj[p] = [obj[p], value];
+  }
+}
+
+export function formDataToObject(formData: FormData) {
+  const obj: Record<string, unknown> = {};
+
+  for (const [key, value] of formData.entries()) {
+    set(obj, key, value);
+  }
+
+  return obj;
+}

package/src/adapters/next-app-dir/nextAppDirCaller.ts

@@ -0,0 +1,129 @@
+import { getTRPCErrorFromUnknown, TRPCError } from '../../@trpc/server';
+// FIXME: fix lint rule, this is ok
+// eslint-disable-next-line no-restricted-imports
+import type { ErrorHandlerOptions } from '../../unstable-core-do-not-import/procedure';
+// FIXME: fix lint rule, this is ok
+// eslint-disable-next-line no-restricted-imports
+import type { CallerOverride } from '../../unstable-core-do-not-import/procedureBuilder';
+// FIXME: fix lint rule, this is ok
+// eslint-disable-next-line no-restricted-imports
+import type {
+  MaybePromise,
+  Simplify,
+} from '../../unstable-core-do-not-import/types';
+import { formDataToObject } from './formDataToObject';
+import { TRPCRedirectError } from './redirect';
+import { rethrowNextErrors } from './rethrowNextErrors';
+
+type ContextCallback<TContext> = object extends TContext
+  ? {
+      createContext?: () => MaybePromise<TContext>;
+    }
+  : {
+      createContext: () => MaybePromise<TContext>;
+    };
+
+/**
+ * Create a caller that works with Next.js React Server Components & Server Actions
+ */
+export function nextAppDirCaller<TContext>(
+  config: Simplify<
+    {
+      /**
+       * Transform form data to a `Record` before passing it to the procedure
+       * @default true
+       */
+      normalizeFormData?: boolean;
+      /**
+       * Called when an error occurs in the handler
+       */
+      onError?: (opts: ErrorHandlerOptions<TContext>) => void;
+    } & ContextCallback<TContext>
+  >,
+): CallerOverride<TContext> {
+  const {
+    normalizeFormData = true,
+
+    // rethrowNextErrors = true
+  } = config;
+  const createContext = async (): Promise<TContext> => {
+    return config?.createContext?.() ?? ({} as TContext);
+  };
+  return async (opts) => {
+    const ctx: TContext = await createContext().catch((cause) => {
+      const error = new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to create context',
+        cause,
+      });
+
+      throw error;
+    });
+
+    const handleError = (cause: unknown) => {
+      const error = getTRPCErrorFromUnknown(cause);
+
+      config.onError?.({
+        ctx,
+        error,
+        input: opts.args[0],
+        path: '',
+        type: opts._def.type,
+      });
+
+      rethrowNextErrors(error);
+
+      throw error;
+    };
+    switch (opts._def.type) {
+      case 'mutation': {
+        /**
+         * When you wrap an action with useFormState, it gets an extra argument as its first argument.
+         * The submitted form data is therefore its second argument instead of its first as it would usually be.
+         * The new first argument that gets added is the current state of the form.
+         * @see https://react.dev/reference/react-dom/hooks/useFormState#my-action-can-no-longer-read-the-submitted-form-data
+         */
+        let input = opts.args.length === 1 ? opts.args[0] : opts.args[1];
+        if (normalizeFormData && input instanceof FormData) {
+          input = formDataToObject(input);
+        }
+
+        return await opts
+          .invoke({
+            type: opts._def.type,
+            ctx,
+            getRawInput: async () => input,
+            path: '',
+            input,
+          })
+          .then((data) => {
+            if (data instanceof TRPCRedirectError) throw data;
+            return data;
+          })
+          .catch(handleError);
+      }
+      case 'query': {
+        const input = opts.args[0];
+        return await opts
+          .invoke({
+            type: opts._def.type,
+            ctx,
+            getRawInput: async () => input,
+            path: '',
+            input,
+          })
+          .then((data) => {
+            if (data instanceof TRPCRedirectError) throw data;
+            return data;
+          })
+          .catch(handleError);
+      }
+      default: {
+        throw new TRPCError({
+          code: 'NOT_IMPLEMENTED',
+          message: `Not implemented for type ${opts._def.type}`,
+        });
+      }
+    }
+  };
+}

package/src/adapters/next-app-dir/notFound.ts

@@ -0,0 +1,12 @@
+import type { notFound as __notFound } from 'next/navigation';
+import { TRPCError } from '../../@trpc/server';
+
+/**
+ * Like `next/navigation`'s `notFound()` but throws a `TRPCError` that later will be handled by Next.js
+ * @public
+ */
+export const notFound: typeof __notFound = () => {
+  throw new TRPCError({
+    code: 'NOT_FOUND',
+  });
+};

package/src/adapters/next-app-dir/redirect.ts

@@ -0,0 +1,30 @@
+import type { RedirectType } from 'next/navigation';
+import { TRPCError } from '../../@trpc/server';
+
+/**
+ * @internal
+ */
+export class TRPCRedirectError extends TRPCError {
+  public readonly args;
+  constructor(url: URL | string, redirectType?: RedirectType) {
+    super({
+      // TODO(?): This should maybe a custom error code
+      code: 'UNPROCESSABLE_CONTENT',
+      message: `Redirect error to "${url}" that will be handled by Next.js`,
+    });
+
+    this.args = [url.toString(), redirectType] as const;
+  }
+}
+
+/**
+ * Like `next/navigation`'s `redirect()` but throws a `TRPCError` that later will be handled by Next.js
+ * This provides better typesafety than the `next/navigation`'s `redirect()` since the action continues
+ * to execute on the frontend even if Next's `redirect()` has a return type of `never`.
+ * @public
+ * @remark You should only use this if you're also using `nextAppDirCaller`.
+ */
+export const redirect = (url: URL | string, redirectType?: RedirectType) => {
+  // We rethrow this internally so the returntype on the client is undefined.
+  return new TRPCRedirectError(url, redirectType) as unknown as undefined;
+};

package/src/adapters/next-app-dir/rethrowNextErrors.ts

@@ -0,0 +1,25 @@
+import { isNotFoundError } from 'next/dist/client/components/not-found';
+import { isRedirectError } from 'next/dist/client/components/redirect';
+import {
+  notFound as __notFound,
+  redirect as __redirect,
+} from 'next/navigation';
+import type { TRPCError } from '../../@trpc/server';
+import { TRPCRedirectError } from './redirect';
+
+/**
+ * Rethrow errors that should be handled by Next.js
+ */
+
+export const rethrowNextErrors = (error: TRPCError) => {
+  if (error.code === 'NOT_FOUND') {
+    __notFound();
+  }
+  if (error instanceof TRPCRedirectError) {
+    __redirect(...error.args);
+  }
+  const { cause } = error;
+  if (isRedirectError(cause) || isNotFoundError(cause)) {
+    throw error.cause;
+  }
+};

package/src/adapters/next-app-dir.ts

@@ -0,0 +1,3 @@
+export { nextAppDirCaller as experimental_nextAppDirCaller } from './next-app-dir/nextAppDirCaller';
+export { redirect as experimental_redirect } from './next-app-dir/redirect';
+export { notFound as experimental_notFound } from './next-app-dir/notFound';

package/src/adapters/next.ts

@@ -1,32 +1,43 @@
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
+// @trpc/server
+import type { AnyRouter } from '../@trpc/server';
+// @trpc/server
+import { getErrorShape, TRPCError } from '../@trpc/server';
 import type {
-  NextApiHandler,
-  NextApiRequest,
-  NextApiResponse,
-} from 'next/types';
-import { AnyRouter } from '../core';
-import { TRPCError } from '../error/TRPCError';
-import { getErrorShape } from '../shared/getErrorShape';
-import {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
-  nodeHTTPRequestHandler,
 } from './node-http';
+import { nodeHTTPRequestHandler } from './node-http';
 
 export type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<
   NextApiRequest,
   NextApiResponse
 >;
 
+/**
+ * Preventing "TypeScript where it's tough not to get "The inferred type of 'xxxx' cannot be named without a reference to [...]"
+ */
+export type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
+
 export function createNextApiHandler<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, NextApiRequest, NextApiResponse>,
 ): NextApiHandler {
   return async (req, res) => {
     function getPath(): string | null {
-      if (typeof req.query.trpc === 'string') {
-        return req.query.trpc;
+      if (typeof req.query['trpc'] === 'string') {
+        return req.query['trpc'];
       }
-      if (Array.isArray(req.query.trpc)) {
-        return req.query.trpc.join('/');
+      if (Array.isArray(req.query['trpc'])) {
+        return req.query['trpc'].join('/');
       }
       return null;
     }
@@ -54,7 +65,12 @@ export function createNextApiHandler<TRouter extends AnyRouter>(
     }
 
     await nodeHTTPRequestHandler({
-      ...opts,
+      // FIXME: no typecasting should be needed here
+      ...(opts as NodeHTTPHandlerOptions<
+        AnyRouter,
+        NextApiRequest,
+        NextApiResponse
+      >),
       req,
       res,
       path,

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

@@ -8,7 +8,7 @@
  */
 
 /**
- * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-node/upload/fileUploadHandler.ts
+ * @link https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-node/upload/fileUploadHandler.ts
  */
 import { randomBytes } from 'node:crypto';
 import { createReadStream, createWriteStream, statSync } from 'node:fs';
@@ -18,7 +18,8 @@ import { basename, dirname, extname, resolve as resolvePath } from 'node:path';
 import { finished, Readable } from 'node:stream';
 import { promisify } from 'node:util';
 import { streamSlice } from './streamSlice';
-import { MaxPartSizeExceededError, UploadHandler } from './uploadHandler';
+import type { UploadHandler } from './uploadHandler';
+import { MaxPartSizeExceededError } from './uploadHandler';
 
 export async function readableStreamToString(
   stream: ReadableStream<Uint8Array>,
@@ -183,6 +184,12 @@ export function createFileUploadHandler({
     return new NodeOnDiskFile(filepath, contentType);
   };
 }
+type NodeJSReadableStreamEsque = {
+  on(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): NodeJSReadableStreamEsque;
+};
 
 export class NodeOnDiskFile {
   name: string;
@@ -245,8 +252,8 @@ export class NodeOnDiskFile {
   }
 
   stream(): ReadableStream<any>;
-  stream(): NodeJS.ReadableStream;
-  stream(): NodeJS.ReadableStream | ReadableStream<any> {
+  stream(): NodeJSReadableStreamEsque;
+  stream(): NodeJSReadableStreamEsque | ReadableStream<any> {
     let stream: Readable = createReadStream(this.filepath);
     if (this.slicer) {
       stream = stream.pipe(streamSlice(this.slicer.start, this.slicer.end));

package/src/adapters/node-http/content-type/form-data/index.ts

@@ -6,20 +6,19 @@
  */
 
 /**
- * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/formData.ts
+ * @link https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/formData.ts
  */
 import * as fs from 'fs/promises';
 import { Readable } from 'node:stream';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore the type definitions for this package are borked
 import { streamMultipart } from '@web3-storage/multipart-parser';
-import { CombinedDataTransformer } from '../../../../transformer';
+// @trpc/server
 import { createNodeHTTPContentTypeHandler } from '../../internals/contentType';
-import { NodeHTTPRequest } from '../../types';
+import type { NodeHTTPRequest } from '../../types';
 import { NodeOnDiskFile } from './fileUploadHandler';
-import {
-  MaxBodySizeExceededError,
-  UploadHandler,
-  UploadHandlerPart,
-} from './uploadHandler';
+import type { UploadHandler, UploadHandlerPart } from './uploadHandler';
+import { MaxBodySizeExceededError } from './uploadHandler';
 
 const utfTextDecoder = new TextDecoder('utf-8');
 
@@ -31,7 +30,7 @@ const utfTextDecoder = new TextDecoder('utf-8');
  * @param uploadHandler A function that handles file uploads and returns a value to be used in the request body. If uploaded to disk, the returned value is a NodeOnDiskFile. If uploaded to memory, the returned value is a File.
  * @param maxBodySize The maximum size of the request body in bytes. Defaults to Infinity.
  *
- * @see https://remix.run/utils/parse-multipart-form-data
+ * @link https://remix.run/utils/parse-multipart-form-data
  */
 async function parseMultipartFormData(
   request: NodeHTTPRequest,
@@ -136,8 +135,7 @@ export const nodeHTTPFormDataContentTypeHandler =
           0: undefined,
         };
       }
-      const transformer = opts.router._def._config
-        .transformer as CombinedDataTransformer;
+      const transformer = opts.router._def._config.transformer;
 
       const deserializedInput = transformer.input.deserialize(
         JSON.parse(unparsedInput),
@@ -148,16 +146,18 @@ export const nodeHTTPFormDataContentTypeHandler =
     },
   });
 
-export { parseMultipartFormData as experimental_parseMultipartFormData };
-export { createMemoryUploadHandler as experimental_createMemoryUploadHandler } from './memoryUploadHandler';
 export {
-  createFileUploadHandler as experimental_createFileUploadHandler,
   NodeOnDiskFile as experimental_NodeOnDiskFile,
+  createFileUploadHandler as experimental_createFileUploadHandler,
 } from './fileUploadHandler';
+export { createMemoryUploadHandler as experimental_createMemoryUploadHandler } from './memoryUploadHandler';
 export {
-  composeUploadHandlers as experimental_composeUploadHandlers,
-  MaxPartSizeExceededError,
   MaxBodySizeExceededError,
+  MaxPartSizeExceededError,
+  composeUploadHandlers as experimental_composeUploadHandlers,
+  type UploadHandler,
 } from './uploadHandler';
-export { type UploadHandler } from './uploadHandler';
-export { isMultipartFormDataRequest as experimental_isMultipartFormDataRequest };
+export {
+  isMultipartFormDataRequest as experimental_isMultipartFormDataRequest,
+  parseMultipartFormData as experimental_parseMultipartFormData,
+};

package/src/adapters/node-http/content-type/form-data/memoryUploadHandler.ts

@@ -6,9 +6,10 @@
  */
 
 /**
- * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/upload/memoryUploadHandler.ts
+ * @link https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/upload/memoryUploadHandler.ts
  */
-import { MaxPartSizeExceededError, UploadHandler } from './uploadHandler';
+import type { UploadHandler } from './uploadHandler';
+import { MaxPartSizeExceededError } from './uploadHandler';
 
 export type MemoryUploadHandlerFilterArgs = {
   filename?: string;

package/src/adapters/node-http/content-type/form-data/streamSlice.ts

@@ -1,4 +1,5 @@
-import { Transform, TransformCallback } from 'node:stream';
+import type { TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
 
 class SliceStream extends Transform {
   private indexOffset = 0;
@@ -9,7 +10,11 @@ class SliceStream extends Transform {
     super();
   }
 
-  _transform(chunk: any, _: BufferEncoding, done: TransformCallback): void {
+  override _transform(
+    chunk: any,
+    _: BufferEncoding,
+    done: TransformCallback,
+  ): void {
     this.indexOffset += chunk.length;
 
     if (!this.emitUp && this.indexOffset >= this.startIndex) {

package/src/adapters/node-http/content-type/form-data/uploadHandler.ts

@@ -1,7 +1,7 @@
-import { NodeOnDiskFile } from './fileUploadHandler';
+import type { NodeOnDiskFile } from './fileUploadHandler';
 
 /**
- * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/formData.ts
+ * @link https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/formData.ts
  */
 export type UploadHandlerPart = {
   name: string;

package/src/adapters/node-http/content-type/json/getPostBody.ts

@@ -1,6 +1,7 @@
-import { TRPCError } from '../../../../error/TRPCError';
-import { BodyResult } from '../../../../http/contentType';
-import { NodeHTTPRequest } from '../../types';
+// @trpc/server
+import { TRPCError } from '../../../../@trpc/server';
+import type { BodyResult } from '../../../../@trpc/server/http';
+import type { NodeHTTPRequest } from '../../types';
 
 export async function getPostBody(opts: {
   req: NodeHTTPRequest;
@@ -8,6 +9,22 @@ export async function getPostBody(opts: {
 }): Promise<BodyResult> {
   const { req, maxBodySize = Infinity } = opts;
   return new Promise((resolve) => {
+    if (
+      !req.headers['content-type']?.startsWith('application/json') &&
+      (!req.method ||
+        (req.method !== 'GET' &&
+          req.method !== 'OPTIONS' &&
+          req.method !== 'HEAD'))
+    ) {
+      resolve({
+        ok: false,
+        error: new TRPCError({
+          code: 'UNSUPPORTED_MEDIA_TYPE',
+          message: 'Invalid Content-Type header (expected application/json)',
+        }),
+      });
+      return;
+    }
     if ('body' in req) {
       resolve({
         ok: true,

package/src/adapters/node-http/content-type/json/index.ts

@@ -1,4 +1,4 @@
-import { getJsonContentTypeInputs } from '../../../../http/contentType';
+import { getJsonContentTypeInputs } from '../../../../@trpc/server/http';
 import { createNodeHTTPContentTypeHandler } from '../../internals/contentType';
 import { getPostBody } from './getPostBody';
 

package/src/adapters/node-http/internals/contentType.ts

@@ -1,6 +1,8 @@
-import { AnyRouter } from '../../../core';
-import { BaseContentTypeHandler } from '../../../http/contentType';
-import {
+// @trpc/server
+import type { AnyRouter } from '../../../@trpc/server';
+// @trpc/server/http
+import type { BaseContentTypeHandler } from '../../../@trpc/server/http';
+import type {
   NodeHTTPRequest,
   NodeHTTPRequestHandlerOptions,
   NodeHTTPResponse,