fastify 3.4.1 → 3.7.0

package/test/request-error.test.js

@@ -126,3 +126,84 @@ test('default clientError handler ignores ECONNRESET', t => {
     client.write('\r\n\r\n')
   })
 })
+
+test('error handler binding', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.setErrorHandler(function (err, request, reply) {
+    t.strictEqual(this, fastify)
+    reply
+      .code(err.statusCode)
+      .type('application/json; charset=utf-8')
+      .send(err)
+  })
+
+  fastify.post('/', function (req, reply) {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    simulate: {
+      error: true
+    },
+    body: {
+      text: '12345678901234567890123456789012345678901234567890'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 400)
+    t.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.deepEqual(JSON.parse(res.payload), {
+      error: 'Bad Request',
+      message: 'Simulated',
+      statusCode: 400
+    })
+  })
+})
+
+test('encapsulated error handler binding', t => {
+  t.plan(7)
+
+  const fastify = Fastify()
+
+  fastify.register(function (app, opts, next) {
+    app.decorate('hello', 'world')
+    t.strictEqual(app.hello, 'world')
+    app.post('/', function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+    app.setErrorHandler(function (err, request, reply) {
+      t.strictEqual(this.hello, 'world')
+      reply
+        .code(err.statusCode)
+        .type('application/json; charset=utf-8')
+        .send(err)
+    })
+    next()
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    simulate: {
+      error: true
+    },
+    body: {
+      text: '12345678901234567890123456789012345678901234567890'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 400)
+    t.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.deepEqual(res.json(), {
+      error: 'Bad Request',
+      message: 'Simulated',
+      statusCode: 400
+    })
+    t.strictEqual(fastify.hello, undefined)
+  })
+})

package/test/route.test.js

@@ -190,6 +190,33 @@ test('invalid schema - route', t => {
   })
 })
 
+test('same route definition object on multiple prefixes', async t => {
+  t.plan(2)
+
+  const routeObject = {
+    handler: () => {},
+    method: 'GET',
+    url: '/simple'
+  }
+
+  const fastify = Fastify()
+
+  fastify.register(async function (f) {
+    f.addHook('onRoute', (routeOptions) => {
+      t.is(routeOptions.url, '/v1/simple')
+    })
+    f.route(routeObject)
+  }, { prefix: '/v1' })
+  fastify.register(async function (f) {
+    f.addHook('onRoute', (routeOptions) => {
+      t.is(routeOptions.url, '/v2/simple')
+    })
+    f.route(routeObject)
+  }, { prefix: '/v2' })
+
+  await fastify.ready()
+})
+
 test('path can be specified in place of uri', t => {
   t.plan(3)
   const fastify = Fastify()

package/test/trust-proxy.test.js

@@ -5,13 +5,17 @@ const test = t.test
 const sget = require('simple-get').concat
 const fastify = require('..')
 
-const sgetForwardedRequest = (app, forHeader, path) => {
+const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
+  const headers = {
+    'X-Forwarded-For': forHeader,
+    'X-Forwarded-Host': 'example.com'
+  }
+  if (protoHeader) {
+    headers['X-Forwarded-Proto'] = protoHeader
+  }
   sget({
     method: 'GET',
-    headers: {
-      'X-Forwarded-For': forHeader,
-      'X-Forwarded-Host': 'example.com'
-    },
+    headers: headers,
     url: 'http://localhost:' + app.server.address().port + path
   }, () => {})
 }
@@ -28,6 +32,10 @@ const testRequestValues = (t, req, options) => {
   if (options.ips) {
     t.deepEqual(req.ips, options.ips, 'gets ips from x-forwarded-for')
   }
+  if (options.protocol) {
+    t.ok(req.protocol, 'protocol is defined')
+    t.equal(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
+  }
 }
 
 test('trust proxy, not add properties to node req', (t) => {
@@ -131,3 +139,32 @@ test('trust proxy IP addresses', (t) => {
     sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs')
   })
 })
+
+test('trust proxy protocol', (t) => {
+  t.plan(13)
+  const app = fastify({
+    trustProxy: true
+  })
+  app.get('/trustproxyprotocol', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem' })
+    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+  })
+  app.get('/trustproxynoprotocol', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http' })
+    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+  })
+  app.get('/trustproxyprotocols', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor' })
+    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+  })
+
+  t.tearDown(app.close.bind(app))
+
+  app.listen(0, (err) => {
+    app.server.unref()
+    t.error(err)
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem')
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol')
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
+  })
+})

package/test/types/decorate-request-reply.test-d.ts

@@ -0,0 +1,18 @@
+import fastify from '../../fastify'
+import { expectType } from 'tsd'
+
+type TestType = void
+
+declare module '../../fastify' {
+  interface FastifyRequest {
+    testProp: TestType;
+  }
+  interface FastifyReply {
+    testProp: TestType;
+  }
+}
+
+fastify().get('/', (req, res) => {
+  expectType<TestType>(req.testProp)
+  expectType<TestType>(res.testProp)
+})

package/test/types/instance.test-d.ts

@@ -16,16 +16,17 @@ expectAssignable<FastifyInstance>(server.addSchema({
 expectType<Record<string, unknown>>(server.getSchemas())
 expectType<unknown>(server.getSchema('SchemaId'))
 
-expectType<unknown>(server.use(() => {}))
-expectType<unknown>(server.use('/foo', () => {}))
+expectAssignable<FastifyInstance>(
+  server.setErrorHandler(function (error, request, reply) {
+    expectAssignable<FastifyInstance>(this)
+  })
+)
 
-server.setErrorHandler(function (error, request, reply) {
-  expectAssignable<FastifyInstance>(this)
-})
-
-server.setErrorHandler<FastifyError>(function (error, request, reply) {
-  expectType<FastifyError>(error)
-})
+expectAssignable<FastifyInstance>(
+  server.setErrorHandler<FastifyError>(function (error, request, reply) {
+    expectType<FastifyError>(error)
+  })
+)
 
 function fastifyErrorHandler (this: FastifyInstance, error: FastifyError) {}
 server.setErrorHandler(fastifyErrorHandler)
@@ -51,6 +52,23 @@ expectError(server.setReplySerializer(serializerWithInvalidReturn))
 function invalidSchemaErrorFormatter () {}
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
+// test listen method callback
+expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {}))
+expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {}))
+expectAssignable<void>(server.listen(3000, '', (err, address) => {}))
+expectAssignable<void>(server.listen('3000', '', (err, address) => {}))
+expectAssignable<void>(server.listen(3000, (err, address) => {}))
+expectAssignable<void>(server.listen('3000', (err, address) => {}))
+
+// test listen method promise
+expectAssignable<PromiseLike<string>>(server.listen(3000))
+expectAssignable<PromiseLike<string>>(server.listen('3000'))
+expectAssignable<PromiseLike<string>>(server.listen(3000, '', 0))
+expectAssignable<PromiseLike<string>>(server.listen('3000', '', 0))
+expectAssignable<PromiseLike<string>>(server.listen(3000, ''))
+expectAssignable<PromiseLike<string>>(server.listen('3000', ''))
+
+// test listen opts objects
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000 }))
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0' }))
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }))

package/test/types/logger.test-d.ts

@@ -1,5 +1,5 @@
 import { expectType, expectError } from 'tsd'
-import fastify, { FastifyLogFn, LogLevel, FastifyLoggerInstance } from '../../fastify'
+import fastify, { FastifyLogFn, LogLevel, FastifyLoggerInstance, FastifyError } from '../../fastify'
 import { Server, IncomingMessage, ServerResponse } from 'http'
 import * as pino from 'pino'
 
@@ -85,3 +85,65 @@ const serverWithAutoInferredPino = fastify({
 })
 
 expectType<pino.Logger>(serverWithAutoInferredPino.log)
+
+const serverAutoInferredPinoPrettyBooleanOption = fastify({
+  logger: {
+    prettyPrint: true
+  }
+})
+
+expectType<FastifyLoggerInstance>(serverAutoInferredPinoPrettyBooleanOption.log)
+
+const serverAutoInferredPinoPrettyObjectOption = fastify({
+  logger: {
+    prettyPrint: {
+      translateTime: true,
+      levelFirst: false,
+      messageKey: 'msg',
+      timestampKey: 'time',
+      messageFormat: false,
+      colorize: true,
+      crlf: false,
+      errorLikeObjectKeys: ['err', 'error'],
+      errorProps: '',
+      search: 'foo == `bar`',
+      ignore: 'pid,hostname',
+      suppressFlushSyncWarning: true
+    }
+  }
+})
+
+expectType<FastifyLoggerInstance>(serverAutoInferredPinoPrettyObjectOption.log)
+
+const serverAutoInferredSerializerObjectOption = fastify({
+  logger: {
+    serializers: {
+      req (IncomingMessage) {
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          hostname: 'hostname',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (ServerResponse) {
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (FastifyError) {
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyLoggerInstance>(serverAutoInferredSerializerObjectOption.log)

package/test/types/register.test-d.ts

@@ -0,0 +1,16 @@
+import { expectAssignable, expectError } from 'tsd'
+import fastify, { FastifyInstance, FastifyPluginAsync } from '../../fastify'
+
+const testPluginOptsAsync: FastifyPluginAsync = async function (_instance, _opts) { }
+
+// Type validation
+expectError(fastify().register(testPluginOptsAsync, { prefix: 1 }))
+expectError(fastify().register(testPluginOptsAsync, { logLevel: () => ({}) }))
+expectError(fastify().register(testPluginOptsAsync, { logSerializers: () => ({}) }))
+expectError(fastify().register({}))
+
+expectAssignable<FastifyInstance>(
+  fastify().register(
+    testPluginOptsAsync, { prefix: '/example', logLevel: 'info', logSerializers: { key: (value: any) => `${value}` } }
+  )
+)

package/test/types/request.test-d.ts

@@ -53,7 +53,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RequestQuerystringDefault>(request.query)
   expectType<any>(request.id)
   expectType<FastifyLoggerInstance>(request.log)
-  expectType<RawRequestDefaultExpression['socket']>(request.connection)
+  expectType<RawRequestDefaultExpression['socket']>(request.socket)
   expectType<Error & { validation: any; validationContext: string } | undefined>(request.validationError)
 }
 

package/test/types/schema.test-d.ts

@@ -1,5 +1,6 @@
 import { expectAssignable, expectError } from 'tsd'
 import fastify, { FastifyInstance } from '../../fastify'
+import Ajv = require('ajv')
 
 const server = fastify()
 
@@ -31,6 +32,10 @@ expectAssignable<FastifyInstance>(server.get(
   () => { }
 ))
 
+expectAssignable<FastifyInstance>(server.setValidatorCompiler(({ schema }) => {
+  return new Ajv().compile(schema)
+}))
+
 expectError(server.get(
   '/unknown-schema-prop',
   {

package/test/validation-error-handling.test.js

@@ -97,6 +97,72 @@ test('should be able to use setErrorHandler specify custom validation error', t
   })
 })
 
+test('error inside custom error handler should have validationContext', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema,
+    validatorCompiler: ({ schema, method, url, httpPart }) => {
+      return function (data) {
+        return { error: new Error('this failed') }
+      }
+    }
+  }, function (req, reply) {
+    t.fail('should not be here')
+    reply.code(200).send(req.body.name)
+  })
+
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.strictEqual(error.validationContext, 'body')
+    reply.status(500).send(error)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      name: 'michelangelo',
+      work: 'artist'
+    },
+    url: '/'
+  }, () => {})
+})
+
+test('error inside custom error handler should have validationContext if specified by custom error handler', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema,
+    validatorCompiler: ({ schema, method, url, httpPart }) => {
+      return function (data) {
+        const error = new Error('this failed')
+        error.validationContext = 'customContext'
+        return { error: error }
+      }
+    }
+  }, function (req, reply) {
+    t.fail('should not be here')
+    reply.code(200).send(req.body.name)
+  })
+
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.strictEqual(error.validationContext, 'customContext')
+    reply.status(500).send(error)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      name: 'michelangelo',
+      work: 'artist'
+    },
+    url: '/'
+  }, () => {})
+})
+
 test('should be able to attach validation to request', t => {
   t.plan(3)
 

package/types/instance.d.ts

@@ -21,6 +21,7 @@ export interface FastifyInstance<
 > {
   server: RawServer;
   prefix: string;
+  version: string | undefined;
   log: Logger;
 
   addSchema(schema: unknown): FastifyInstance<RawServer, RawRequest, RawReply, Logger>;
@@ -46,10 +47,10 @@ export interface FastifyInstance<
   inject(opts: InjectOptions | string): Promise<LightMyRequestResponse>;
   inject(): LightMyRequestChain;
 
-  listen(port: number, address: string, backlog: number, callback: (err: Error, address: string) => void): void;
-  listen(port: number, address: string, callback: (err: Error, address: string) => void): void;
-  listen(port: number, callback: (err: Error, address: string) => void): void;
-  listen(port: number, address?: string, backlog?: number): Promise<string>;
+  listen(port: number | string, address: string, backlog: number, callback: (err: Error, address: string) => void): void;
+  listen(port: number | string, address: string, callback: (err: Error, address: string) => void): void;
+  listen(port: number | string, callback: (err: Error, address: string) => void): void;
+  listen(port: number | string, address?: string, backlog?: number): Promise<string>;
   listen(opts: { port: number; host?: string; backlog?: number }, callback: (err: Error, address: string) => void): void;
   listen(opts: { port: number; host?: string; backlog?: number }): Promise<string>;
 
@@ -58,13 +59,6 @@ export interface FastifyInstance<
 
   register: FastifyRegister<FastifyInstance<RawServer, RawRequest, RawReply, Logger> & PromiseLike<undefined>>;
 
-  /**
-   * This method will throw a `FST_ERR_MISSING_MIDDLEWARE` error unless support
-   * for Express-style middlewares is first enabled. Visit
-   * https://fastify.io/docs/latest/Middleware/ for more info.
-   */
-  use(...args: unknown[]): unknown;
-
   route<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault
@@ -237,14 +231,14 @@ export interface FastifyInstance<
    */
   setNotFoundHandler<RouteGeneric extends RouteGenericInterface = RouteGenericInterface>(
     handler: (request: FastifyRequest<RouteGeneric, RawServer, RawRequest>, reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric>) => void
-  ): void;
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger>;
 
   /**
    * Set a function that will be called whenever an error happens
    */
   setErrorHandler<TError extends Error = FastifyError, RouteGeneric extends RouteGenericInterface = RouteGenericInterface>(
     handler: (this: FastifyInstance<RawServer, RawRequest, RawReply, Logger>, error: TError, request: FastifyRequest<RouteGeneric, RawServer, RawRequest>, reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric>) => void
-  ): void;
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger>;
 
   /**
    * Set the schema validator for all routes.

package/types/logger.d.ts

@@ -1,3 +1,23 @@
+/*
+ * Rationale for not directly importing types from @types/pino for use in fastify interfaces:
+ * - pino does not itself provide types so the types from @types must be used.
+ * - the types from @types are unofficial and the preference is to avoid using them or requiring them as a dependency of fastify.
+ * - the goal is to provide the minimum viable type definitions necessary to use fastify's official logger, pino.
+ * - the types provided should cover the basic use cases for the majority of fastify users while also being easy to maintain.
+ * - for advanced use cases needing the full set of types, users should be directed to manually install the unofficial types with
+ *   `npm i -D @types/pino` and to supply their own logger instance as described at https://www.fastify.io/docs/latest/Logging/.
+ * - some fastify contributors have volunteered to maintain official types within pino (https://github.com/pinojs/pino/issues/910)
+ *   in which case if the proposal is followed through with then in the future fastify will be able to directly import the full
+ *   set of types rather than only duplicating and maintaining the subset chosen for providing a minimum viable logger api.
+ *
+ * Relevant discussions:
+ *
+ * https://github.com/fastify/fastify/pull/2550
+ * https://github.com/pinojs/pino/issues/910
+ * https://github.com/fastify/fastify/pull/1532
+ * https://github.com/fastify/fastify/issues/649
+ */
+
 import { FastifyError } from 'fastify-error'
 import { RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression } from './utils'
 import { FastifyRequest, RequestGenericInterface } from './request'
@@ -30,6 +50,63 @@ export interface FastifyLoggerInstance {
   child(bindings: Bindings): FastifyLoggerInstance;
 }
 
+// This interface is accurate for pino 6.3 and was copied from the following permalink:
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/72c9bd83316bd31e93ab86d64ddf598d922f33cd/types/pino/index.d.ts#L514-L567
+export interface PrettyOptions {
+  /**
+   * Translate the epoch time value into a human readable date and time string.
+   * This flag also can set the format string to apply when translating the date to human readable format.
+   * The default format is yyyy-mm-dd HH:MM:ss.l o in UTC.
+   * For a list of available pattern letters see the {@link https://www.npmjs.com/package/dateformat|dateformat documentation}.
+   */
+  translateTime?: boolean | string;
+  /**
+   * If set to true, it will print the name of the log level as the first field in the log line. Default: `false`.
+   */
+  levelFirst?: boolean;
+  /**
+   * The key in the JSON object to use as the highlighted message. Default: "msg".
+   */
+  messageKey?: string;
+  /**
+   * The key in the JSON object to use for timestamp display. Default: "time".
+   */
+  timestampKey?: string;
+  /**
+   * Format output of message, e.g. {level} - {pid} will output message: INFO - 1123 Default: `false`.
+   */
+  messageFormat?: false | string;
+  /**
+   * If set to true, will add color information to the formatted output message. Default: `false`.
+   */
+  colorize?: boolean;
+  /**
+   * Appends carriage return and line feed, instead of just a line feed, to the formatted log line.
+   */
+  crlf?: boolean;
+  /**
+   * Define the log keys that are associated with error like objects. Default: ["err", "error"]
+   */
+  errorLikeObjectKeys?: string[];
+  /**
+   *  When formatting an error object, display this list of properties.
+   *  The list should be a comma separated list of properties. Default: ''
+   */
+  errorProps?: string;
+  /**
+   * Specify a search pattern according to {@link http://jmespath.org|jmespath}
+   */
+  search?: string;
+  /**
+   * Ignore one or several keys. Example: "time,hostname"
+   */
+  ignore?: string;
+  /**
+   * Suppress warning on first synchronous flushing.
+   */
+  suppressFlushSyncWarning?: boolean;
+}
+
 /**
  * Fastify Custom Logger options. To enable configuration of all Pino options,
  * refer to this example:
@@ -41,24 +118,27 @@ export interface FastifyLoggerOptions<
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>
 > {
   serializers?: {
-    req: (req: RawRequest) => {
-      method: string;
-      url: string;
-      version: string;
-      hostname: string;
-      remoteAddress: string;
-      remotePort: number;
+    req?: (req: RawRequest) => {
+      method?: string;
+      url?: string;
+      version?: string;
+      hostname?: string;
+      remoteAddress?: string;
+      remotePort?: number;
+      [key: string]: unknown;
     };
-    err: (err: FastifyError) => {
+    err?: (err: FastifyError) => {
       type: string;
       message: string;
       stack: string;
-      [key: string]: any;
+      [key: string]: unknown;
     };
-    res: (res: RawReply) => {
+    res?: (res: RawReply) => {
       statusCode: string | number;
+      [key: string]: unknown;
     };
   };
   level?: string;
   genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface>(req: FastifyRequest<RequestGeneric, RawServer, RawRequest>) => string;
+  prettyPrint?: boolean | PrettyOptions;
 }

package/types/register.d.ts

@@ -26,4 +26,5 @@ export type FastifyRegisterOptions<Options> = (RegisterOptions & Options) | (()
 interface RegisterOptions {
   prefix?: string;
   logLevel?: LogLevel;
+  logSerializers?: Record<string, (value: any) => string>;
 }

package/types/request.d.ts

@@ -22,20 +22,29 @@ export interface FastifyRequest<
   params: RouteGeneric['Params'];
   raw: RawRequest;
   query: RouteGeneric['Querystring'];
-  headers: RawRequest['headers'] & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
   log: FastifyLoggerInstance;
   body: RouteGeneric['Body'];
-  ip: string;
-  ips?: string[];
-  hostname: string;
-  url: string;
-  method: string;
-  routerPath: string;
-  routerMethod: string;
-  is404: boolean;
+
   /** in order for this to be used the user should ensure they have set the attachValidation option. */
   validationError?: Error & { validation: any; validationContext: string };
 
-  // `connection` is a deprecated alias for `socket` and doesn't exist in `Http2ServerRequest`
-  connection: RawRequest['socket'];
+  /**
+   * @deprecated Use `raw` property
+   */
+  readonly req: RawRequest;
+  readonly headers: RawRequest['headers'] & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
+  readonly ip: string;
+  readonly ips?: string[];
+  readonly hostname: string;
+  readonly url: string;
+  readonly protocol: 'http' | 'https';
+  readonly method: string;
+  readonly routerPath: string;
+  readonly routerMethod: string;
+  readonly is404: boolean;
+  readonly socket: RawRequest['socket'];
+
+  // Prefer `socket` over deprecated `connection` property in node 13.0.0 or higher
+  // @deprecated
+  readonly connection: RawRequest['socket'];
 }