Hooks ===== Hooks are pluggable middleware functions that can be registered **before**, **after** or on \__error__s of a :doc:`./services`. You can register a single hook function or create a chain of them to create complex work-flows. Most of the time multiple hooks are registered so the examples show the “hook chain” array style registration. A hook is **transport independent**, which means it does not matter if it has been called through HTTP(S) (REST), Socket.io, Primus or any other transport Feathers may support in the future. They are also service agnostic, meaning they can be used with ​\ **any**\ ​ service regardless of whether they have a model or not. Hooks are commonly used to handle things like validation, logging, populating related entities, sending notifications and more. This pattern keeps your application logic flexible, composable, and much easier to trace through and debug. For more information about the design patterns behind hooks see `this blog post `_. Quick Example ------------- The following example adds a ``createdAt`` and ``updatedAt`` property before saving the data to the database and logs any errors on the service: .. code:: js const feathers = require('@feathersjs/feathers'); const app = feathers(); app.service('messages').hooks({ before: { create(context) { context.data.createdAt = new Date(); }, update(context) { context.data.updatedAt = new Date(); }, patch(context) { context.data.updatedAt = new Date(); } }, error(context) { console.error(`Error in ${context.path} calling ${context.method} method`, context.error); } }); Hook functions -------------- A hook function can be a normal or ``async`` function or arrow function that takes the `hook context <#hook-context>`_ as the parameter and can - return a ``context`` object - return nothing (``undefined``) - return ``feathers.SKIP`` to skip all further hooks - ``throw`` an error - for asynchronous operations return a `Promise `_ that - resolves with a ``context`` object - resolves with ``undefined`` - rejects with an error For more information see the `hook flow <#hook-flow>`_ and `asynchronous hooks <#asynchronous-hooks>`_ section. .. code:: js // normal hook function function(context) { return context; } // asynchronous hook function with promise function(context) { return Promise.resolve(context); } // async hook function async function(context) { return context; } // normal arrow function context => { return context; } // asynchronous arrow function with promise context => { return Promise.resolve(context); } // async arrow function async context => { return context; } // skip further hooks const feathers = require('@feathersjs/feathers'); async context => { return feathers.SKIP; } Hook context ------------ The hook ``context`` is passed to a hook function and contains information about the service method call. It has **read only** properties that should not be modified and **writeable** properties that can be changed for subsequent hooks. .. tip:: The ``context`` object is the same throughout a service method call so it is possible to add properties and use them in other hooks at a later time. context.app ~~~~~~~~~~~ :doc:`./application`. This can be used to retrieve other services (via ``context.app.service('name')``) or configuration values. context.service ~~~~~~~~~~~~~~~ ``context.service`` is a *read only* property and contains the service this hook currently runs on. context.path ~~~~~~~~~~~~ ``context.path`` is a *read only* property and contains the service name (or path) without leading or trailing slashes. context.method ~~~~~~~~~~~~~~ ``context.method`` is a *read only* property with the name of the :doc:`./services` (one of ``find``, ``get``, ``create``, ``update``, ``patch``, ``remove``). context.type ~~~~~~~~~~~~ ``context.type`` is a *read only* property with the hook type (one of ``before``, ``after`` or ``error``). context.params ~~~~~~~~~~~~~~ ``context.params`` is a **writeable** property that contains the :doc:`./services` parameters (including ``params.query``). For more information see the :ref:`services_params`. context.id ~~~~~~~~~~ ``context.id`` is a **writeable** property and the ``id`` for a ``get``, ``remove``, ``update`` and ``patch`` service method call. For ``remove``, ``update`` and ``patch`` ``context.id`` can also be ``null`` when modifying multiple entries. In all other cases it will be ``undefined``. .. note:: ``context.id`` is only available for method types ``get``, ``remove``, ``update`` and ``patch``. context.data ~~~~~~~~~~~~ ``context.data`` is a **writeable** property containing the data of a ``create``, ``update`` and ``patch`` service method call. .. note:: ``context.data`` will only be available for method types ``create``, ``update`` and ``patch``. context.error ~~~~~~~~~~~~~ ``context.error`` is a **writeable** property with the error object that was thrown in a failed method call. It is only available in ``error`` hooks. .. note:: ``context.error`` will only be available if ``context.type`` is ``error``. context.result ~~~~~~~~~~~~~~ ``context.result`` is a **writeable** property containing the result of the successful service method call. It is only available in ``after`` hooks. ``context.result`` can also be set in - A ``before`` hook to skip the actual service method (database) call - An ``error`` hook to swallow the error and return a result instead .. .. note:: ``context.result`` will only be available if ``context.type`` is ``after`` or if ``context.result`` has been set. context.dispatch ~~~~~~~~~~~~~~~~ ``context.dispatch`` is a **writeable, optional** property and contains a “safe” version of the data that should be sent to any client. If ``context.dispatch`` has not been set ``context.result`` will be sent to the client instead. .. note:: ``context.dispatch`` only affects the data sent through a Feathers Transport like `REST <./express>`_ or :doc:`./socketio`. An internal method call will still get the data set in ``context.result``. context.statusCode ~~~~~~~~~~~~~~~~~~ ``context.statusCode`` is a **writeable, optional** property that allows to override the standard `HTTP status code `_ that should be returned. Hook flow --------- In general, hooks are executed in the order they are registered with the original service method being called after all ``before`` hooks. This flow can be affected as follows. Throwing an error ~~~~~~~~~~~~~~~~~ When an error is thrown (or the promise is rejected), all subsequent hooks - and the service method call if it didn’t run already - will be skipped and only the error hooks will run. The following example throws an error when the text for creating a new message is empty. You can also create very similar hooks to use your Node validation library of choice. .. code:: js app.service('messages').hooks({ before: { create: [ function(context) { if(context.data.text.trim() === '') { throw new Error('Message text can not be empty'); } } ] } }); Setting ``context.result`` ~~~~~~~~~~~~~~~~~~~~~~~~~~ When ``context.result`` is set in a ``before`` hook, the original :doc:`./services` call will be skipped. All other hooks will still execute in their normal order. The following example always returns the currently `authenticated user <./authentication/server.md>`_ instead of the actual user for all ``get`` method calls: .. code:: js app.service('users').hooks({ before: { get: [ function(context) { // Never call the actual users service // just use the authenticated user context.result = context.params.user; } ] } }); Returning ``feathers.SKIP`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``require('@feathersjs/feathers').SKIP`` can be returned from a hook to indicate that all following hooks should be skipped. If returned by a **before** hook, the remaining **before** hooks are skipped; any **after** hooks will still be run. If it hasn’t run yet, the service method will still be called unless ``context.result`` is set already. Asynchronous hooks ------------------ When the hook function is ``async`` or a Promise is returned it will wait until all asynchronous operations resolve or reject before continuing to the next hook. .. important:: As stated in the `hook functions <#hook-functions>`_ section the promise has to either resolve with the ``context`` object (usually done with ``.then(() => context)`` at the end of the promise chain) or with ``undefined``. async/await ~~~~~~~~~~~ When using Node v8.0.0 or later the use of `async/await `_ is highly recommended. This will avoid many common issues when using Promises and asynchronous hook flows. Any hook function can be ``async`` in which case it will wait until all ``await`` operations are completed. Just like a normal hook it should return the ``context`` object or ``undefined``. The following example shows an async/await hook that uses another service to retrieve and populate the messages ``user`` when getting a single message: .. code:: js app.service('messages').hooks({ after: { get: [ async function(context) { const userId = context.result.userId; // Since context.app.service('users').get returns a promise we can `await` it const user = await context.app.service('users').get(userId); // Update the result (the message) context.result.user = user; // Returning will resolve the promise with the `context` object return context; } ] } }); Returning promises ~~~~~~~~~~~~~~~~~~ The following example shows an asynchronous hook that uses another service to retrieve and populate the messages ``user`` when getting a single message. .. code:: js app.service('messages').hooks({ after: { get: [ function(context) { const userId = context.result.userId; // context.app.service('users').get returns a Promise already return context.app.service('users').get(userId).then(user => { // Update the result (the message) context.result.user = user; // Returning will resolve the promise with the `context` object return context; }); } ] } }); .. .. note:: A common issue when hooks are not running in the expected order is a missing ``return`` statement of a promise at the top level of the hook function. .. important:: Most Feathers service calls and newer Node packages already return Promises. They can be returned and chained directly. There is no need to instantiate your own ``new`` Promise instance in those cases. Converting callbacks ~~~~~~~~~~~~~~~~~~~~ When the asynchronous operation is using a *callback* instead of returning a promise you have to create and return a new Promise (``new Promise((resolve, reject) => {})``) or use `util.promisify `_. The following example reads a JSON file converting `fs.readFile `_ with ``util.promisify``: .. code:: js const fs = require('fs'); const util = require('util'); const readFile = util.promisify(fs.readFile); app.service('messages').hooks({ after: { get: [ function(context) { return readFile('./myfile.json').then(data => { context.result.myFile = data.toString(); return context; }); } ] } }); .. .. tip:: Other tools like `Bluebird `_ also help converting between callbacks and promises. Registering hooks ----------------- Hook functions are registered on a service through the ``app.service().hooks(hooks)`` method. There are several options for what can be passed as ``hooks``: .. code:: js // The standard all at once way (also used by the generator) // an array of functions per service method name (and for `all` methods) app.service('servicename').hooks({ before: { all: [ // Use normal functions function(context) { console.log('before all hook ran'); } ], find: [ // Use ES6 arrow functions context => console.log('before find hook 1 ran'), context => console.log('before find hook 2 ran') ], get: [ /* other hook functions here */ ], create: [], update: [], patch: [], remove: [] }, after: { all: [], find: [], get: [], create: [], update: [], patch: [], remove: [] }, error: { all: [], find: [], get: [], create: [], update: [], patch: [], remove: [] } }); // Register a single hook before, after and on error for all methods app.service('servicename').hooks({ before(context) { console.log('before all hook ran'); }, after(context) { console.log('after all hook ran'); }, error(context) { console.log('error all hook ran'); } }); .. .. tip:: When using the full object, ``all`` is a special keyword meaning this hook will run for all methods. ``all`` hooks will be registered before other method specific hooks. .. tip:: ``app.service().hooks(hooks)`` can be called multiple times and the hooks will be registered in that order. Normally all hooks should be registered at once however to see at a glance what the service is going to do. .. _hooks_application-hooks: Application hooks ----------------- To add hooks to every service ``app.hooks(hooks)`` can be used. Application hooks are `registered in the same format as service hooks <#registering-hooks>`_ and also work exactly the same. .. note:: when application hooks will be executed however: - ``before`` application hooks will always run *before* all service ``before`` hooks - ``after`` application hooks will always run *after* all service ``after`` hooks - ``error`` application hooks will always run *after* all service ``error`` hooks Here is an example for a very useful application hook that logs every service method error with the service and method name as well as the error stack. .. code:: js app.hooks({ error(context) { console.error(`Error in '${context.path}' service method '${context.method}'`, context.error.stack); } });