Introdução ao Fastify: Construindo uma API Simples

Introdução;

Fastify é um framework web para Node.js que se concentra em fornecer uma solução de alto desempenho e baixa sobrecarga para a construção de aplicações web e APIs. Ele é projetado para ser simples de usar, enquanto oferece recursos poderosos que o tornam ideal para uma ampla gama de casos de uso. O Fastify possui benchmark de velocidade impressionantes e é conhecido por sua capacidade de lidar com altas cargas de forma eficiente.

Vantagens do Fastify:

• Desempenho: O Fastify é construído com um foco em velocidade, tornando-se um dos frameworks web mais rápidos disponíveis para Node.js. Sua baixa sobrecarga e arquitetura eficiente contribuem para tempos de resposta reduzidos e melhor desempenho geral.
• Validação Baseada em Esquema: O Fastify fornece suporte embutido para validação baseada em esquema de payloads de requisição e resposta. Isso permite que os desenvolvedores definam expectativas claras para os dados recebidos, levando a uma maior confiabilidade e segurança.
• Extensibilidade: O Fastify é altamente extensível, permitindo que os desenvolvedores adicionem facilmente plugins e middleware personalizados para aprimorar a funcionalidade de suas aplicações. Isso o torna adaptável a uma ampla gama de requisitos de projeto.
• Suporte Assíncrono: O Fastify abraça totalmente padrões de programação assíncrona, tornando-o bem adequado para lidar com operações limitadas por I/O de forma eficiente. Ele aproveita recursos modernos do JavaScript, como async/await, para simplificar o código assíncrono.
• Amigável para Desenvolvedores: Com sua API intuitiva e documentação abrangente, o Fastify procura oferecer uma experiência amigável para desenvolvedores. Ele oferece uma sintaxe clara e concisa, tornando fácil de entender e usar tanto para iniciantes quanto para desenvolvedores experientes.

O que será abordado neste tutorial:

Neste tutorial, abordaremos o básico do uso do Fastify para construir uma API simples. Começando pela configuração de um projeto Fastify, exploraremos gradualmente seus principais recursos, incluindo manipulação de rotas, validação de requisições, middleware, tratamento de erros, testes e implantação. Ao final do tutorial, você terá uma compreensão sólida de como usar o Fastify para criar aplicações web robustas e eficientes.

Pré-requisitos

Antes de começarmos, certifique-se de ter os seguintes pré-requisitos instalados:

1. Node.js e npm: O Fastify requer que o Node.js e o npm estejam instalados em seu sistema. Você pode baixá-los e instalá-los a partir do site oficial do Node.js.
2. Conhecimento Básico de JavaScript e Node.js: Este tutorial assume que você possui um entendimento básico de JavaScript e de como trabalhar com Node.js. Familiaridade com conceitos como callbacks, promises e módulos será benéfica enquanto exploramos os recursos do Fastify.

Com esses pré-requisitos atendidos, você está pronto para mergulhar na construção com o Fastify! Vamos começar.

Configurando o Fastify

Instalando o Fastify via npm

Para começar com o Fastify, você primeiro precisará instalá-lo via npm, que é o gerenciador de pacotes para Node.js. Se você é fã do Yarn ou Bun, você também pode tentar usá-los. Para este guia, eu usarei o NPM.

E caso você não saiba, ou não entenda completamente como usar o NPM, você pode dar uma olhada neste tutorial sobre como se familiarizar com ele.

Para começar, crie uma nova pasta, digamos, na sua área de trabalho ou no seu diretório de trabalho onde você gostaria de configurar o projeto do Fastify.

Para fazer isso, basta executar o seguinte código no seu terminal, passo a passo seguindo um após o outro

mkdir meu-projeto-fastify
cd meu-projeto-fastify

Agora, você criou uma pasta e se mudou para essa pasta a partir do seu terminal. Bom trabalho!

A seguir, inicialize o npm para esse projeto e instale o framework Fastify.

npm init -y
npm install fastify

A esta altura, seu projeto consiste apenas no arquivo package.json, package-lock.json e node_modules, que contém metadados sobre seu projeto e suas dependências. À medida que continuamos construindo nossa aplicação Fastify, adicionaremos mais arquivos e diretórios a essa estrutura.

Criando um Servidor Simples

Configurando um servidor Fastify básico

Agora que temos nosso projeto configurado, vamos criar um servidor Fastify simples. Crie um novo arquivo chamado index.js no diretório do seu projeto e adicione o seguinte código:

// Importando o módulo Fastify
const fastify = require('fastify')();

// Definindo um manipulador de rota para a URL raiz
fastify.get('/', async (request, reply) => {
  return { hello: 'mundo' };
});

// Iniciar o servidor
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log('Servidor está rodando em http://localhost:3000');
  } catch (error) {
    console.error('Erro ao iniciar o servidor:', error);
    process.exit(1);
  }
};

start();

Este código configura um servidor Fastify básico que escuta requisições HTTP recebidas na porta 3000. Quando uma requisição é feita para a URL raiz (/), ela responde com um objeto JSON contendo a mensagem "hello": "mundo".

Para que o código a seguir funcione, precisamos informá-lo para rodar. Como podemos fazer isso? Bem, podemos executar node index.js no nosso terminal na pasta raiz do projeto e funcionará.

Mas isso significaria que teríamos que executar esse comando sempre que fizermos uma atualização no arquivo. Não queremos esse estresse. Devemos ser capazes de salvar o arquivo e automaticamente acionar a reconstrução. Como podemos fazer isso?
Bem, aí entra o Nodemon.

Para instalar o Nodemon, simplesmente execute o seguinte código no terminal;
npm install nodemon --save-dev.
Isso instalará o Nodemon e poderemos nos concentrar em nosso código sem precisar pedí-lo para recriar manualmente.

Mas ainda não terminamos com o Nodemon. Prometo que este é o último trecho de código que configuraremos para o Nodemon. O que precisamos fazer? Precisamos informá-lo para acionar automaticamente sempre que salvamos um arquivo. Como fazemos isso?

Abra seu arquivo package.json e substitua a seção script pelo seguinte código:

 "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "echo \"Erro: nenhum teste especificado\" && exit 1"
  },

E lá vamos nós! Terminamos a configuração do Nodemon, prometo!

Agora, para iniciar nosso servidor, precisamos executar npm run dev no nosso diretório raiz do projeto. Uma vez feito isso, navegue até o seu navegador e digite http://localhost:3000/ - você verá nossa resposta de exemplo hello mundo como definimos no nosso arquivo index.js acima.

Adicionando rotas para lidar com diferentes métodos HTTP (GET, POST, etc.)

O Fastify facilita a construção de APIs REST / definir rotas para manipular diferentes métodos HTTP, como GET, POST, PUT, DELETE, etc. Vamos adicionar uma rota para lidar com uma requisição POST. Atualize seu arquivo index.js com o seguinte código:

// Define um manipulador de rota para lidar com requisições POST para '/data'
fastify.post('/data', async (request, reply) => {
  const payload = request.body;
  // Processar os dados recebidos
  // Por enquanto, vamos apenas retornar os dados recebidos
  return { receivedData: payload };
});

Agora, nosso servidor Fastify pode lidar tanto com requisições GET para a URL raiz (/) quanto com requisições POST para o endpoint /data.

Respondendo com dados JSON

Em ambos os manipuladores de rota que definimos ('/' e '/data'), estamos respondendo com dados JSON usando os métodos de resposta integrados do Fastify. O Fastify automaticamente serializa objetos JavaScript para JSON, facilitando o envio de dados estruturados como respostas.

Com essas adições, nosso servidor Fastify agora é capaz de lidar com requisições HTTP básicas e responder com dados JSON.

Mas como testamos a requisição POST? Não podemos testar uma requisição POST a partir do navegador, podemos?
Para nos ajudar, usaremos o Apidog.

Você pode se inscrever para uma conta gratuita, experimentar a interface web ou baixar o aplicativo desktop para testar suas novas APIs criadas.

Para ajudá-lo a entender como usar o Apidog, aqui está um guia bem escrito. Para pular a conversa longa e a leitura, você pode dar uma olhada por esta seção - esta é a mais importante para nós agora.

Se você seguiu o guia acima, deve estar familiarizado com o Apidog em grande medida.

Toque na requisição da página do projeto, e você poderá testar a API que criamos a partir do servidor Fastify.

Como você pode ver na captura de tela acima, você precisará definir o método HTTP como POST, inserir a URL correta (certifique-se de que seu servidor ainda está rodando), e inserir seu payload no corpo.

Seguir as etapas acima corretamente lhe dará um código de resposta 200, e você poderá ver a resposta.

Se tudo correr bem para você, deve obter a mesma resposta que eu tive.

Middleware e Plugins

Introdução ao Middleware no Fastify

Funções de middleware no Fastify são funções que têm acesso aos objetos de requisição e resposta e podem realizar tarefas como registro, autenticação, análise de dados, etc., antes de passar o controle para a próxima função de middleware ou manipulador de rota. As funções de middleware são executadas na ordem em que são adicionadas ao pipeline da aplicação.

Criando Funções de Middleware Personalizadas

Você pode criar funções de middleware personalizadas no Fastify definindo funções que aceitam os parâmetros request, reply e next. Aqui está um exemplo de middleware de registro personalizado:

// Middleware de registro personalizado
const loggerMiddleware = async (request, reply, next) => {
  console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
  next();
};

// Registrar middleware com o Fastify
fastify.use(loggerMiddleware);

Neste exemplo, a função loggerMiddleware registra o timestamp, o método HTTP e a URL de cada requisição recebida. Em seguida, chama a função next() para passar o controle para a próxima função de middleware ou manipulador de rota.

Assim é como o Middleware funciona completamente no Node.js e em seus outros frameworks, como o Express.js.

Instalando e Usando Plugins do Fastify

O Fastify fornece um rico ecossistema de plugins que estendem sua funcionalidade para vários propósitos, como autenticação, integração com banco de dados, validação, etc. Você pode instalar e usar plugins do Fastify via npm. Aqui está como instalar um plugin e registrá-lo no Fastify:

npm install fastify-auth fastify-cors

// Importar plugins necessários
const fastifyAuth = require('fastify-auth');
const fastifyCors = require('fastify-cors');

// Registrar plugins com o Fastify
fastify.register(fastifyAuth);
fastify.register(fastifyCors);

Neste exemplo, instalamos e registramos dois plugins: fastify-auth para autenticação e fastify-cors para suporte a Compartilhamento de Recursos entre Diferentes Origens (CORS).

Mas espere. Não vamos testar isso. Esses são apenas exemplos que mostram como instalar e executar middleware e plugins no Fastify.

Aqui está um artigo para aprender mais sobre middleware e plugins. Você pode fazer sua própria pesquisa e descobertas. Só não se confunda. Middleware no Node.js e Fastify é um tópico amplo.

Tratamento de Erros

Tratando Erros nas Rotas do Fastify

No Fastify, você pode tratar erros em manipuladores de rota lançando erros ou retornando-os de funções assíncronas. O Fastify captura automaticamente esses erros e envia uma resposta de erro apropriada para o cliente. Aqui está um exemplo:

// Manipulador de rota com tratamento de erro
fastify.get('/error', async (request, reply) => {
  // Simular um erro
  throw new Error('Ops! Algo deu errado.');
});

De acordo com esse exemplo, se um usuário navegar até uma /error que não existe ou algo assim, podemos lançar um erro e deixar o usuário saber o que está acontecendo.

Se você está curioso (e deve estar), aqui está um artigo para aprender mais sobre Erros.

Aproveitando as funções de middleware, plugins e os recursos de tratamento de erros no Fastify, você pode aprimorar a funcionalidade e a confiabilidade de suas aplicações web e APIs. Esses recursos permitem que você modularize seu código, adicione componentes reutilizáveis e trate erros de maneira elegante, levando a aplicações mais manuteníveis e robustas.

Conclusão

Neste tutorial, abordamos uma introdução abrangente ao Fastify, um framework web rápido e de baixa sobrecarga para Node.js. Aqui está um resumo dos principais tópicos que exploramos:

1. Introdução ao Fastify: Começamos discutindo o Fastify e suas vantagens sobre outros frameworks Node.js, incluindo seus benefícios de desempenho, API fácil de usar e rico ecossistema de plugins.
2. Configurando o Fastify: Passamos pelo processo de instalação do Fastify usando o npm, inicializando um novo projeto Fastify e explorando a estrutura do projeto. Isso estabeleceu a base para construir aplicações Fastify.
3. Criando um Servidor Simples: Demonstramos como configurar um servidor Fastify básico, adicionar rotas para lidar com diferentes métodos HTTP e responder com dados JSON. Isso ilustrou a simplicidade e flexibilidade de definir rotas e lidar com requisições no Fastify.
4. Middleware e Plugins: Apresentamos o conceito de middleware no Fastify e mostramos como criar funções de middleware personalizadas. Além disso, discutimos como estender a funcionalidade do Fastify com plugins, instalando e usando-os para adicionar recursos, como autenticação e suporte a CORS.
5. Tratamento de Erros: Abordamos o tratamento de erros no Fastify, incluindo como tratar erros em rotas, usar os recursos de tratamento de erro integrados do Fastify e implementar lógica de tratamento de erro personalizada para gerenciar exceções e fornecer respostas de erro significativas para os clientes.

Através deste tutorial, você adquiriu o conhecimento para começar a construir aplicações web e APIs com o Fastify. Você aprendeu sobre os recursos principais do Fastify, como lidar com requisições e respostas, estender o framework com plugins e gerenciar erros de forma eficaz. Com essas habilidades, você está bem equipado para explorar recursos mais avançados do Fastify e criar aplicações web eficientes e escaláveis.

À medida que você continua a trabalhar com o Fastify, lembre-se de explorar a extensa documentação e o ecossistema de plugins disponível. A comunidade Fastify é ativa e de apoio, oferecendo uma riqueza de recursos para ajudá-lo a avançar em suas habilidades e construir aplicações robustas.

Obrigado por acompanhar este tutorial sobre Fastify. Boas codificações!