The hitchhiker's guide to plugins

First of all, DON'T PANIC!

Fastify was built from the beginning to be an extremely modular system. We built a powerful API that allows you to add methods and utilities to Fastify by creating a namespace. We built a system that creates an encapsulation model that allows you to split your application in multiple microservices at any moment, without the need to refactor the entire application.

Table of contents

Register

As in JavaScript everything is an object, in Fastify everything is a plugin.Your routes, your utilities and so on are all plugins. To add a new plugin, whatever its functionality is, in Fastify you have a nice and unique api to use: register.

  1. fastify.register(
  2.   require('./my-plugin'),
  3.   { options }
  4. )

register creates a new Fastify context, this means that if you do any change to the Fastify instance, those changes will not be reflected in the context's ancestors. In other words, encapsulation!

_Why is encapsulation important?_Well, let's say you are creating a new disruptive startup, what do you do? You create an api server with all your stuff, everything in the same place, a monolith!Ok, you are growing very fast and you want to change your architecture and try microservices. Usually this implies a huge amount of work, because of cross dependencies and the lack of separation of concerns.Fastify helps you a lot in this direction, because thanks to the encapsulation model it will completely avoid cross dependencies, and will help you structure your code in cohesive blocks.

_Let's return to how to correctly use register._As you probably know, the required plugins must expose a single function with the following signature

  1. module.exports = function (fastify, options, done) {}

Where fastify is (pretty obvious) the encapsulated Fastify instance, options is the options object and done is the function you must call when your plugin is ready.

Fastify's plugin model is fully reentrant and graph-based, it handles without any kind of problem asynchronous code and it guarantees the load order of the plugins, even the close order! How? Glad you asked, checkout avvio! Fastify starts loading the plugin after .listen(), .inject() or .ready() are called.

Inside a plugin you can do whatever you want, register routes, utilities (we'll see this in a moment) and do nested registers, just remember to call done when everything is set up!

  1. module.exports = function (fastify, options, done) {
  2.   fastify.get('/plugin', (request, reply) => {
  3.     reply.send({ hello: 'world' })
  4.   })
  6.   done()
  7. }

Well, now you know how to use the register api and how it works, but how do we add new functionality to Fastify and even better, share them with other developers?

Decorators

Okay, let's say that you wrote an utility that is so good that you decided to make it available along all your code. How would you do it? Probably something like the following:

  1. // your-awesome-utility.js
  2. module.exports = function (a, b) {
  3.   return a + b
  4. }
  1. const util = require('./your-awesome-utility')
  2. console.log(util('that is ', ' awesome'))

And now you will import your utility in every file you need it. (And don't forget that you will probably also need it in your test).

Fastify offers you a way nicer and elegant way to do this, decorators. Create a decorator is extremely easy, just use the decorate api:

  1. fastify.decorate('util', (a, b) => a + b)

Now you can access your utility just by doing fastify.util whenever you need it, even inside your test.And here's starts the magic; do you remember that few lines above we talked about encapsulation? Well, using register and decorate in conjunction enable exactly that, let me show you an example to clarify this:

  1. fastify.register((instance, opts, done) => {
  2.   instance.decorate('util', (a, b) => a + b)
  3.   console.log(instance.util('that is ', ' awesome'))
  5.   done()
  6. })
  8. fastify.register((instance, opts, done) => {
  9.   console.log(instance.util('that is ', ' awesome')) // this will throw an error
  11.   done()
  12. })

Inside the second register call instance.util will throw an error, because util exists only inside the first register context.Let's step back for a moment and get deeper on this: when using the register api you will create a new context every time and this avoids situations like the one mentioned few line above. But pay attention, the encapsulation works only for the ancestors and the brothers, but not for the sons.

  1. fastify.register((instance, opts, done) => {
  2.   instance.decorate('util', (a, b) => a + b)
  3.   console.log(instance.util('that is ', ' awesome'))
  5.   fastify.register((instance, opts, done) => {
  6.     console.log(instance.util('that is ', ' awesome')) // this will not throw an error
  7.     done()
  8.   })
  10.   done()
  11. })
  13. fastify.register((instance, opts, done) => {
  14.   console.log(instance.util('that is ', ' awesome')) // this will throw an error
  16.   done()
  17. })

Take home message: if you need that an utility is available in every part of your application, pay attention that is declared at the root scope of your application. Otherwise you can use fastify-plugin utility as described here.

decorate is not the unique api that you can use to extend the server functionalities, you can also use decorateRequest and decorateReply.

_decorateRequest and decorateReply? Why do we need them if we already have decorate?_Good question, we added them to make Fastify more developer-friendly. Let's see an example:

  1. fastify.decorate('html', payload => {
  2.   return generateHtml(payload)
  3. })
  5. fastify.get('/html', (request, reply) => {
  6.   reply
  7.     .type('text/html')
  8.     .send(fastify.html({ hello: 'world' }))
  9. })

It works, but it can be way better!

  1. fastify.decorateReply('html', function (payload) {
  2.   this.type('text/html') // this is the 'Reply' object
  3.   this.send(generateHtml(payload))
  4. })
  6. fastify.get('/html', (request, reply) => {
  7.   reply.html({ hello: 'world' })
  8. })

And in the same way you can do this for the request object:

  1. fastify.decorate('getHeader', (req, header) => {
  2.   return req.headers[header]
  3. })
  5. fastify.addHook('preHandler', (request, reply, done) => {
  6.   request.isHappy = fastify.getHeader(request.raw, 'happy')
  7.   done()
  8. })
  10. fastify.get('/happiness', (request, reply) => {
  11.   reply.send({ happy: request.isHappy })
  12. })

Again, it works, but it can be way better!

  1. fastify.decorateRequest('setHeader', function (header) {
  2.   this.isHappy = this.headers[header]
  3. })
  5. fastify.decorateRequest('isHappy', false) // this will be added to the Request object prototype, yay speed!
  7. fastify.addHook('preHandler', (request, reply, done) => {
  8.   request.setHeader('happy')
  9.   done()
  10. })
  12. fastify.get('/happiness', (request, reply) => {
  13.   reply.send({ happy: request.isHappy })
  14. })

We've seen how to extend server functionality and how handle the encapsulation system, but what if you need to add a function that must be executed every time that the server "emits" an event?

Hooks

You just built an amazing utility, but now you need to execute that for every request, this is what you will likely do:

  1. fastify.decorate('util', (request, key, value) => { request.key = value })
  3. fastify.get('/plugin1', (request, reply) => {
  4.   fastify.util(request, 'timestamp', new Date())
  5.   reply.send(request)
  6. })
  8. fastify.get('/plugin2', (request, reply) => {
  9.   fastify.util(request, 'timestamp', new Date())
  10.   reply.send(request)
  11. })

I think we all agree that this is terrible. Code repeat, awful readability and it cannot scale.

So what can you do to avoid this annoying issue? Yes, you are right, use an hook!

  1. fastify.decorate('util', (request, key, value) => { request[key] = value })
  3. fastify.addHook('preHandler', (request, reply, done) => {
  4.   fastify.util(request, 'timestamp', new Date())
  5.   done()
  6. })
  8. fastify.get('/plugin1', (request, reply) => {
  9.   reply.send(request)
  10. })
  12. fastify.get('/plugin2', (request, reply) => {
  13.   reply.send(request)
  14. })

Now for every request you will run your utility, it is obvious that you can register as many hooks as you need.It can happen that you want a hook that must be executed just for a subset of routes, how can you do that? Yep, encapsulation!

  1. fastify.register((instance, opts, done) => {
  2.   instance.decorate('util', (request, key, value) => { request[key] = value })
  4.   instance.addHook('preHandler', (request, reply, done) => {
  5.     instance.util(request, 'timestamp', new Date())
  6.     done()
  7.   })
  9.   instance.get('/plugin1', (request, reply) => {
  10.     reply.send(request)
  11.   })
  13.   done()
  14. })
  16. fastify.get('/plugin2', (request, reply) => {
  17.   reply.send(request)
  18. })

Now your hook will run just for the first route!

As you probably noticed at this time, request and reply are not the standard Nodejs request and response objects, but Fastify's objects.

Middlewares

Fastify supports out of the box Express/Restify/Connect middlewares, this means that you can just drop-in your old code and it will work! _(faster, by the way)_Let's say that you are arriving from Express, and you already have some Middleware that does exactly what you need, and you don't want to redo all the work. How we can do that? Checkout our middlewares engine, middie.

  1. const yourMiddleware = require('your-middleware')
  2. fastify.use(yourMiddleware)

How to handle encapsulation and distribution

Perfect, now you know (almost) all the tools that you can use to extend Fastify. But probably there is something you noted when trying out your code.How can you distribute your code?

The preferred way to distribute a utility is to wrap all your code inside a register, in this way your plugin can support an asynchronous bootstrap (since decorate is a synchronous api), in the case of a database connection for example.

_Wait, what? Didn't you tell me that register creates an encapsulation and that what I create inside there will not be available outside?_Yes, I said that. But what I didn't tell you, is that you can tell to Fastify to avoid this behavior, with the fastify-plugin module.

  1. const fp = require('fastify-plugin')
  2. const dbClient = require('db-client')
  4. function dbPlugin (fastify, opts, done) {
  5.   dbClient.connect(opts.url, (err, conn) => {
  6.     fastify.decorate('db', conn)
  7.     done()
  8.   })
  9. }
  11. module.exports = fp(dbPlugin)

You can also tell to fastify-plugin to check the installed version of Fastify, in case of you need a specific api.

As we mentioned earlier, Fastify starts loading its plugins after .listen(), .inject() or .ready() are called and as such, after they have been declared. This means that, even though the plugin may inject variables to the external fastify instance via decorate, the decorated variables will not be accessible before calling .listen(), .inject() or .ready().

In case you rely on a variable injected by a preceding plugin and want to pass that in the options argument of register, you can do so by using a function instead of an object:

  1. const fastify = require('fastify')()
  2. const fp = require('fastify-plugin')
  3. const dbClient = require('db-client')
  5. function dbPlugin (fastify, opts, done) {
  6.   dbClient.connect(opts.url, (err, conn) => {
  7.     fastify.decorate('db', conn)
  8.     done()
  9.   })
  10. }
  12. fastify.register(fp(dbPlugin), { url: 'https://example.com' })
  13. fastify.register(require('your-plugin'), parent => {
  14.   return { connection: parent.db, otherOption: 'foo-bar' }
  15. })

In the above example, the parent variable of the function passed in as the second argument of register is a copy of the external fastify instance that the plugin was registered at. This means that we are able to access any variables that were injected by preceding plugins in the order of declaration.

Handle errors

It can happen that one of your plugins could fail during the startup. Maybe you expect it and you have a custom logic that will be triggered in that case. How can you do this? The after api is what you need. after simply registers a callback that will be executed just after a register, and it can take up to three parameters.The callback changes based on the parameters your are giving:

  • If no parameter is given to the callback and there is an error, that error will be passed to the next error handler.
  • If one parameter is given to the callback, that parameter will be the error object.
  • If two parameters are given to the callback, the first will be the error object, the second will be the done callback.
  • If three parameters are given to the callback, the first will be the error object, the second will be the top level context unless you have specified both server and override, in that case the context will be what the override returns, and the third the done callback.Let's see how to use it:
  1. fastify
  2.   .register(require('./database-connector'))
  3.   .after(err => {
  4.     if (err) throw err
  5.   })

Let's start!

Awesome, now you know everything you need to know about Fastify and its plugin system to start building your first plugin, and please if you do, tell us! We will add it to the ecosystem section of our documentation!

If you want to see some real world example, checkout:

  • point-of-view Templates rendering (ejs, pug, handlebars, marko) plugin support for Fastify.
  • fastify-mongodb Fastify MongoDB connection plugin, with this you can share the same MongoDb connection pool in every part of your server.
  • fastify-multipart Multipart support for Fastify
  • fastify-helmet Important security headers for Fastify

Do you feel it's missing something here? Let us know! :)