Plugins

This tutorial is compatible with hapi v17

Overview

hapi has an extensive and powerful plugin system that allows you to very easily break your application up into isolated pieces of business logic, and reusable utilities. You can either add an existing plugin to your application, or create your own.

Creating a plugin

Plugins are very simple to write. At their core they are an object with a register property, that is a function with the signature async function (server, options). Additionally the plugin object has a required name property and several optional properties including version.

A very simple plugin looks like:

  1. 'use strict';
  2.  
  3. const myPlugin = {
  4.     name: 'myPlugin',
  5.     version: '1.0.0',
  6.     register: async function (server, options) {
  7.  
  8.         // Create a route for example
  9.  
  10.         server.route({
  11.             method: 'GET',
  12.             path: '/test',
  13.             handler: function (request, h) {
  14.  
  15.                 return 'hello, world';
  16.             }
  17.         });
  18.  
  19.         // etc ...
  20.         await someAsyncMethods();
  21.     }
  22. };

Once this plugin is registered, the server will display 'hello, world' when the user goes to route /test.

To write a plugin as an external module, you can specify a pkg property:

  1. 'use strict';
  2.  
  3. exports.plugin = {
  4.     pkg: require('./package.json'),
  5.     register: async function (server, options) {
  6.  
  7.         // Create a route for example
  8.  
  9.         server.route({
  10.             method: 'GET',
  11.             path: '/test',
  12.             handler: function (request, h) {
  13.  
  14.                 return 'hello, world';
  15.             }
  16.         });
  17.  
  18.         // etc...
  19.         await someAsyncMethods();
  20.     }
  21. };

Note that in the first example, we set the name and version properties explicitly, however in the second we set a pkg parameter with the contents of package.json as its value. Either method is acceptable.

When written as a module, a plugin can either be top-level module export i.e module.exports = { register, name, version } or if you want your module to export more than a hapi plugin, it can be exported as exports.plugin = { register, name, version }.

Additionally, the plugin object may contain the property multiple that when set to true tells hapi that it is safe to register your plugin more than once in the same server.

Another available property is once. When set to true will mean hapi ignores subsequent registers of the same plugin without throwing an error.

The register method

As we've seen above, the register method accepts two parameters, server and options.

register should be an async function that returns once your plugin has completed whatever steps are necessary for it to be registered. Alternatively your register plugin should throw an error if an error occurred while registering your plugin.

The server object is a reference to the server your plugin is being loaded in.

The options parameter is simply whatever options the user passes to your plugin when calling server.register(plugins, [options]). No changes are made and the object is passed directly to your register method. Here is an example:

  1. 'use strict';
  2.  
  3. exports.plugin = {
  4.     pkg: require('./package.json'),
  5.     register: async function (server, options) {
  6.  
  7.         // Create a route for example
  8.  
  9.         server.route({
  10.             method: 'GET',
  11.             path: '/test',
  12.             handler: function (request, h) {
  13.  
  14.                 const name = options.name;
  15.                 return `Hello ${name}`;
  16.             }
  17.         });
  18.  
  19.         // etc...
  20.         await someAsyncMethods();
  21.     }
  22. };

Here, you grab a name from the options object via options.name. You then use that name to return a message to the user. Lets see how you pass that name to the plugin:

  1. const start = async function () {
  2.  
  3.     await server.register({
  4.         plugin: require('myplugin'),
  5.         options: {
  6.             name: 'Bob'
  7.         }
  8.     });
  9. };

When you register the plugin, you can pass whatever options to it with server.register(plugins, [options]). Here you are passing { name: "Bob" } to your plugin, which as you see above, can be accessed with the options object when you create the plugin.

Loading a plugin

Plugins can be loaded one at a time, or as a group in an array, by the server.register(plugins, [options]) method, for example:

  1. const start = async function () {
  2.  
  3.     const server = Hapi.server();
  4.  
  5.     // load one plugin
  6.  
  7.     await server.register(require('myplugin'));
  8.  
  9.     // load multiple plugins
  10.  
  11.     await server.register([require('myplugin'), require('yourplugin')]);
  12. };

To pass options to your plugin, we instead pass an object with plugin and options keys, such as:

  1. const start = async function () {
  2.  
  3.     const server = Hapi.server();
  4.  
  5.     await server.register({
  6.         plugin: require('myplugin'),
  7.         options: {
  8.             message: 'hello'
  9.         }
  10.     });
  11. };

These objects can also be passed in an array:

  1. const start = async function () {
  2.  
  3.     const server = Hapi.server();
  4.  
  5.     await server.register([{
  6.         plugin: require('plugin1'),
  7.         options: {}
  8.     }, {
  9.         plugin: require('plugin2'),
  10.         options: {}
  11.     }]);
  12. };

Registration options

You may also pass a second optional parameter to server.register(). Documentation for this object can be found in the API reference.

The options object is used by hapi and is not passed to the plugin(s) being loaded. It allows you to apply vhost or prefix modifiers to any routes that your plugins register.

For example, let's say we have a plugin that looks like this:

  1. 'use strict';
  2.  
  3. exports.plugin = {
  4.     pkg: require('./package.json'),
  5.     register: async function (server, options) {
  6.  
  7.         server.route({
  8.             method: 'GET',
  9.             path: '/test',
  10.             handler: function (request, h) {
  11.  
  12.                 return 'test passed';
  13.             }
  14.         });
  15.  
  16.         // etc...
  17.         await someAsyncMethods();
  18.     }
  19. };

Normally, when this plugin is loaded it will create a GET route at /test. This can be changed by using the prefix setting in the options, which will prepend a string to all routes created in the plugin:

  1. const start = async function () {
  2.  
  3.     const server = Hapi.server();
  4.  
  5.     await server.register(require('myplugin'), {
  6.         routes: {
  7.             prefix: '/plugins'
  8.         }
  9.     });
  10. };

Now when the plugin is loaded, because of the prefix option the GET route will be created at /plugins/test.

Similarly the options.routes.vhost property will assign a default vhost configuration to any routes created by the plugins being loaded. More detail about the vhost configuration can be found in the API reference.