feat: add request.routeOptions object

docs/Reference/Request.md

@@ -42,6 +42,13 @@ Request is a core Fastify object containing the following fields:
   handling the request
 - `routeConfig` - The route [`config`](./Routes.md#routes-config) 
   object.
+- `routeOptions` - The route [`option`](./Routes.md#routes-options) object
+  - `bodyLimit` - either get server limit or route limit
+  - `method` - get http method
+  - `url` - get the path of the URL to match this route
+  - `attachValidation` - attach `validationError` to request, if there is a schema
+  - `logLevel` - get log level for this route.
+  - `version` -  a semver compatible string that defined the version of the endpoint
 - [.getValidationFunction(schema | httpPart)](#getvalidationfunction) - 
   Returns a validation function for the specified schema or http part,
   if any of either are set or cached.
@@ -90,7 +97,13 @@ fastify.post('/:params', options, function (request, reply) {
   console.log(request.protocol)
   console.log(request.url)
   console.log(request.routerMethod)
-  console.log(request.routerPath)
+  console.log(request.routeOptions.bodyLimit)
+  console.log(request.routeOptions.method)
+  console.log(request.routeOptions.url)
+  console.log(request.routeOptions.attachValidation)
+  console.log(request.routeOptions.logLevel)
+  console.log(request.routeOptions.version)
+  console.log(request.routerPath.logLevel)
   request.log.info('some info')
 })
 ```

lib/request.js

@@ -165,6 +165,23 @@ Object.defineProperties(Request.prototype, {
       return this[kRouteContext].config.url
     }
   },
+  routeOptions: {
+    get () {
+      const context = this[kRouteContext]
+      const routeLimit = context._parserOptions.limit
+      const serverLimit = context.server.initialConfig.bodyLimit
+      const version = context.server.hasConstraintStrategy('version') ? this.raw.headers['accept-version'] : undefined
+      const options = {
+        method: context.config.method,
+        url: context.config.url,
+        bodyLimit: (routeLimit || serverLimit),
+        attachValidation: context.attachValidation,
+        logLevel: context.logLevel,
+        version
+      }
+      return Object.freeze(options)
+    }
+  },
   routerMethod: {
     get () {
       return this[kRouteContext].config.method

test/bodyLimit.test.js

@@ -44,3 +44,82 @@ test('bodyLimit', t => {
     })
   })
 })
+
+test('default request.routeOptions.bodyLimit should be 1048576', t => {
+  t.plan(4)
+  const fastify = Fastify()
+  fastify.post('/default-bodylimit', {
+    handler (request, reply) {
+      t.equal(1048576, request.routeOptions.bodyLimit)
+      reply.send({ })
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/default-bodylimit',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})
+
+test('request.routeOptions.bodyLimit should be equal to route limit', t => {
+  t.plan(4)
+  const fastify = Fastify({ bodyLimit: 1 })
+  fastify.post('/route-limit', {
+    bodyLimit: 1000,
+    handler (request, reply) {
+      t.equal(1000, request.routeOptions.bodyLimit)
+      reply.send({})
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/route-limit',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})
+
+test('request.routeOptions.bodyLimit should be equal to server limit', t => {
+  t.plan(4)
+  const fastify = Fastify({ bodyLimit: 100 })
+  fastify.post('/server-limit', {
+    handler (request, reply) {
+      t.equal(100, request.routeOptions.bodyLimit)
+      reply.send({})
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/server-limit',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})

test/request-error.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { connect } = require('net')
+const sget = require('simple-get').concat
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
@@ -313,3 +314,94 @@ test('default clientError replies with bad request on reused keep-alive connecti
     client.write('\r\n\r\n')
   })
 })
+
+test('request.routeOptions should be immutable', t => {
+  t.plan(7)
+  const fastify = Fastify()
+  const handler = function (req, res) {
+    t.equal('POST', req.routeOptions.method)
+    t.equal('/', req.routeOptions.url)
+    try {
+      req.routeOptions.bodyLimit = 1001
+      t.fail('property bodyLimit is immutable')
+    } catch (err) {
+      t.ok(err)
+    }
+    try {
+      req.routeOptions = null
+      t.fail('routerOptions is immutable')
+    } catch (err) {
+      t.ok(err)
+    }
+    res.send({ })
+  }
+  fastify.post('/', {
+    bodyLimit: 1000,
+    handler
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})
+
+test('test request.routeOptions.version', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'POST',
+    url: '/version',
+    constraints: { version: '1.2.0' },
+    handler: function (request, reply) {
+      t.equal('1.2.0', request.routeOptions.version)
+      reply.send({})
+    }
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/version-undefined',
+    handler: function (request, reply) {
+      t.equal(undefined, request.routeOptions.version)
+      reply.send({})
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/version',
+      headers: { 'Content-Type': 'application/json', 'Accept-Version': '1.2.0' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/version-undefined',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})

test/types/request.test-d.ts

@@ -17,7 +17,7 @@ import fastify, {
 } from '../../fastify'
 import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
-import { FastifyRequest } from '../../types/request'
+import { FastifyRequest, RequestRouteOptions } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { FastifyInstance } from '../../types/instance'
 import { RouteGenericInterface } from '../../types/route'
@@ -66,6 +66,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<string>(request.method)
   expectType<string>(request.routerPath)
   expectType<string>(request.routerMethod)
+  expectType<Readonly<RequestRouteOptions>>(request.routeOptions)
   expectType<boolean>(request.is404)
   expectType<string>(request.hostname)
   expectType<string>(request.ip)

types/request.d.ts

@@ -20,6 +20,15 @@ export interface ValidationFunction {
   errors?: null | ErrorObject[];
 }
 
+export interface RequestRouteOptions {
+  method: string,
+  url: string,
+  bodyLimit:number,
+  attachValidation:boolean,
+  logLevel:string,
+  version: string | undefined
+}
+
 /**
  * FastifyRequest is an instance of the standard http or http2 request objects.
  * It defaults to http.IncomingMessage, and it also extends the relative request object.
@@ -66,6 +75,7 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   readonly method: string;
   readonly routerPath: string;
   readonly routerMethod: string;
+  readonly routeOptions: Readonly<RequestRouteOptions>
   readonly is404: boolean;
   readonly socket: RawRequest['socket'];