Usando Fastify no lugar do Express
Tags: braziliandevs, express, fastify
Published: 2021-08-19 19:37:17

Todo novo desenvolvedor que entra no mundo NODE(gosto de dizer mundo, pq o node é muita coisa) aprende logo de inicio a instalar o servidor(que estende o padrão do Node) expressJS. 

Express é ótimo. 
Express tem boa documentação 
Express tem muito material de tutoriais. 
Express tem muita pergunta no stackoverflow(isso é importante)

Tudo em node(relacionado a API e sites) muitos materiais com express. 

Se você procurar no google por expressjs vai ter como resposta mais de 3 milhões de resultados 

Expressjs esta em tudo. 

Mas eu vim aqui para passar a palavra do Fastify 

Fastify é um servidor web(que estende o servidor padrão do node)
Em miúdos. Ele faz exatamente a mesma coisa que o express. 

Só que mais rápido(segundo os devs do fastify). 

Além de usar a arquitetura de middleware(caso você sinta saudades do express)

Isso não é uma comparação de qual é o melhor! 
Nada disso. É apenas mostrar uma alternativa!
Fastify É inspirado no Hapi e no Express. 

Eu gostei dele pela velocidade(no que eu precisei)
E este é o mote de propaganda dele. Velocidade! Tem os testes no site deles. 

Gostei do uso de schema(são meio chato de fazer, mas muito bons depois :). Te ajuda muito. 

Basta criar um arquivo de nome qualquer 
colar o código abaixo e mandar rodar. 

estes códigos são do site oficial do fastify
```javascript

// Require the framework and instantiate it
const fastify = require('fastify')({ logger: true })

// Declare a route
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
})

// Run the server!
const start = async () => {
  try {
    await fastify.listen(3000)
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()
```
Pronto, já pode testar a /. 

Agora vamos por validações com schema

```javascript

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

fastify.route({
  method: 'GET',
  url: '/',
  schema: {
    // request needs to have a querystring with a `name` parameter
    querystring: {
      name: { type: 'string' }
    },
    // the response needs to be an object with an `hello` property of type 'string'
    response: {
      200: {
        type: 'object',
        properties: {
          hello: { type: 'string' }
        }
      }
    }
  },
  // this function is executed for every request before the handler is executed
  preHandler: async (request, reply) => {
    // E.g. check authentication
  },
  handler: async (request, reply) => {
    return { hello: 'world' }
  }
})

const start = async () => {
  try {
    await fastify.listen(3000)
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()

```
Mas não é só isso! 
Fastify é todo assíncrono! 
Tem ganchos que ajudam muito. 
Você pode validar algo antes de chegar a qualquer rota. Parecido com o use do Express. 
Declarando rotas com array.
```javascript 
 

const routes = [{
        method: 'GET',
        url: '/api/qualquercoisa',
        preHandler:[pre1, pre2, pre3],
        OutroHook:[outro,outro],
        schema: seuSchema
        handler:seuHandler
    },
   
]
module.exports = minharota

```
Isso é só o começo! 

```javascript 

const blogRoutes = require('./routes/minharota')
minhasrotas.forEach((route, index) => {
    app.route(route)
})

```
Criando um plugin! 

```javascript 

module.exports = function (fastify, opts, done) {
  fastify.decorate('utility', () => {})

  fastify.get('/', handler)

  done()
}
```

Tem muito mais plugins prontinhos pra você usar! 

De resto é muito parecido com outros servidores! 

Quero em breve postar mais algumas coisas sobre o fastify!