Fastify

https://fastify.dev/docs
Admin
Fastify is a fast and low-overhead web framework for Node.js that provides high performance,...
Tokens:110,431
Snippets:1,279
Trust Score:9.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start server with callback

Source: https://fastify.dev/docs/latest/Reference/Server

Starts the server using a callback function to handle potential errors during startup.

```javascript
fastify.listen((err, address) => {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

})
```

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

### Install fastify-cli

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Install the Fastify CLI tool to manage and scaffold projects.

```bash
npm i fastify-cli
```

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

### Start Fastify Server

Source: https://fastify.dev/docs/latest/Guides/Testing

Initializes and starts the Fastify server using the application builder function. Includes basic logging configuration.

```javascript
'use strict'



const server = require('./app')({

  logger: {

    level: 'info',

    transport: {

      target: 'pino-pretty'

    }

  }

})



server.listen({ port: 3000 }, (err, address) => {

  if (err) {

    server.log.error(err)

    process.exit(1)

  }

})

```

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

### Run Different Examples with Concurrently and Autocannon

Source: https://fastify.dev/docs/latest/Guides/Benchmarking

Execute multiple examples concurrently, including a specific Fastify example and an Autocannon benchmark, using branch-comparer.

```bash
branchcmp --rounds 2 -s "node ./node_modules/concurrently -k -s first \"node ./examples/asyncawait.js\" \"node ./node_modules/autocannon -c 100 -d 5 -p 10 localhost:3000/\""
```

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

### Launch and Test Server

Source: https://fastify.dev

Commands to start the server and verify it with curl.

```bash
node server
```

```bash
curl http://localhost:3000
```

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

### Install Functions Framework

Source: https://fastify.dev/docs/latest/Guides/Serverless

Commands to install the Google Functions Framework for local development.

```bash
npm i -g @google-cloud/functions-framework
```

```bash
npm i -D @google-cloud/functions-framework
```

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

### Install Fastify

Source: https://fastify.dev

Install the Fastify package via NPM.

```bash
npm install fastify
```

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

### Initial Fastify Server Setup

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

A basic server implementation that accepts requests before the required magicKey is initialized.

```javascript
const Fastify = require('fastify')



const provider = require('./provider')



const server = Fastify({ logger: true })

const USUAL_WAIT_TIME_MS = 5000



server.get('/ping', function (request, reply) {

  reply.send({ error: false, ready: request.server.magicKey !== null })

})



server.post('/webhook', function (request, reply) {

  // It's good practice to validate webhook requests come from

  // who you expect. This is skipped in this sample for the sake

  // of simplicity



  const { magicKey } = request.body

  request.server.magicKey = magicKey

  request.log.info('Ready for customer requests!')



  reply.send({ error: false })

})



server.get('/v1*', async function (request, reply) {

  try {

    const data = await provider.fetchSensitiveData(request.server.magicKey)

    return { customer: true, error: false }

  } catch (error) {

    request.log.error({

      error,

      message: 'Failed at fetching sensitive data from provider',

    })



    reply.statusCode = 500

    return { customer: null, error: true }

  }

})



server.decorate('magicKey')



server.listen({ port: '1234' }, () => {

  provider.thirdPartyMagicKeyGenerator(USUAL_WAIT_TIME_MS)

    .catch((error) => {

      server.log.error({

        error,

        message: 'Got an error while trying to get the magic key!'

      })



      // Since we won't be able to serve requests, might as well wrap

      // things up

      server.close(() => process.exit(1))

    })

})
```

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

### Configure package.json scripts

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Add the start script to your package.json to run the server using the CLI.

```json
{

  "scripts": {

    "start": "fastify start server.js"

  }

}
```

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

### Install dependencies

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Install the required packages for plugin management and MongoDB integration.

```bash
npm i fastify-plugin @fastify/mongodb
```

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

### Run server via CLI

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Start the server using the configured npm script.

```bash
npm start
```

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

### Install TypeBox Provider

Source: https://fastify.dev/docs/latest/Reference/Type-Providers

Install the required packages for the TypeBox provider.

```bash
$ npm i typebox @fastify/type-provider-typebox
```

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

### HTTP Response Example

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Successful HTTP response for a GET request.

```http
HTTP/1.1 200 OK

Connection: keep-alive

Content-Length: 31

Content-Type: application/json; charset=utf-8

Date: Fri, 15 Apr 2022 23:03:20 GMT

Keep-Alive: timeout=5



{

    "customer": true,

    "error": false

}
```

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

### Start server with Promise

Source: https://fastify.dev/docs/latest/Reference/Server

Uses a Promise-based approach to handle server startup instead of a callback.

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

  .then((address) => console.log(`server listening on ${address}`))

  .catch(err => {

    console.log('Error starting server:', err)

    process.exit(1)

  })
```

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

### Install Fastify TypeScript dependencies

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Commands to initialize a project and install necessary packages for TypeScript development.

```bash
npm init -y

npm i fastify

npm i -D typescript @types/node
```

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

### Main Application Entry Point

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Configures the Fastify server, registers the setup plugin, and defines routes that are either blocked or non-blocked based on the magic key.

```javascript
const Fastify = require('fastify')



const customerRoutes = require('./customer-routes')

const { setup, delay } = require('./delay-incoming-requests')



const server = new Fastify({ logger: true })



server.register(setup)



// Non-blocked URL

server.get('/ping', function (request, reply) {

  reply.send({ error: false, ready: request.server.magicKey !== null })

})



// Webhook to handle the provider's response - also non-blocked

server.post('/webhook', function (request, reply) {

  // It's good practice to validate webhook requests really come from

  // whoever you expect. This is skipped in this sample for the sake

  // of simplicity



  const { magicKey } = request.body

  request.server.magicKey = magicKey

  request.log.info('Ready for customer requests!')



  reply.send({ error: false })

})



// Blocked URLs

// Mind we're building a new plugin by calling the `delay` factory with our

// customerRoutes plugin

server.register(delay(customerRoutes), { prefix: '/v1' })



server.listen({ port: '1234' })
```

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

### listen([options][, callback])

Source: https://fastify.dev/docs/latest/Reference/Server

Starts the server and waits for the ready event. Supports Node.js core listen options plus Fastify-specific configurations.

```APIDOC
## listen([options][, callback])

### Description
Starts the server and internally waits for the .ready() event. If no callback is provided, a Promise is returned.

### Parameters
- **options** (Object) - Optional - Extends Node.js core listen options. Includes `listenTextResolver` (Function) to customize the startup log message.
- **callback** (Function) - Optional - Callback function invoked with (err, address).

### Example
```javascript
fastify.listen({ port: 3000, host: '0.0.0.0' }, (err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})
```
```

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

### Install Zod Provider

Source: https://fastify.dev/docs/latest/Reference/Type-Providers

Install the required packages for the Zod provider.

```bash
$ npm i zod @fastify/type-provider-zod
```

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

### Install json-schema-to-ts

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Install the package as a development dependency.

```bash
npm i -D json-schema-to-ts
```

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

### Initialize Fastify Plugin Project

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Commands to initialize a new npm project and install the fastify-plugin dependency.

```bash
npm init -y

npm i fastify-plugin
```

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

### Install ESLint Extension

Source: https://fastify.dev/docs/latest/Guides/Contributing

Installs the ESLint extension into the portable VSCode instance.

```bash
code-fastify --install-extension dbaeumer.vscode-eslint
```

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

### Start server with specific host and port

Source: https://fastify.dev/docs/latest/Reference/Server

Configures the server to listen on a specific host and port using a callback.

```javascript
fastify.listen({ port: 3000, host: '127.0.0.1' }, (err, address) => {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

})
```

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

### Start server for Docker containers

Source: https://fastify.dev/docs/latest/Reference/Server

Listens on 0.0.0.0 to ensure the server is accessible within containerized environments.

```javascript
fastify.listen({ port: 3000, host: '0.0.0.0' }, (err, address) => {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

})
```

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

### Install JsonSchemaToTs Provider

Source: https://fastify.dev/docs/latest/Reference/Type-Providers

Install the required package for the json-schema-to-ts provider.

```bash
$ npm i @fastify/type-provider-json-schema-to-ts
```

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

### Create a basic Fastify server in TypeScript

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Example of a minimal Fastify server implementation using TypeScript.

```typescript
import fastify from 'fastify'



const server = fastify()



server.get('/ping', async (request, reply) => {

  return 'pong\n'

})



server.listen({ port: 8080 }, (err, address) => {

  if (err) {

    console.error(err)

    process.exit(1)

  }

  console.log(`Server listening at ${address}`)

})
```

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

### Install TypeBox

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Command to add the TypeBox library to your project dependencies.

```bash
npm i typebox
```

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

### Server Startup Logs

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Initial log output generated when the server starts and begins listening for connections.

```json
{"time":1650063793316,"msg":"Doing magic!"}

{"time":1650063793316,"msg":"Server listening at http://127.0.0.1:1234"}
```

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

### Configure package.json scripts

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Add build and start scripts to the package.json file to handle compilation and execution.

```json
{

  "scripts": {

    "build": "tsc -p tsconfig.json",

    "start": "node index.js"

  }

}
```

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

### Hyperlink formatting examples

Source: https://fastify.dev/docs/latest/Guides/Style-Guide

Demonstrates preferred and discouraged hyperlink structures for documentation.

```markdown
<!-- More like this -->



// Add clear & brief description

[Fastify Plugins] (https://fastify.dev/docs/latest/Plugins/)



<!--Less like this -->



// incomplete description

[Fastify] (https://fastify.dev/docs/latest/Plugins/)



// Adding title in link brackets

[](https://fastify.dev/docs/latest/Plugins/ "fastify plugin")



// Empty title

[](https://fastify.dev/docs/latest/Plugins/)



// Adding links localhost URLs instead of using code strings (``)

[http://localhost:3000/](http://localhost:3000/)
```

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

### Defining and using a standard utility module

Source: https://fastify.dev/docs/latest/Guides/Plugins-Guide

A basic example of exporting a utility function and importing it into another file.

```javascript
// your-awesome-utility.js

module.exports = function (a, b) {

  return a + b

}
```

```javascript
const util = require('./your-awesome-utility')

console.log(util('that is ', 'awesome'))
```

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

### Query API via cURL

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Example command to test the authenticated route.

```bash
curl localhost:8080/auth?username=admin&password=Password123!
```

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

### Implement Fastify Plugin in JavaScript

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Example implementation of a Fastify plugin using fastify-plugin to decorate the instance.

```javascript
// fastify-plugin is highly recommended for any plugin you write

const fp = require('fastify-plugin')



function myPlugin (instance, options, done) {



  // decorate the fastify instance with a custom function called myPluginFunc

  instance.decorate('myPluginFunc', (input) => {

    return input.toUpperCase()

  })



  done()

}



module.exports = fp(myPlugin, {

  fastify: '5.x',

  name: 'my-plugin' // this is used by fastify-plugin to derive the property name

})
```

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

### Configure Server Host Binding

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Example of modifying the listen configuration to bind to all interfaces, useful for containerized environments.

```javascript
fastify.listen({ port: 3000, host: '0.0.0.0' }, function (err, address) {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

  fastify.log.info(`server listening on ${address}`)

})
```

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

### Define a SQL migration script

Source: https://fastify.dev/docs/latest/Guides/Database

Example of a migration file following the [version].[action].[description].sql naming convention.

```sql
// 001.do.create-users-table.sql

CREATE TABLE IF NOT EXISTS users (

  id SERIAL PRIMARY KEY NOT NULL,

  created_at DATE NOT NULL DEFAULT CURRENT_DATE,

  firstName TEXT NOT NULL,

  lastName TEXT NOT NULL

);
```

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

### Test Endpoint Request

Source: https://fastify.dev/docs/latest/Guides/Serverless

Example curl request to test the /hello endpoint.

```bash
curl -X POST https://$GOOGLE_REGION-$GOOGLE_PROJECT.cloudfunctions.net/me \

  -H "Content-Type: application/json" \

  -d '{ "name": "Fastify" }'

{"message":"Hello Fastify!"}
```

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

### Request Logging Output

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Example logs showing incoming request and completion with response time.

```json
{"time":1650063799858,"reqId":"req-4","req":{"method":"GET","url":"/v1","hostname":"localhost:1234","remoteAddress":"127.0.0.1","remotePort":51934},"msg":"incoming request"}

{"time":1650063800561,"reqId":"req-4","res":{"statusCode":200},"responseTime":702.4662979990244,"msg":"request completed"}
```

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

### Schema Caching Example

Source: https://fastify.dev/docs/latest/Reference/Reply

Demonstrates how schema mutation affects the cache and how to properly create new schema objects to avoid cache reuse.

```javascript
const schema1 = {
  type: 'object',
  properties: {
    foo: {
      type: 'string'
    }
  }
}
```

```javascript
const serialize = reply.compileSerializationSchema(schema1)

// Later on...
schema1.properties.foo.type = 'integer'
const newSerialize = reply.compileSerializationSchema(schema1)

console.log(newSerialize === serialize) // true
```

```javascript
const serialize = reply.compileSerializationSchema(schema1)

// Later on...
const newSchema = Object.assign({}, schema1)
newSchema.properties.foo.type = 'integer'

const newSerialize = reply.compileSerializationSchema(newSchema)

console.log(newSerialize === serialize) // false
```

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

### Firebase CLI Commands

Source: https://fastify.dev/docs/latest/Guides/Serverless

Commands for installing tools, running local emulators, deploying, and reading logs.

```bash
npm i -g firebase-tools
```

```bash
firebase emulators:start --only functions
```

```bash
firebase deploy --only functions
```

```bash
firebase functions:log
```

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

### Replicate request logging with hooks

Source: https://fastify.dev/docs/latest/Reference/Server

Provides examples of using onRequest and onResponse hooks to manually implement custom request logging.

```javascript
// Examples of hooks to replicate the disabled functionality.

fastify.addHook('onRequest', (req, reply, done) => {

  req.log.info({ url: req.raw.url, id: req.id }, 'received request')

  done()

})



fastify.addHook('onResponse', (req, reply, done) => {

  req.log.info({ url: req.raw.originalUrl, statusCode: reply.raw.statusCode }, 'request completed')

  done()

})
```

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

### Define Fastify Endpoints

Source: https://fastify.dev/docs/latest/Guides/Serverless

Examples of defining simple GET and schema-validated POST endpoints.

```javascript
fastify.get('/', async (request, reply) => {

  reply.send({message: 'Hello World!'})

})
```

```javascript
fastify.route({

  method: 'POST',

  url: '/hello',

  schema: {

    body: {

      type: 'object',

      properties: {

        name: { type: 'string'}

      },

      required: ['name']

    },

    response: {

      200: {

        type: 'object',

        properties: {

          message: {type: 'string'}

        }

      }

    },

  },

  handler: async (request, reply) => {

    const { name } = request.body;

    reply.code(200).send({

      message: `Hello ${name}!`

    })

  }

})
```

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

### Basic Fastify Injection Test

Source: https://fastify.dev/docs/latest/Guides/Testing

Demonstrates using `fastify.inject` to make a fake GET request to the root route and log the response status code and body. This is a simple way to test routes without starting a real HTTP server.

```javascript
'use strict'



const build = require('./app')



const test = async () => {

  const app = build()



  const response = await app.inject({

    method: 'GET',

    url: '/'

  })



  console.log('status code: ', response.statusCode)

  console.log('body: ', response.body)

}

test()

```

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

### Create a Basic Fastify Server

Source: https://fastify.dev

Initialize a Fastify server instance and define a route.

```javascript
// Import the framework and instantiate it  

import Fastify from 'fastify'  

const fastify = Fastify({  

  logger: true  

})  

  

// Declare a route  

fastify.get('/', async function handler (request, reply) {  

  return { hello: 'world' }  

})  

  

// Run the server!  

try {  

  await fastify.listen({ port: 3000 })  

} catch (err) {  

  fastify.log.error(err)  

  process.exit(1)  

}
```

```javascript
'use strict'  

  

// Require the framework and instantiate it  

const fastify = require('fastify')({ logger: true })  

  

// Declare a route  

fastify.get('/', function handler (request, reply) {  

  reply.send({ hello: 'world' })  

})  

  

// Run the server!  

fastify.listen({ port: 3000 }, (err) => {  

  if (err) {  

    fastify.log.error(err)  

    process.exit(1)  

  }  

})
```

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

### Initialize Fastify server

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Configure the main server instance and register plugins for database connectivity and routes.

```javascript
// ESM

import Fastify from 'fastify'

import dbConnector from './our-db-connector.js'

import firstRoute from './our-first-route.js'



/**

 * @type {import('fastify').FastifyInstance} Instance of Fastify

 */

const fastify = Fastify({

  logger: true

})

fastify.register(dbConnector)

fastify.register(firstRoute)



fastify.listen({ port: 3000 }, function (err, address) {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

  // Server is now listening on ${address}

})
```

```javascript
// CommonJs

/**

 * @type {import('fastify').FastifyInstance} Instance of Fastify

 */

const fastify = require('fastify')({

  logger: true

})



fastify.register(require('./our-db-connector'))

fastify.register(require('./our-first-route'))



fastify.listen({ port: 3000 }, function (err, address) {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

  // Server is now listening on ${address}

})
```

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

### Create Portable Data Directories

Source: https://fastify.dev/docs/latest/Guides/Contributing

Sets up the necessary directories for user data and extensions.

```bash
mkdir -p /Applications/VSCodeFastify/code-portable-data/{user-data,extensions}
```

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

### Use Fastify CLI

Source: https://fastify.dev

Scaffold a new project using the Fastify CLI.

```bash
npm install --global fastify-cli  

  

fastify generate myproject
```

```bash
fastify generate myproject --lang=ts
```

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

### Install json-schema-to-typescript

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Install the development dependency required to transform JSON schemas into TypeScript interfaces.

```bash
npm i -D json-schema-to-typescript
```

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

### Initialize Plugin Project

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Commands to set up a new TypeScript project for a Fastify plugin.

```bash
npm init -y

npm i fastify fastify-plugin

npm i -D typescript @types/node
```

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

### serializerCompiler

Source: https://fastify.dev/docs/latest/Reference/Server

Property to get the schema serializer function.

```APIDOC
## serializerCompiler

### Description
Returns the schema serializer function. Signature: function ({ schema, method, url, httpPart }).
```

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

### validatorCompiler

Source: https://fastify.dev/docs/latest/Reference/Server

Property to get the schema validator function.

```APIDOC
## validatorCompiler

### Description
Returns the schema validator function. Signature: function ({ schema, method, url, httpPart }).
```

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

### Request Handling Logs During Startup

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Logs showing how the server handles incoming requests while in a non-ready state.

```json
{"time":1650063795030,"reqId":"req-1","req":{"method":"GET","url":"/v1","hostname":"localhost:1234","remoteAddress":"127.0.0.1","remotePort":51928},"msg":"incoming request"}

{"time":1650063795033,"reqId":"req-1","res":{"statusCode":503},"responseTime":2.5721680000424385,"msg":"request completed"}

{"time":1650063796248,"reqId":"req-2","req":{"method":"GET","url":"/ping","hostname":"localhost:1234","remoteAddress":"127.0.0.1","remotePort":51930},"msg":"incoming request"}

{"time":1650063796248,"reqId":"req-2","res":{"statusCode":200},"responseTime":0.4802369996905327,"msg":"request completed"}
```

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

### Define Schema Object

Source: https://fastify.dev/docs/latest/Reference/Request

Example of a schema object definition.

```javascript
const schema1 = {

  type: 'object',

  properties: {

    foo: {

      type: 'string'

    }

  }

}
```

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

### Create a Basic Server

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

A standard server implementation using either ESM or CommonJS syntax.

```javascript
// Require the framework and instantiate it



// ESM

import Fastify from 'fastify'



const fastify = Fastify({

  logger: true

})

// CommonJs

const fastify = require('fastify')({

  logger: true

})



// Declare a route

fastify.get('/', function (request, reply) {

  reply.send({ hello: 'world' })

})



// Run the server!

fastify.listen({ port: 3000 }, function (err, address) {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

  // Server is now listening on ${address}

})
```

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

### Handle server readiness with ready

Source: https://fastify.dev/docs/latest/Reference/Server

Uses the ready method to execute code once all plugins are loaded, supporting both callback and promise patterns.

```javascript
fastify.ready(err => {

  if (err) throw err

})
```

```javascript
fastify.ready().then(() => {

  console.log('successfully booted!')

}, (err) => {

  console.log('an error happened', err)

})
```

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

### Verify Extension Installation

Source: https://fastify.dev/docs/latest/Guides/Contributing

Checks if the ESLint extension directory exists.

```bash
[ -d /Applications/VSCodeFastify/code-portable-data/extensions/dbaeumer.vscode-eslint-* ] && echo "found"
```

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

### Retrieving All Headers

Source: https://fastify.dev/docs/latest/Reference/Reply

Gets a shallow copy of all current response headers.

```javascript
reply.header('x-foo', 'foo')

reply.header('x-bar', 'bar')

reply.raw.setHeader('x-foo', 'foo2')

reply.getHeaders() // { 'x-foo': 'foo', 'x-bar': 'bar' }
```

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

### Create Fastify Instance

Source: https://fastify.dev/docs/latest/Guides/Serverless

Initialize the Fastify instance and define the application handler to process requests.

```javascript
const fastify = require("fastify")({

  logger: true,

})



const fastifyApp = async (request, reply) => {

  await registerRoutes(fastify)

  await fastify.ready()

  fastify.server.emit("request", request, reply)

}
```

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

### Initialize Fastify Instance

Source: https://fastify.dev/docs/latest/Guides/Serverless

Basic initialization of the Fastify instance with logging enabled.

```javascript
const fastify = require("fastify")({

  logger: true // you can also define the level passing an object configuration to logger: {level: 'debug'}

});
```

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

### Verify VSCode Installation

Source: https://fastify.dev/docs/latest/Guides/Contributing

Checks if the VSCode application exists at the specified path.

```bash
[ -d /Applications/VSCodeFastify/Visual\ Studio\ Code.app ] && echo "found"
```

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

### Custom clientErrorHandler configuration

Source: https://fastify.dev/docs/latest/Reference/Server

Example of overriding the clientErrorHandler during Fastify instance initialization.

```javascript
const fastify = require('fastify')({

  clientErrorHandler: function (err, socket) {

    const body = JSON.stringify({

      error: {

        message: 'Client error',

        code: '400'

      }

    })



    // `this` is bound to fastify instance

    this.log.trace({ err }, 'client error')



    // the handler is responsible for generating a valid HTTP response

    socket.end([

      'HTTP/1.1 400 Bad Request',

      `Content-Length: ${body.length}`,

      `Content-Type: application/json\r\n\r\n${body}`

    ].join('\r\n'))

  }

})
```

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

### Create an Async/Await Server

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Server implementation utilizing async/await for route handlers and startup logic.

```javascript
// ESM

import Fastify from 'fastify'



const fastify = Fastify({

  logger: true

})

// CommonJs

const fastify = require('fastify')({

  logger: true

})



fastify.get('/', async (request, reply) => {

  return { hello: 'world' }

})



/**

 * Run the server!

 */

const start = async () => {

  try {

    await fastify.listen({ port: 3000 })

  } catch (err) {

    fastify.log.error(err)

    process.exit(1)

  }

}

start()
```

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

### Define JSON Schemas

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Example JSON schema definitions for headers and querystring parameters.

```json
{

  "title": "Headers Schema",

  "type": "object",

  "properties": {

    "h-Custom": { "type": "string" }

  },

  "additionalProperties": false,

  "required": ["h-Custom"]

}
```

```json
{

  "title": "Querystring Schema",

  "type": "object",

  "properties": {

    "username": { "type": "string" },

    "password": { "type": "string" }

  },

  "additionalProperties": false,

  "required": ["username", "password"]

}
```

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

### Retrieve server addresses

Source: https://fastify.dev/docs/latest/Reference/Server

Returns an array of addresses the server is currently listening on after it has started.

```javascript
await fastify.listen({ port: 8080 })

const addresses = fastify.addresses()

// [

//   { port: 8080, family: 'IPv6', address: '::1' },

//   { port: 8080, family: 'IPv4', address: '127.0.0.1' }

// ]
```

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

### Subscribe to Fastify Initialization Channel

Source: https://fastify.dev/docs/latest/Reference/Hooks

Use the 'fastify.initialization' channel to register hooks on the Fastify instance during startup.

```javascript
const tracer = /* retrieved from elsewhere in the package */

const dc = require('node:diagnostics_channel')

const channel = dc.channel('fastify.initialization')

const spans = new WeakMap()



channel.subscribe(function ({ fastify }) {

  fastify.addHook('onRequest', (request, reply, done) => {

    const span = tracer.startSpan('fastify.request.handler')

    spans.set(request, span)

    done()

  })



  fastify.addHook('onResponse', (request, reply, done) => {

    const span = spans.get(request)

    span.finish()

    done()

  })

})
```

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

### ready()

Source: https://fastify.dev/docs/latest/Reference/Server

Function called when all the plugins have been loaded.

```APIDOC
## ready(callback)

### Description
Function called when all the plugins have been loaded. It takes an error parameter if something went wrong.

### Parameters
- **callback** (Function) - Optional - A function to be executed when all plugins are loaded. If omitted, returns a Promise.
```

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

### Example validation error response

Source: https://fastify.dev/docs/latest/Reference/Validation-and-Serialization

The default JSON payload returned when request validation fails.

```json
{

  "statusCode": 400,

  "error": "Bad Request",

  "message": "body should have required property 'name'"

}
```

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

### HAProxy Backend for Domain 'two.fastify.example'

Source: https://fastify.dev/docs/latest/Guides/Recommendations

Configure a backend in HAProxy for 'two.fastify.example', distributing requests to servers 10.10.12.2 and 10.10.12.3 using round-robin.

```haproxy
backend example2-backend
  server example2-1 10.10.12.2:80
  server example2-2 10.10.12.2:80
  server example2-3 10.10.12.3:80
```

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

### Server Ready Log

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Log output indicating the server has completed initialization and is ready for customer requests.

```json
{"time":1650063798377,"reqId":"req-3","req":{"method":"POST","url":"/webhook","hostname":"localhost:1234","remoteAddress":"127.0.0.1","remotePort":51932},"msg":"incoming request"}

{"time":1650063798379,"reqId":"req-3","msg":"Ready for customer requests!"}

{"time":1650063798379,"reqId":"req-3","res":{"statusCode":200},"responseTime":1.3567829988896847,"msg":"request completed"}
```

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

### Configure Netlify Build Settings

Source: https://fastify.dev/docs/latest/Guides/Serverless

Define the build command and functions directory in netlify.toml.

```toml
[build]

  # This will be run the site build

  command = "npm run build:functions"

  # This is the directory is publishing to netlify's CDN

  # and this is directory of your front of your app

  # publish = "build"

  # functions build directory

  functions = "functions-build" # always appends `-build` folder to your `functions` folder for builds
```

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

### Implement a Plugin

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Demonstrates modularizing routes into separate files using the register API.

```javascript
// ESM

import Fastify from 'fastify'

import firstRoute from './our-first-route.js'

/**

 * @type {import('fastify').FastifyInstance} Instance of Fastify

 */

const fastify = Fastify({

  logger: true

})



fastify.register(firstRoute)



fastify.listen({ port: 3000 }, function (err, address) {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

  // Server is now listening on ${address}

})
```

```javascript
// CommonJs

/**

 * @type {import('fastify').FastifyInstance} Instance of Fastify

 */

const fastify = require('fastify')({

  logger: true

})



fastify.register(require('./our-first-route'))



fastify.listen({ port: 3000 }, function (err, address) {

  if (err) {

    fastify.log.error(err)

    process.exit(1)

  }

  // Server is now listening on ${address}

})
```

```javascript
// our-first-route.js



/**

 * Encapsulates the routes

 * @param {FastifyInstance} fastify  Encapsulated Fastify Instance

 * @param {Object} options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options

 */

async function routes (fastify, options) {

  fastify.get('/', async (request, reply) => {

    return { hello: 'world' }

  })

}



//ESM

export default routes;



// CommonJs

module.exports = routes
```

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

### Open Project in VSCode

Source: https://fastify.dev/docs/latest/Guides/Contributing

Launches the portable VSCode instance in the current directory.

```bash
code-fastify .
```

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

### fastify<RawRequest, RawReply, Logger>(opts?: FastifyServerOptions)

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Initializes a new Fastify server instance. The type system automatically infers the server type (HTTP, HTTPS, or HTTP2) based on the provided options.

```APIDOC
## fastify(opts)

### Description
Initializes a new Fastify server instance. This method supports generic types to extend the underlying Node.js Server, Request, and Reply objects.

### Parameters
- **opts** (FastifyServerOptions) - Optional - Configuration object for the server, including settings for https, http2, and logger.

### Usage Example
```typescript
import fastify from 'fastify'

// Standard HTTP server
const server = fastify()

// HTTPS server
const httpsServer = fastify({
  https: {
    key: fs.readFileSync('key.pem'),
    cert: fs.readFileSync('cert.pem')
  }
})

// HTTP2 server
const http2Server = fastify({ http2: true })
```
```

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

### Fastify Server Decoration

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Initializes a placeholder decoration on the Fastify server instance.

```javascript
  fastify.decorate('magicKey')
```

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

### Connect to Postgres with @fastify/postgres

Source: https://fastify.dev/docs/latest/Guides/Database

Register the Postgres plugin and execute queries using the pg client instance.

```javascript
const fastify = require('fastify')()

fastify.register(require('@fastify/postgres'), {
  connectionString: 'postgres://postgres@localhost/postgres'
})

fastify.get('/user/:id', function (req, reply) {
  fastify.pg.query(
    'SELECT id, username, hash, salt FROM users WHERE id=$1', [req.params.id],
    function onResult (err, result) {
      reply.send(err || result)
    }
  )
})

fastify.listen({ port: 3000 }, err => {
  if (err) throw err
  console.log(`server listening on ${fastify.server.address().port}`)
})
```

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

### Decorator Encapsulation Example

Source: https://fastify.dev/docs/latest/Reference/Decorators

Demonstrates how decorators can be redefined within encapsulated plugin contexts without causing errors.

```APIDOC
## Decorator Encapsulation

Defining a decorator (using `decorate`, `decorateRequest`, or `decorateReply`) with the same name more than once in the same **encapsulated** context will throw an exception. However, decorators can be redefined within different encapsulated plugin contexts.

### Example of Redefining Decorators within Encapsulation

```javascript
const fastify = require('fastify')()

// Initial decorator definition
fastify.decorateReply('view', function (template, args) {
  // Amazing view rendering engine
})

fastify.get('/', (req, reply) => {
  reply.view('/index.html', { hello: 'world' })
})

// Registering a plugin with a new encapsulated context
fastify.register(async function (server, opts) {
  // Redefining the 'view' decorator within this encapsulated plugin
  // This will not throw an error because it's in a different context.
  server.decorateReply('view', function (template, args) {
    // Another rendering engine
  })

  server.get('/', (req, reply) => {
    reply.view('/index.page', { hello: 'world' })
  })
}, { prefix: '/bar' })

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

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

### Define server.js file

Source: https://fastify.dev/docs/latest/Guides/Getting-Started

Create a server file that exports an async function to define routes.

```javascript
// server.js

'use strict'



module.exports = async function (fastify, opts) {

  fastify.get('/', async (request, reply) => {

    return { hello: 'world' }

  })

}
```

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

### Define a route with schema and handler

Source: https://fastify.dev/docs/latest/Reference/Routes

Configures a GET route with request query validation and response serialization schemas.

```javascript
fastify.route({

  method: 'GET',

  url: '/',

  schema: {

    querystring: {

      type: 'object',

      properties: {

        name: { type: 'string' },

        excitement: { type: 'integer' }

      }

    },

    response: {

      200: {

        type: 'object',

        properties: {

          hello: { type: 'string' }

        }

      }

    }

  },

  handler: function (request, reply) {

    reply.send({ hello: 'world' })

  }

})
```

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

### Implement TypeScript Fastify Plugin

Source: https://fastify.dev/docs/latest/Reference/TypeScript

Example of using declaration merging to extend Fastify interfaces and defining plugin logic.

```typescript
import { FastifyPluginCallback, FastifyPluginAsync } from 'fastify'

import fp from 'fastify-plugin'



// using declaration merging, add your plugin props to the appropriate fastify interfaces

// if prop type is defined here, the value will be typechecked when you call decorate{,Request,Reply}

declare module 'fastify' {

  interface FastifyRequest {

    myPluginProp: string

  }

  interface FastifyReply {

    myPluginProp: number

  }

}



// define options

export interface MyPluginOptions {

  myPluginOption: string

}



// define plugin using callbacks

const myPluginCallback: FastifyPluginCallback<MyPluginOptions> = (fastify, options, done) => {

  fastify.decorateRequest('myPluginProp', 'super_secret_value')

  fastify.decorateReply('myPluginProp', options.myPluginOption)



  done()

}



// define plugin using promises

const myPluginAsync: FastifyPluginAsync<MyPluginOptions> = async (fastify, options) => {

  fastify.decorateRequest('myPluginProp', 'super_secret_value')

  fastify.decorateReply('myPluginProp', options.myPluginOption)

}



// export plugin using fastify-plugin

export default fp(myPluginCallback, '3.x')

// or

// export default fp(myPluginAsync, '3.x')
```

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

### Reply Object Usage

Source: https://fastify.dev/docs/latest/Reference/Reply

Example of using the Reply object to set a status code, headers, and send a JSON response.

```APIDOC
fastify.get('/', options, function (request, reply) {
  reply
    .code(200)
    .header('Content-Type', 'application/json; charset=utf-8')
    .send({ hello: 'world' })
})
```

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

### Deploy and Manage Function

Source: https://fastify.dev/docs/latest/Guides/Serverless

Commands for deploying the function to Google Cloud and reading logs.

```bash
gcloud functions deploy fastifyFunction \

--runtime nodejs14 --trigger-http --region $GOOGLE_REGION --allow-unauthenticated
```

```bash
gcloud functions logs read
```

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

### Configure listen with custom log resolver

Source: https://fastify.dev/docs/latest/Reference/Server

Use the listenTextResolver option to customize the log message displayed after the server starts.

```javascript
server.listen({

  port: 9080,

  listenTextResolver: (address) => { return `Prometheus metrics server is listening at ${address}` }

})
```

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

### Register onListen hook

Source: https://fastify.dev/docs/latest/Reference/Hooks

Executes when the server starts listening. Errors in this hook are logged and ignored, allowing the queue to continue.

```javascript
// callback style

fastify.addHook('onListen', function (done) {

  // Some code

  const err = null;

  done(err)

})



// or async/await style

fastify.addHook('onListen', async function () {

  // Some async code

})
```

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

### Create a custom database plugin

Source: https://fastify.dev/docs/latest/Guides/Database

Implement a custom Fastify plugin to integrate third-party database libraries like Knex.

```javascript
'use strict'

const fp = require('fastify-plugin')
const knex = require('knex')

function knexPlugin(fastify, options, done) {
  if(!fastify.knex) {
    const knex = knex(options)
    fastify.decorate('knex', knex)

    fastify.addHook('onClose', (fastify, done) => {
      if (fastify.knex === knex) {
        fastify.knex.destroy(done)
      }
    })
  }

  done()
}

export default fp(knexPlugin, { name: 'fastify-knex-example' })
```

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

### Decorators with Dependencies

Source: https://fastify.dev/docs/latest/Reference/Decorators

Illustrates how to define decorators that depend on other decorators. The 'utility' decorator relies on 'greet' and 'hi'. Dependencies are checked before server startup.

```javascript
async function greetDecorator (fastify, opts) {
  fastify.decorate('greet', () => {
    return 'greet message'
  })
}

async function hiDecorator (fastify, opts) {
  fastify.decorate('hi', () => {
    return 'hi message'
  })
}

async function utilityDecorator (fastify, opts) {
  fastify.decorate('utility', () => {
    return `${fastify.greet()} | ${fastify.hi()}`
  })
}

fastify.register(fastifyPlugin(greetDecorator, { name: 'greet' }))
fastify.register(fastifyPlugin(hiDecorator, { name: 'hi' }))
fastify.register(fastifyPlugin(utilityDecorator, { dependencies: ['greet', 'hi'] }))

fastify.get('/', function (req, reply) {
  reply.send({ hello: fastify.utility() })
})

fastify.listen({ port: 3000 }, (err, address) => {
  if (err) throw err
})
```

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

### Define Duplicate Decorator in Same Context

Source: https://fastify.dev/docs/latest/Reference/Decorators

Defining a decorator with the same name more than once within the same encapsulated context will throw an exception. This example demonstrates such a scenario.

```javascript
const server = require('fastify')()



server.decorateReply('view', function (template, args) {

  // Amazing view rendering engine

})



server.get('/', (req, reply) => {

  reply.view('/index.html', { hello: 'world' })

})



// Somewhere else in our codebase, we define another

// view decorator. This throws.

server.decorateReply('view', function (template, args) {

  // Another rendering engine

})



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

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

### Configure Fastify for Google Cloud Run

Source: https://fastify.dev/docs/latest/Guides/Serverless

Adjust the server to listen on the port provided by the environment and bind to all IPv4 addresses.

```javascript
function build() {

  const fastify = Fastify({ trustProxy: true })

  return fastify

}



async function start() {

  // Google Cloud Run will set this environment variable for you, so

  // you can also use it to detect if you are running in Cloud Run

  const IS_GOOGLE_CLOUD_RUN = process.env.K_SERVICE !== undefined



  // You must listen on the port Cloud Run provides

  const port = process.env.PORT || 3000



  // You must listen on all IPV4 addresses in Cloud Run

  const host = IS_GOOGLE_CLOUD_RUN ? "0.0.0.0" : undefined



  try {

    const server = build()

    const address = await server.listen({ port, host })

    console.log(`Listening on ${address}`)

  } catch (err) {

    console.error(err)

    process.exit(1)

  }

}



module.exports = build



if (require.main === module) {

  start()
}
```

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

### Delay Plugin Implementation

Source: https://fastify.dev/docs/latest/Guides/Delay-Accepting-Requests

Defines the logic for delaying requests using an onRequest hook and a setup function to initialize the magic key.

```javascript
const fp = require('fastify-plugin')



const provider = require('./provider')



const USUAL_WAIT_TIME_MS = 5000



async function setup(fastify) {

  // As soon as we're listening for requests, let's work our magic

  fastify.server.on('listening', doMagic)



  // Set up the placeholder for the magicKey

  fastify.decorate('magicKey')



  // Our magic -- important to make sure errors are handled. Beware of async

  // functions outside `try/catch` blocks

  // If an error is thrown at this point and not captured it'll crash the

  // application

  function doMagic() {

    fastify.log.info('Doing magic!')



    provider.thirdPartyMagicKeyGenerator(USUAL_WAIT_TIME_MS)

      .catch((error) => {

        fastify.log.error({

          error,

          message: 'Got an error while trying to get the magic key!'

        })



        // Since we won't be able to serve requests, might as well wrap

        // things up

        fastify.close(() => process.exit(1))

      })

  }

}



const delay = (routes) =>

  function (fastify, opts, done) {

    // Make sure customer requests won't be accepted if the magicKey is not

    // available

    fastify.addHook('onRequest', function (request, reply, next) {

      if (!request.server.magicKey) {

        reply.statusCode = 503

        reply.header('Retry-After', USUAL_WAIT_TIME_MS)

        reply.send({ error: true, retryInMs: USUAL_WAIT_TIME_MS })

      }



      next()

    })



    // Register to-be-delayed routes

    fastify.register(routes, opts)



    done()

  }



module.exports = {

  setup: fp(setup),

  delay,

}
```

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

### Initialize Fastify for Lambda and Local Execution

Source: https://fastify.dev/docs/latest/Guides/Serverless

Exports an initialization function for Lambda usage while maintaining local server capabilities via require.main check.

```javascript
const fastify = require('fastify');



function init() {

  const app = fastify();

  app.get('/', (request, reply) => reply.send({ hello: 'world' }));

  return app;

}



if (require.main === module) {

  // called directly i.e. "node app"

  init().listen({ port: 3000 }, (err) => {

    if (err) console.error(err);

    console.log('server listening on 3000');

  });

} else {

  // required as a module => executed on aws lambda

  module.exports = init;

}
```

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

### Customizing Query String Parsing

Source: https://fastify.dev/docs/latest/Reference/Server

Examples of using custom parsers like 'qs' or modifying the default 'fast-querystring' behavior for case-insensitive keys.

```javascript
const qs = require('qs')

const fastify = require('fastify')({

  routerOptions: {

    querystringParser: str => qs.parse(str)

  }

})
```

```javascript
const querystring = require('fast-querystring')

const fastify = require('fastify')({

  routerOptions: {

    querystringParser: str => querystring.parse(str.toLowerCase())

  }

})
```

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

### Handle asynchronous responses in hooks

Source: https://fastify.dev/docs/latest/Reference/Hooks

Examples of returning the reply object when sending responses asynchronously outside the promise chain or via plugins.

```javascript
fastify.addHook('preHandler', async (request, reply) => {

  setImmediate(() => { reply.send('hello') })



  // This is needed to signal the handler to wait for a response

  // to be sent outside of the promise chain

  return reply

})



fastify.addHook('preHandler', async (request, reply) => {

  // the @fastify/static plugin will send a file asynchronously,

  // so we should return reply

  reply.sendFile('myfile')

  return reply

})
```
Tokens:
Raw