DEV Community: Gabriel Valin

Why should you consider Fastify for your Node.JS app

Gabriel Valin — Mon, 02 Jun 2025 18:02:39 +0000

Nowadays most developers uses express by default to build a new Node.JS app. It's is popular, easy to use and even Nest.JS uses it behind the scenes.

But if you take a look at the Fastify docs, you’ll see that it works quite differently from Express:

Fastify uses fast-json-stringify by Matteo Collina with built-in functions based on schemas for serialize objects too fast
Fastify uses a radix tree for routing - a compact and optimized tree built during server setup.
It’s minimalist, with a strong focus on core performance
Native validation using JSON Schema via Ajv

Express working as well but for optimization...

Express uses JSON.stringify for serialize objects
Linear routing based on route definition
Minimalist but depends on directly middlewares
No native validation

Below, you can see two files with simple implementations using Express and Fastify.I also ran a quick benchmark with Autocannon, and here are the results:

Express might feel comfortable, but give Fastify a try at least once.

Ref:

https://fastify.dev/docs/v2.15.x/Documentation/Server/
https://ankitpandeycu.medium.com/unleashing-the-potential-of-radix-tree-35e6c5d3b49d
https://www.npmjs.com/package/fast-json-stringify
https://fastify.dev/benchmarks/

Mocking Interface with jest-mock-extended

Gabriel Valin — Thu, 03 Nov 2022 15:27:16 +0000

Objetivo

Se você está cansado de mockar classes concretas, criar classes ou funções para usar de mock, essas duas funções abaixo vão te ajudar de uma maneira bem inteligente e prática.

Situação

Precisamos testar um serviço que vai nos retornar uma lista de usuários.

Fluxo do sistema

Testes

Muitas das vezes, criamos algum tipo de módulo/objeto para mockar dependências que seguem um "contrato" que são injetadas em um tipo de serviço. Quando usamos o princípio de Interface Segregation podemos mockar diretamente a INTERFACE usando duas funcionalidades do pacote jest-mock-extended sem se preocupar com as dependências externas (ex: Repositórios concretos)

Exemplo

Aqui temos uma interface que um repositório deve seguir.

import { UserDTO } from "../dtos/user";

export interface GetUsers {
    allUsers(): Promise<UserDTO[]>
}

E no nosso serviço vamos ter uma injeção de dependência seguindo essa interface (sem dizer quem é a classe concreta que representa isso, Inversão de Dependência).

import { UserDTO } from "../dtos/user";
import { ServiceProtocol } from "../protocols/service";
import { GetUsers } from "../repos/get-users";

export default class GetAllUsersService implements ServiceProtocol<null, Promise<UserDTO[]>> {
    constructor (private readonly usersRepository: GetUsers) {}

    async perform(): Promise<UserDTO[]> {
        const all = await this.usersRepository.allUsers()
        return all
    }
}

Agora nos testes, a mágica =)

Repare que na variável usersRepository estamos utilizando o MockProxy na interface e não na classe concreta e entre os testes estamos falando para que a mesma seja mockada.

Com isso, não se preocupamos com classe concreta de repositório, apenas com a camada do serviço que precisa ser testada.

import GetAllUsersService from "@/domain/services/get-all-users-service"
import { mock, MockProxy } from 'jest-mock-extended'
import { GetUsers } from "./repos/get-users"

describe('GetAllUsersService', () => {
    let sut: GetAllUsersService
    let usersRepository: MockProxy<GetUsers>

    beforeAll(() => {
       usersRepository = mock()
    })

    beforeEach(() => {
        sut = new GetAllUsersService(usersRepository)
        usersRepository.allUsers.mockResolvedValue([
            {
                name: 'user 1',
                email: 'user 1',
                age: 'user 1',
                departament: 'user 1',
                created_at: new Date(),
                inative: false
            },
        ])
    })

    it('should call allUsers one time', async () => {
        await sut.perform()

        expect(usersRepository.allUsers).toHaveBeenCalledTimes(1)
    })
})

Valeu!

Referências:

CÓDIGO-FONTE: https://github.com/Gabriel-Valin/clean-arch-express-based

Builder Pattern w/ Typescript

Gabriel Valin — Tue, 01 Nov 2022 14:44:06 +0000

Ideia

A ideia inicial do Builder Pattern é possibilidade de criar objetos complexos com a maior variação de configurações possíveis, uma alternativa ao pattern Factory Method.

Contexto

Temos diversos departamentos em nossa empresa e vamos criar usuários e distribuí-los nos mesmos.

Como podemos via códificação, criar uma maneira de centralizar essa criação e passar as devidas configurações para diversos usuários? Builder!!!

Criando tipos e nossa class User.

export type UserInfo = {
    name: string
    age: number
    departament: string
    salary: number
}

export class User {
    name = ''
    age = 0
    departament = ''
    salary = 0

    create() {
        console.log({
            name: this.name,
            age: this.age,
            departament: this.departament,
            salary: this.salary
        })
    }
}

_
Criando o protocolo que a classe concreta do Builder deverá implementar._


import { User } from ".."

export interface UserBuilder {
    setName(name: string): this
    setAge(age: number): this
    setDepartament(departament: string): this
    setSalary(salary: number): this
    getUser(): User
}

Criando nossa classe concreta de UserBuilder.

import { User } from ".."
import { UserBuilder } from "../protocols/user-builder-protocol"

export class ConcreteUserBuilder implements UserBuilder {
    user: User

    constructor() {
        this.user = new User()
    }

    setName(name: string): this {
        this.user.name =  name
        return this
    }

    setAge(age: number): this {
        this.user.age =  age
        return this
    }

    setDepartament(departament: string): this {
        this.user.departament =  departament
        return this
    }

    setSalary(salary: number): this {
        this.user.salary =  salary
        return this
    }

    getUser(): User {
        return this.user
    }
}

_
Implementando a criação de novos usuários._


import { ConcreteUserBuilder } from "../builder/user-builder"

class EngineerUser {
    static buildUser() {
        return new ConcreteUserBuilder()
            .setName('Gabriel Valin')
            .setAge(23)
            .setDepartament('Engineering')
            .setSalary(99999999) //hahahaha :D
            .getUser() 
    }
}

class MarketingUser {
    static buildUser() {
        return new ConcreteUserBuilder()
            .setName('Thais Valin')
            .setAge(19)
            .setDepartament('Marketing')
            .setSalary(8888888) //hahahaha :D
            .getUser() 
    }
}

const newEngineer = EngineerUser.buildUser()
const newMarketing = MarketingUser.buildUser()

newMarketing.create()
newEngineer.create()

Resultado:

{
  name: 'Thais Valin',
  age: 19,
  departament: 'Marketing',
  salary: 8888888
}
{
  name: 'Gabriel Valin',
  age: 23,
  departament: 'Engineering',
  salary: 99999999
}

Conclusão

Está foi uma maneira simplificada de mostrar como utilizar o pattern Builder.

Uma maneira legal de se pensar para entender esse pattern é imaginar a construção de uma casa, onde definimos numa classe principal (User) que ela terá algumas propriedades (janelas, portas, quantidade de banheiros, quartos, etc..), após isso devemos falar para a construtora que a casa deverá ser construída mantendo o padrão de construção que foi passado (interface UserBuilder), por final, a construtora irá criar e separar para os funcionários as funções de construção que ao final vão gerar uma casa pronta (ConcreteUserBuilder).

Com isso é possível que a construtora sempre crie casas complexas podendo definir suas propriedades sem muita dificuldade. (EngineerUser, MarketingUser). :D

Links para se aprofundar: https://refactoring.guru/design-patterns/builder/typescript/example

Node.JS and Cache with REDIS

Gabriel Valin — Fri, 28 Oct 2022 14:23:51 +0000

Primeiramente, o quê é cache?

Segundo a querida Wikipedia, cache é:

Na área da computação, cache é um dispositivo de acesso rápido, interno a um sistema, que serve de intermediário entre um operador de um processo e o dispositivo de armazenamento ao qual esse operador acede.

Aqui nesse artigo iremos utilizar um simples servidor HTTP feito com Expressjs e duas rotas GET para mostrar uma das dezenas de estratégias existentes para se lidar com cache.

Clone o repositório para visualizar a estrutura por dentro e também contém a descrição para rodar o projeto: https://github.com/Gabriel-Valin/api-cache-redis

Contexto ficticío:

Uma empresa tem 5 mil funcionários, todos cadastrados em um banco de dados; Precisamos disponibilizar um endpoint para que esses usuários possam ser consultados.

Execução:

Começamos pensando que o processo de transferência de pacotes entre redes está entre uma das tarefas mais demoradas que um computador pode fazer, apesar de que para um humano isso seja "alienigenamente" rápido. Então como podemos otimizar a entrega desse pacotão com 5 mil funcionários? Resposta? CACHE!!

cache.ts: Configuração da conexão com Redis.

import IORedis from 'ioredis';

const redis = new IORedis({
    host: process.env.REDIS_HOST,
    port: 6379,
    password: process.env.REDIS_PASS
})


export default redis

list-service: Listando usuários.

import { getAllUsers } from "../repositories/find-all"
import redis from "./cache"
export const CACHE_KEY = 'users'

export const listAllUsersService = async () => {
    const cachedUsers = await redis.get(CACHE_KEY)
    if (cachedUsers) {
        return JSON.parse(cachedUsers)
    }
    const users = getAllUsers()
    await redis.set(CACHE_KEY, JSON.stringify(users))
    return users
}

add-user: Adicionando novo usuário a empresa.

import redis from "../services/cache";
import { CACHE_KEY } from "../services/list-service";
import { Response, Request } from "express";

export const addNewUser = async (req: Request, res: Response) => {
    // here will create a new user
    // when user created we should cleanup cache 'cause the user list was updated

    await redis.del(CACHE_KEY)
    return res.status(200).json({ message: 'cache clean' })
}

Estratégia:

Temos uma lista bem grande para disponibilizar ao client, então utilizamos a simples estratégia de após a primeira consulta no endpoint o conteúdo irá ficar "cached" e só invalidamos o cache assim que um novo usuário for cadastrado na empresa e assim o ciclo se repetirá. Com isso, a lista ficará sempre em cache, podendo reduzir o tempo de resposta em até mais de 50%.

Bônus:

Lembrando que existem vários sistemas de armazenamento em cache, esse foi apenas uma demonstração simples que acontece no mundo real onde precisamos "cachar" a entrega de conteúdo em um API, para mais informações, leia este artigo do Ed Rodrigues.

https://edrodrigues.com.br/blog/estrategias-de-cache-tudo-o-que-voce-precisa-saber/

HTTP - Verbs, HTTP codes & Request Params

Gabriel Valin — Mon, 18 Oct 2021 16:56:15 +0000

Verbs

GET - Reading infos
POST - Create infos
PUT - Update Infos
PATCH - Update PARTIAL info (example: avatar from user)
DELETE - Delete infos

HTTP - Status Code

1xx - Informative: processing..
2xx - Confirmation:
- 200: Request success
- 201: Created - AFTER REQUEST POST
3xx - Redirect:
- 301: Moved Permanently
- 302: Moved
4xx - Client Error
- 400: Bad Request
- 401: Unauthorized
- 403: Forbidden
- 404: Not Found
- 422: Unprocessable Entity
5xx - Server Error
- 500: Internal Server Error
- 502: Bad Gateway

Request Params

Header Params: Token, authorization, cors
Query Params: key,value,separator (page=28&)
Route Params: /products/{id}
Body Params: { name: 'john doe', last_name: 'stewie' }

API Rest - a little bit..

Gabriel Valin — Mon, 18 Oct 2021 16:44:08 +0000

Application Programming Interface

Group of possible specifications about interactions at applications.
Documentation (example: Swagger)

REST: Representation State Transfer

Architecture Shape

6 rules for REST

Client-Server
Stateless
Cache
Uniform Interface
- http://address.com/users (example)
- JSON/XML ...
- Messages and Status coherent
- HATEOS
  - Return links inside request
Layers
- Charger Balanced (example)
Code on Demand

NodeJS - Fundamentals

Gabriel Valin — Mon, 18 Oct 2021 16:35:15 +0000

NODEJS

Open Source platform, allow the execution of javascript language in server-side.
Single Thread (v8) with Thread Pool (libuv c++) and group of modules.
Event Loop (Call Stack)
NoN-Blocking I/O
Self Modules (http, fs, dns, buffer, etc..)

What's Event Loop?

the last one in is the first one out!