fastify 4.9.0 → 4.9.2

package/docs/Reference/Decorators.md

@@ -114,10 +114,39 @@ fastify.get('/', async function (request, reply) {
 The `dependencies` parameter is an optional list of decorators that the
 decorator being defined relies upon. This list is simply a list of string names
 of other decorators. In the following example, the "utility" decorator depends
-upon "greet" and "log" decorators:
+upon "greet" and "hi" decorators:
 
 ```js
-fastify.decorate('utility', fn, ['greet', 'log'])
+async function greetDecorator (fastify, opts) {
+  fastify.decorate('greet', () => {
+    return 'greet message'
+  })
+}
+
+async function hiDecorator (fastify, opts) {
+  fastify.decorate('hi', () => {
+    return 'hi message'
+  })
+}
+
+async function utilityDecorator (fastify, opts) {
+  fastify.decorate('utility', () => {
+    return `${fastify.greet()} | ${fastify.hi()}`
+  })
+}
+
+fastify.register(fastifyPlugin(greetDecorator, { name: 'greet' }))
+fastify.register(fastifyPlugin(hiDecorator, { name: 'hi' }))
+fastify.register(fastifyPlugin(utilityDecorator, { dependencies: ['greet', 'hi'] }))
+
+fastify.get('/', function (req, reply) {
+  // Response: {"hello":"greet message | hi message"}
+  reply.send({ hello: fastify.utility() })
+})
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) throw err
+})
 ```
 
 Note: using an arrow function will break the binding of `this` to the

package/docs/Reference/Errors.md

@@ -332,7 +332,7 @@ The router received an invalid url.
 ### FST_ERR_ASYNC_CONSTRAINT
 <a id="FST_ERR_ASYNC_CONSTRAINT"></a>
 
-The router received error when using asynchronous constraints.
+The router received an error when using asynchronous constraints.
 
 #### FST_ERR_DEFAULT_ROUTE_INVALID_TYPE
 <a id="FST_ERR_DEFAULT_ROUTE_INVALID_TYPE"></a>

package/docs/Reference/Hooks.md

@@ -449,9 +449,9 @@ fastify.addHook('onRoute', (routeOptions) => {
 })
 ```
 
-If you want to add more routes within an onRoute hook, you have to tag these
-routes properly. If you don't, the hook will run into an infinite loop. The
-recommended approach is shown below.
+To add more routes within an onRoute hook, the routes must
+be tagged correctly. The hook will run into an infinite loop if
+not tagged. The recommended approach is shown below.
 
 ```js
 const kRouteAlreadyProcessed = Symbol('route-already-processed')

package/docs/Reference/Reply.md

@@ -656,13 +656,13 @@ fastify.get('/json', options, function (request, reply) {
 #### Streams
 <a id="send-streams"></a>
 
-*send* can also handle streams out of the box. If you are sending a stream and
-you have not set a `'Content-Type'` header, *send* will set it at
+*send* can also handle streams by setting the `'Content-Type'` header to
 `'application/octet-stream'`.
 ```js
 fastify.get('/streams', function (request, reply) {
   const fs = require('fs')
   const stream = fs.createReadStream('some-file', 'utf8')
+  reply.header('Content-Type', 'application/octet-stream')
   reply.send(stream)
 })
 ```

package/docs/Reference/Routes.md

@@ -734,9 +734,9 @@ fastify.route({
 
 #### Asynchronous Custom Constraints
 
-You can provide your custom constraints and the `constraint` criteria can be
-fetched from other source, for example `database`. Usage of asynchronous custom
-constraint should place at the last resort since it impacts the router
+Custom constraints can be provided and the `constraint` criteria can be
+fetched from another source such as `database`. The use of asynchronous
+custom constraints should be a last resort as it impacts router
 performance.
 
 ```js

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.9.0'
+const VERSION = '4.9.2'
 
 const Avvio = require('avvio')
 const http = require('http')

package/lib/route.js

@@ -252,7 +252,7 @@ function buildRouting (options) {
                 throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof func)
               }
             }
-          } else if (typeof opts[hook] !== 'function') {
+          } else if (opts[hook] !== undefined && typeof opts[hook] !== 'function') {
             throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof opts[hook])
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.9.0",
+  "version": "4.9.2",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

package/test/hooks.test.js

@@ -3322,12 +3322,22 @@ test('registering invalid hooks should throw an error', async t => {
     fastify.route({
       method: 'GET',
       path: '/invalidHook',
-      onRequest: undefined,
+      onRequest: null,
       async handler () {
         return 'hello world'
       }
     })
-  }, new Error('onRequest hook should be a function, instead got undefined'))
+  }, new Error('onRequest hook should be a function, instead got object'))
+
+  // undefined is ok
+  fastify.route({
+    method: 'GET',
+    path: '/validhook',
+    onRequest: undefined,
+    async handler () {
+      return 'hello world'
+    }
+  })
 
   t.throws(() => {
     fastify.addHook('onRoute', (routeOptions) => {

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

@@ -75,6 +75,8 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RequestParamsDefault>(request.params)
   expectType<FastifyContext<ContextConfigDefault>>(request.context)
   expectType<FastifyContextConfig>(request.context.config)
+  expectType<FastifyContextConfig>(request.routeConfig)
+  expectType<FastifySchema>(request.routeSchema)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}

package/types/context.d.ts

@@ -8,5 +8,8 @@ export interface FastifyContextConfig {
  * Route context object. Properties defined here will be available in the route's handler
  */
 export interface FastifyContext<ContextConfig = ContextConfigDefault> {
+  /**
+   * @deprecated Use Request#routeConfig or Request#routeSchema instead
+   */
   config: FastifyContextConfig & ContextConfig;
 }

package/types/request.d.ts

@@ -5,7 +5,7 @@ import { RouteGenericInterface } from './route'
 import { FastifyInstance } from './instance'
 import { FastifyTypeProvider, FastifyTypeProviderDefault, FastifyRequestType, ResolveFastifyRequestType } from './type-provider'
 import { FastifySchema } from './schema'
-import { FastifyContext } from './context'
+import { FastifyContext, FastifyContextConfig } from './context'
 
 type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
 export interface RequestGenericInterface {
@@ -48,6 +48,8 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   server: FastifyInstance;
   body: RequestType['body'];
   context: FastifyContext<ContextConfig>;
+  routeConfig: FastifyContextConfig & ContextConfig;
+  routeSchema: FastifySchema
 
   /** in order for this to be used the user should ensure they have set the attachValidation option. */
   validationError?: Error & { validation: any; validationContext: string };