### Install @fastify/sensible

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Install the @fastify/sensible package using npm.

```bash
npm i @fastify/sensible
```

--------------------------------

### Get Forwarded Request Information with req.forwarded

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `req.forwarded()` helper provides access to the forwarded request information, similar to the `jshttp/forwarded` library, without needing to pass the request object explicitly.

```js
fastify.get('/', (req, reply) => {
  reply.send(req.forwarded())
})
```

--------------------------------

### Basic Usage of @fastify/sensible

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Register the @fastify/sensible plugin and use its utilities, such as reply.notFound().

```javascript
const fastify = require('fastify')()
fastify.register(require('@fastify/sensible'))

fastify.get('/', (req, reply) => {
  reply.notFound()
})

fastify.get('/async', async (req, reply) => {
  throw fastify.httpErrors.notFound()
})

fastify.get('/async-return', async (req, reply) => {
  return reply.notFound()
})

fastify.listen({ port: 3000 })
```

--------------------------------

### Handle Not Found Reply

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.notFound() decorator to send a 404 Not Found response. This is a shortcut provided by fastify-sensible.

```javascript
fastify.get('/', (req, reply) => {
  reply.notFound()
})
```

--------------------------------

### fastify.to(promise)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Async await wrapper for simplified error handling without try-catch.

```APIDOC
## fastify.to(promise)

### Description
An async/await wrapper inspired by `await-to-js` that simplifies error handling by returning a tuple `[error, result]` instead of throwing exceptions.

### Method
GET (example usage)

### Endpoint
/

### Parameters
#### Path Parameters
- **promise** (Promise) - Required - The promise to wrap.

### Request Example
```js
const [err, user] = await fastify.to(
  db.findOne({ user: 'tyrion' })
)
```

### Response Example
```json
[null, { "user": "tyrion" }] // On success
```
```json
[Error("Database error"), null] // On error
```
```

--------------------------------

### Create a 404 Not Found Error

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the notFound constructor from fastify.httpErrors to create a 404 error. A custom message is optional.

```javascript
const notFoundErr = fastify.httpErrors.notFound('custom message')
```

--------------------------------

### fastify.assert methods

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Provides various assertion methods for checking conditions.

```APIDOC
## fastify.assert methods

### Description
Additional assertion methods available on `fastify.assert` for detailed condition checking.

### Methods
- `fastify.assert.ok(value, message)`
- `fastify.assert.equal(actual, expected, message)`
- `fastify.assert.notEqual(actual, expected, message)`
- `fastify.assert.strictEqual(actual, expected, message)`
- `fastify.assert.notStrictEqual(actual, expected, message)`
- `fastify.assert.deepEqual(actual, expected, message)`
- `fastify.assert.notDeepEqual(actual, expected, message)`

### Request Example
```js
fastify.assert.ok(user, 'User not found')
```
```

--------------------------------

### fastify.assert(condition, statusCode, message)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Verifies a condition and throws an HTTP error if it's false.

```APIDOC
## fastify.assert(condition, statusCode, message)

### Description
Verifies if a given condition is true. If the condition is false, it throws an HTTP error with the specified status code and message. Useful for async routes.

### Method
GET (example usage)

### Endpoint
/

### Parameters
#### Path Parameters
- **condition** (boolean) - Required - The condition to evaluate.
- **statusCode** (number) - Required - The HTTP status code to use if the condition is false.
- **message** (string) - Optional - A custom error message.

### Request Example
```js
fastify.assert(
  req.headers.authorization, 400, 'Missing authorization header'
)
```
```

--------------------------------

### Assert Conditions and Throw HTTP Errors with fastify.assert

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use `fastify.assert(condition, statusCode, message)` to verify a condition and throw a specified HTTP error if it's false. This is particularly useful in async routes for error handling.

```js
// the custom message is optional
fastify.assert(
  req.headers.authorization, 400, 'Missing authorization header'
)
```

--------------------------------

### Async Error Handling Wrapper with fastify.to

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `fastify.to(promise)` utility provides an async/await-friendly way to handle errors from promises without using try-catch blocks, inspired by `await-to-js`.

```js
const [err, user] = await fastify.to(
  db.findOne({ user: 'tyrion' })
)
```

--------------------------------

### reply.staticCache(time)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Sets the cache control header to a public and immutable configuration.

```APIDOC
## reply.staticCache(time)

### Description
Sets the cache control header to a public and immutable configuration.

### Method
GET (example usage)

### Endpoint
/

### Parameters
#### Query Parameters
- **time** (number | string) - Required - The duration for the cache in seconds or a string representation.

### Request Example
```js
fastify.get('/', (req, reply) => {
  reply.staticCache(42)
  reply.send('ok')
})
```

### Response Example
```
Cache-Control: public, max-age=42, immutable
```
```

--------------------------------

### Set Cache Control for Public and Immutable with reply.staticCache

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use `reply.staticCache(time)` to set the cache control header to 'public, max-age=<time>, immutable'. The time can be provided as a number or a string.

```js
fastify.get('/', (req, reply) => {
  // the time can be defined as a string
  reply.staticCache(42) // will set to 'public, max-age=42, immutable'
  reply.send('ok')
})
```

--------------------------------

### Set Max Age and Stale Cache Control with reply.maxAge

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use `reply.maxAge(time)` to set the max-age directive for the Cache-Control header. This can be combined with `reply.stale` for advanced caching strategies.

```js
fastify.get('/', (req, reply) => {
  // the time can be defined as a string
  reply.maxAge(86400)
  reply.stale('while-revalidate', 42)
  reply.send('ok')
})
```

--------------------------------

### Using Shared JSON Schema for HTTP Errors

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Configure @fastify/sensible with sharedSchemaId to use a shared JSON Schema for HTTP errors in route definitions.

```javascript
const fastify = require('fastify')()
fastify.register(require('@fastify/sensible'), {
  sharedSchemaId: 'HttpError'
})

fastify.get('/async', {
  schema: {
    response: {
      404: { $ref: 'HttpError' }
    }
  },
  handler: async (req, reply) => {
    return reply.notFound()
  }
})

fastify.listen({ port: 3000 })
```

--------------------------------

### Configure Cache Control with Max-Age (String)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.cacheControl('max-age', '1d') decorator to set the Cache-Control max-age directive using a string format supported by the ms library (e.g., '1d' for one day).

```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('max-age', '1d') // will set to 'max-age=86400'
  reply.send('ok')
})
```

--------------------------------

### Reply Decorators for HTTP Errors

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `reply` interface is decorated with methods corresponding to the `fastify.httpErrors` constructors, allowing for direct error responses.

```APIDOC
## Reply Decorators for HTTP Errors

### Description

The `reply` interface is extended with methods that mirror the `fastify.httpErrors` constructors. This allows you to directly send HTTP errors from your route handlers.

### Usage

Call the desired error method on the `reply` object.

#### Example
```javascript
fastify.get('/', (req, reply) => {
  reply.notFound() // Sends a 404 Not Found response
})
```
```

--------------------------------

### Configure Cache Control with Max-Age (Seconds)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.cacheControl('max-age', 42) decorator to set the Cache-Control max-age directive to a specified number of seconds.

```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('max-age', 42)
  reply.send('ok')
})
```

--------------------------------

### request.is(types)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Checks if the request content type matches any of the specified types.

```APIDOC
## request.is(types)

### Description
Decorated with `jshttp/type-is`, checks if the `Content-Type` header of the request matches any of the provided MIME types.

### Method
GET (example usage)

### Endpoint
/

### Parameters
#### Query Parameters
- **types** (array of strings) - Required - An array of MIME types to check against (e.g., `['html', 'json']`).

### Request Example
```js
fastify.get('/', (req, reply) => {
  reply.send(req.is(['html', 'json']))
})
```

### Response Example
```json
"application/json"
```
```

--------------------------------

### Set Cache Control for Stale Content with reply.stale

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use `reply.stale(type, time)` to set cache control headers for stale content, supporting 'while-revalidate' and 'if-error' types. The time can be a number or a string.

```js
fastify.get('/', (req, reply) => {
  // the time can be defined as a string
  reply.stale('while-revalidate', 42)
  reply.stale('if-error', 1)
  reply.send('ok')
})
```

--------------------------------

### Configure Public Cache Control

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.cacheControl('public') decorator to set the Cache-Control header to 'public'. This is useful for resources that can be cached by intermediate proxies.

```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('public')
  reply.send('ok')
})
```

--------------------------------

### Fastify HTTP Errors

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `fastify.httpErrors` object provides constructors for common HTTP errors (4xx and 5xx) and a `createError` utility.

```APIDOC
## Fastify HTTP Errors

### Description

The `fastify.httpErrors` object exposes a `createError` function and constructors for all `4xx` and `5xx` HTTP errors. These can be used to generate standardized error responses.

### Usage

Error constructors follow the structure of `http-errors` library: `new createError[code || name]([msg])`.

#### Example
```javascript
// The custom message is optional
const notFoundErr = fastify.httpErrors.notFound('custom message')
```

### Available 4xx Errors

- `fastify.httpErrors.badRequest()
- `fastify.httpErrors.unauthorized()
- `fastify.httpErrors.paymentRequired()
- `fastify.httpErrors.forbidden()
- `fastify.httpErrors.notFound()
- `fastify.httpErrors.methodNotAllowed()
- `fastify.httpErrors.notAcceptable()
- `fastify.httpErrors.proxyAuthenticationRequired()
- `fastify.httpErrors.requestTimeout()
- `fastify.httpErrors.conflict()
- `fastify.httpErrors.gone()
- `fastify.httpErrors.lengthRequired()
- `fastify.httpErrors.preconditionFailed()
- `fastify.httpErrors.payloadTooLarge()
- `fastify.httpErrors.uriTooLong()
- `fastify.httpErrors.unsupportedMediaType()
- `fastify.httpErrors.rangeNotSatisfiable()
- `fastify.httpErrors.expectationFailed()
- `fastify.httpErrors.imateapot()
- `fastify.httpErrors.misdirectedRequest()
- `fastify.httpErrors.unprocessableEntity()
- `fastify.httpErrors.locked()
- `fastify.httpErrors.failedDependency()
- `fastify.httpErrors.tooEarly()
- `fastify.httpErrors.upgradeRequired()
- `fastify.httpErrors.preconditionRequired()
- `fastify.httpErrors.tooManyRequests()
- `fastify.httpErrors.requestHeaderFieldsTooLarge()
- `fastify.httpErrors.unavailableForLegalReasons()

### Available 5xx Errors

- `fastify.httpErrors.internalServerError()
- `fastify.httpErrors.notImplemented()
- `fastify.httpErrors.badGateway()
- `fastify.httpErrors.serviceUnavailable()
- `fastify.httpErrors.gatewayTimeout()
- `fastify.httpErrors.httpVersionNotSupported()
- `fastify.httpErrors.variantAlsoNegotiates()
- `fastify.httpErrors.insufficientStorage()
- `fastify.httpErrors.loopDetected()
- `fastify.httpErrors.bandwidthLimitExceeded()
- `fastify.httpErrors.notExtended()
- `fastify.httpErrors.networkAuthenticationRequired()

### `createError` Utility

Use `createError` to create custom errors with a status code, message, and optional properties, following the `http-errors` structure: `createError([status], [message], [properties])`.

#### Example
```javascript
const err = fastify.httpErrors.createError(404, 'This video does not exist!')
```
```

--------------------------------

### Configure Immutable Cache Control

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.cacheControl('immutable') decorator to set the Cache-Control header to 'immutable'. This indicates that the response will not change over time.

```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('public')
  reply.cacheControl('immutable')
  reply.send('ok')
})
```

--------------------------------

### Prevent Caching

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.preventCache() decorator to set cache control headers to prevent caching. This includes 'no-store', 'max-age=0', 'private', and for HTTP/1.0 compatibility, 'no-cache' and expires to 0.

```javascript
fastify.get('/', (req, reply) => {
  // will set cache-control to 'no-store, max-age=0, private'
  // and for HTTP/1.0 compatibility
  // will set pragma to 'no-cache' and expires to 0
  reply.preventCache()
  reply.send('ok')
})
```

--------------------------------

### reply.maxAge(time)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Sets the max age of the response.

```APIDOC
## reply.maxAge(time)

### Description
Sets the max age of the response. Can be used in conjunction with `reply.stale`.

### Method
GET (example usage)

### Endpoint
/

### Parameters
#### Query Parameters
- **time** (number | string) - Required - The duration for the max age in seconds or a string representation.

### Request Example
```js
fastify.get('/', (req, reply) => {
  reply.maxAge(86400)
  reply.stale('while-revalidate', 42)
  reply.send('ok')
})
```

### Response Example
```
Cache-Control: max-age=86400
Cache-Control: while-revalidate, max-age=42
```
```

--------------------------------

### request.forwarded()

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Provides access to the forwarded IP addresses of the request.

```APIDOC
## request.forwarded()

### Description
Decorated with `jshttp/forwarded`, provides the IP addresses from which the request originated, respecting proxy headers.

### Method
GET (example usage)

### Endpoint
/

### Request Example
```js
fastify.get('/', (req, reply) => {
  reply.send(req.forwarded())
})
```

### Response Example
```json
["192.168.1.1", "::1"]
```
```

--------------------------------

### Reply Decorator: cacheControl

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `reply.cacheControl` decorator provides a convenient way to configure `Cache-Control` response headers.

```APIDOC
## Reply Decorator: cacheControl

### Description

The `reply.cacheControl` decorator is a helper function for setting `Cache-Control` response headers. It supports various directives and time formats.

### Usage

Call `reply.cacheControl` with directives or directives and values.

#### Examples

Configure a single directive:
```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('public')
  reply.send('ok')
})
```

Configure multiple directives:
```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('public')
  reply.cacheControl('immutable')
  reply.send('ok')
})
```

Configure a directive with a time value:
```javascript
fastify.get('/', (req, reply) => {
  reply.cacheControl('max-age', 42)
  reply.send('ok')
})
```

Configure a directive with a string time value (supports `ms` formats):
```javascript
fastify.get('/', (req, reply) => {
  // will set to 'max-age=86400'
  reply.cacheControl('max-age', '1d') 
  reply.send('ok')
})
```
```

--------------------------------

### reply.revalidate()

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Sets the cache control header to a no caching configuration.

```APIDOC
## reply.revalidate()

### Description
Sets the cache control header to a no caching configuration.

### Method
GET (example usage)

### Endpoint
/

### Request Example
```js
fastify.get('/', (req, reply) => {
  reply.revalidate()
  reply.send('ok')
})
```

### Response Example
```
Cache-Control: max-age=0, must-revalidate
```
```

--------------------------------

### reply.stale(type, time)

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Sets the cache control header for stale content.

```APIDOC
## reply.stale(type, time)

### Description
Sets the cache control header for stale content.

### Method
GET (example usage)

### Endpoint
/

### Parameters
#### Query Parameters
- **type** (string) - Required - The type of stale directive (e.g., 'while-revalidate', 'if-error').
- **time** (number | string) - Required - The duration for the stale directive in seconds or a string representation.

### Request Example
```js
fastify.get('/', (req, reply) => {
  reply.stale('while-revalidate', 42)
  reply.stale('if-error', 1)
  reply.send('ok')
})
```

### Response Example
```
Cache-Control: while-revalidate, max-age=42
Cache-Control: if-error, max-age=1
```
```

--------------------------------

### Create a Custom HTTP Error

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the createError function from fastify.httpErrors to create a custom HTTP error with a specified status code, message, and optional properties. This follows the http-errors library API.

```javascript
const err = fastify.httpErrors.createError(404, 'This video does not exist!')
```

--------------------------------

### Set Cache Control to No Caching with reply.revalidate

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use `reply.revalidate()` to set the cache control header to 'max-age=0, must-revalidate'. This is useful for ensuring responses are always fresh.

```js
fastify.get('/', (req, reply) => {
  reply.revalidate() // will set to 'max-age=0, must-revalidate'
  reply.send('ok')
})
```

--------------------------------

### Reply Decorator: vary

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `reply.vary` decorator is a helper for setting the `Vary` response header, based on the `jshttp/vary` module.

```APIDOC
## Reply Decorator: vary

### Description

The `reply.vary` decorator allows you to easily set the `Vary` response header. It is a wrapper around the `jshttp/vary` module, simplifying its usage by not requiring the `res` object.

### Usage

Call `reply.vary` with the header field(s) to include in the `Vary` header.

#### Example
```javascript
fastify.get('/', (req, reply) => {
  reply.vary('Accept')
  reply.send('ok')
})
```
```

--------------------------------

### Check Request Content Type with req.is

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `req.is(types)` helper checks if the request's Content-Type matches any of the provided types, using the `jshttp/type-is` library.

```js
fastify.get('/', (req, reply) => {
  reply.send(req.is(['html', 'json']))
})
```

--------------------------------

### Reply Decorator: preventCache

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

The `reply.preventCache` decorator is a helper to set `Cache-Control` headers to prevent caching.

```APIDOC
## Reply Decorator: preventCache

### Description

The `reply.preventCache` decorator sets the `Cache-Control` header to a no-caching configuration. It also sets compatible headers for older HTTP versions.

### Usage

Call `reply.preventCache` on the reply object.

#### Example
```javascript
fastify.get('/', (req, reply) => {
  // Sets Cache-Control to 'no-store, max-age=0, private'
  // Sets Pragma to 'no-cache' and Expires to 0 for HTTP/1.0 compatibility
  reply.preventCache()
  reply.send('ok')
})
```
```

--------------------------------

### Set Vary Header

Source: https://github.com/fastify/fastify-sensible/blob/main/README.md

Use the reply.vary() decorator to set the Vary response header. This decorator is based on the jshttp/vary library and does not require the res object.

```javascript
fastify.get('/', (req, reply) => {
  reply.vary('Accept')
  reply.send('ok')
})
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.