docs/guides/cli/hook.md
---
outline: deep
---
# Hooks
## Generating a hook
A new hook can be generated via
```
npx feathers generate hook
```
## Hook name
The hook generator will first ask for a name. Based on the name it will create a kebab-cased filename in the `hooks/` folder that exports a camelCased hook function. For example a name of `my fancy Hook` will create a `src/my-fancy-hook.ts` file that exports a `myFancyHook` [hook function](../../api/hooks.md#hook-functions).
## Hook types
There are two hook types that can be generated.
<BlockQuote type="tip">
For more information see the [hooks API documentation](../../api/hooks.md).
</BlockQuote>
### Around hooks
[Around hooks](../../api/hooks.md#around) allow to control the entire `before`, `after` and `error` flow in a single function. An `around` hook is an `async` function that accepts two arguments:
- The [hook context](../../api/hooks.md#hook-context)
- An asynchronous `next` function. Somewhere in the body of the hook function, there is a call to `await next()`, which calls the `next` hooks OR the original function if all other hooks have run.
```ts
import type { HookContext, NextFunction } from '../declarations'
export const myFancyHook = async (context: HookContext, next: NextFunction) => {
console.log(`Running hook ${name} on ${context.path}.${context.method}`)
await next()
// Do things after here
}
```
You can wrap the `await next()` in a `try/catch` block to also handle errors.
### Before, after, error
[Before, after or error hooks](../../api/hooks.md#before-after-and-error) are `async` functions that take the [hook context](#hook-context) as the parameter.
```ts
import type { HookContext } from '../declarations'
export const myFancyHook = async (context: HookContext) => {
console.log(`Running hook ${name} on ${context.path}.${context.method}`)
}
```
## Context types
If the hook is for a specific service, you can pass the service as a generic to the [HookContext](./declarations.md#hook-context) type which will give you the correct types for [context.data](../../api/hooks.md#contextdata), [context.result](../../api/hooks.md#contextresult) and [context.params](../../api/hooks.md#contextparams):
```ts
import type { UserService } from '../services/users/users'
import type { HookContext } from '../declarations'
export const myFancyUserHook = async (context: HookContext<UserService>) => {
console.log(`Running hook ${name} on ${context.path}.${context.method}`)
}
```
## Registering hooks
A generated hook can be registered as an [application hook](./app.md#application-hooks) or as a [service hook](./service.md#registering-hooks). Also see the [hook registration API documentation](../../api/hooks.md#registering-hooks).
## Profiling example
To log some basic profiling information like which method was called and how long it took to run you can create a new _around_ hook called `profiler` via
```
npx feathers generate hook
```
Then update `src/hooks/profiler.ts` as follows:
```ts
import type { HookContext, NextFunction } from '../declarations'
import { logger } from '../logger'
export const profiler = async (context: HookContext, next: NextFunction) => {
const startTime = Date.now()
await next()
const runtime = Date.now() - startTime
console.log(`Calling ${context.method} on service ${context.path} took ${runtime}ms`)
}
```
And add it in `src/app.ts` as an application hook after the `logError` hook as follows:
```ts{1,8}
import { profiler } from './hooks/profiler'
//...
// Register hooks that run on all service methods
app.hooks({
around: {
all: [ logError, profiler ]
},
before: {},
after: {},
error: {}
})
```