feat: add request.routeOptions object

docs/Reference/Request.md

@@ -42,6 +42,12 @@ 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.
 - [.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 +96,12 @@ 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.routerPath.logLevel)
   request.log.info('some info')
 })
 ```

lib/request.js

@@ -137,6 +137,21 @@ function buildRequestWithTrustProxy (R, trustProxy) {
 
   return _Request
 }
+/**
+ *
+ * @param {object} target
+ * @returns {Proxy}
+ */
+function readOnly (target) {
+  return new Proxy(target, {
+    get (target, key) {
+      return target[key]
+    },
+    set (_, key) {
+      throw new Error(`property ${key} is immutable`)
+    }
+  })
+}
 
 Object.defineProperties(Request.prototype, {
   server: {
@@ -165,6 +180,24 @@ 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 options = {
+        method: context.config.method,
+        url: this.raw.url,
+        bodyLimit: (routeLimit || serverLimit),
+        attachValidation: context.attachValidation,
+        logLevel: context.logLevel
+      }
+      return readOnly(options)
+    },
+    set () {
+      throw new Error('routerOptions is immutable')
+    }
+  },
   routerMethod: {
     get () {
       return this[kRouteContext].config.method
@@ -248,13 +281,13 @@ Object.defineProperties(Request.prototype, {
       }
 
       const validatorCompiler = this[kRouteContext].validatorCompiler ||
-      this.server[kSchemaController].validatorCompiler ||
-     (
-       // We compile the schemas if no custom validatorCompiler is provided
-       // nor set
-       this.server[kSchemaController].setupValidator(this.server[kOptions]) ||
-       this.server[kSchemaController].validatorCompiler
-     )
+        this.server[kSchemaController].validatorCompiler ||
+        (
+          // We compile the schemas if no custom validatorCompiler is provided
+          // nor set
+          this.server[kSchemaController].setupValidator(this.server[kOptions]) ||
+          this.server[kSchemaController].validatorCompiler
+        )
 
       const validateFn = validatorCompiler({
         schema,
@@ -291,8 +324,8 @@ Object.defineProperties(Request.prototype, {
 
       // We cannot compile if the schema is missed
       if (validate == null && (schema == null ||
-          typeof schema !== 'object' ||
-          Array.isArray(schema))
+        typeof schema !== 'object' ||
+        Array.isArray(schema))
       ) {
         throw new FST_ERR_REQ_INVALID_VALIDATION_INVOCATION(httpPart)
       }

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,44 @@ 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({ hello: 'world' })
+  }
+  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/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,14 @@ export interface ValidationFunction {
   errors?: null | ErrorObject[];
 }
 
+export interface RequestRouteOptions {
+  method: string,
+  url: string,
+  bodyLimit:number,
+  attachValidation:boolean,
+  logLevel:string
+}
+
 /**
  * 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 +74,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'];