Aide-mémoire Fastify

Fastify est un framework web performant et léger conçu pour offrir une excellente expérience de développement et un débit maximal.

Démarrage rapide

Introduction et Documentation

Fastify délivre des performances remarquables grâce à la compilation basée sur les schémas et une architecture modulaire de plugins.

• Fastify Source Code (github.com)
• Fastify Documentation (fastify.dev)

Exemple Hello World

const fastify = require('fastify')()

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

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

Routage (Routing)

Déclaration de route

fastify.route({
  method: 'GET',
  url: '/',
  schema: { ··· },
  handler: (req, reply) => { ··· },
  beforeHandler: (req, reply, done) => { ··· }
})

Méthodes raccourcies (Shorthand)

fastify.get(path, [options], handler)
fastify.head(path, [options], handler)
fastify.post(path, [options], handler)
fastify.put(path, [options], handler)
fastify.delete(path, [options], handler)
fastify.options(path, [options], handler)
fastify.patch(path, [options], handler)

Gestionnaires Async / Await

fastify.get('/', options, async (req, reply) => {
  return data
  // or
  reply.send(data)
})

Avec les gestionnaires asynchrones, vous pouvez simplement retourner la charge utile ou appeler reply.send(data).

Requête et Réponse (Request & Reply)

Objet Request

request.query
request.body
request.params
request.headers
request.req  // Node.js core incoming request
request.log.info('hello')

See: Request.

Objet Reply

En-têtes de réponse

reply.code(404)
reply.header('Content-Type', 'text/html')
reply.type('text/html')

Redirections

reply.redirect('/foo')
reply.redirect(302, '/foo')

Envoi de données

reply.send(payload)
reply.sent // → true|false

See: Reply.

Validation de schéma JSON

Définition du schéma

const schema = {
  querystring: {
    name: { type: 'string' },
    excitement: { type: 'integer' }
  },
  response: {
    200: {
      type: 'object',
      properties: {
        hello: { type: 'string' }
      }
    }
  }
}

Passage du schéma à la route

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

Objet d'options de route

fastify.route({
  method: 'GET',
  url: '/',
  schema,
  handler: (req, reply) => { ··· }
})

Définir un schéma JSON active une validation à très haute vitesse et une sérialisation accélérée.

See: Validation and Serialization.

Architecture des Plugins

Enregistrer une fonction en plugin

fastify.register(
  require('./route'),
  err => { if (err) throw err }
)

route.js

module.exports = (fastify, options, next) => {
  fastify.get('/', (req, reply) => { ··· })
  next()
}

See: Plugins.

Enregistrer plusieurs plugins

fastify.register([
  require('./another-route'),
  require('./yet-another-route')
], opts, (err) => {
  if (err) throw err
})

Préfixes de routes

fastify.register(
  require('./route'),
  { prefix: '/v1' }
)

Les préfixes seront automatiquement ajoutés à toutes les routes déclarées dans le contexte de ce plugin.

Utilitaire fastify-plugin

const fp = require('fastify-plugin')

module.exports = fp((fastify, opts, next) => {
  fastify.decorate('utility', () => {})
  next()
}, '0.x')

Permet aux plugins d'outrepasser l'encapsulation de portée et de partager des décorateurs avec les portées parentes.

Middlewares et Modèles

Intégration de middlewares

fastify.use(require('cors')())
fastify.use(require('dns-prefetch-control')())
fastify.use(require('frameguard')())
fastify.use(require('hide-powered-by')())
fastify.use(require('hsts')())
fastify.use(require('ienoopen')())
fastify.use(require('x-xss-protection')())