Forem: Zoranildo Santos

Análise: Segurança e IA na Codificação Moderna

Zoranildo Santos — Fri, 21 Mar 2025 16:23:52 +0000

O Cenário Atual

Estamos vivendo um momento crucial na evolução do desenvolvimento de software. A chegada de ferramentas como o GitHub Copilot não representa apenas uma mudança nas ferramentas que usamos, mas uma transformação fundamental na forma como o código é criado. Esta mudança traz consigo tanto oportunidades quanto desafios significativos para a segurança do software.

Esta análise baseia-se no artigo "Securing Code in the Era of Agentic AI" da Veracode, que destaca os desafios e oportunidades que a inteligência artificial (IA) traz para a segurança do software.

Pontos Críticos

O artigo da Veracode levanta questões importantes que merecem nossa atenção:

O Paradoxo da Produtividade: Enquanto as IAs aceleram drasticamente o desenvolvimento, elas também multiplicam os riscos de segurança. É como ter um carro mais rápido, mas com freios menos eficientes.
A Questão da Confiança: 40% do código sugerido por IA do Github Copilot contém vulnerabilidades. Isso nos força a questionar: até que ponto podemos confiar em soluções automatizadas?
O Efeito Cascata: O mais preocupante é como as vulnerabilidades se propagam. Quando um código inseguro é gerado por IA, ele pode ser rapidamente replicado em diversos projetos, criando um efeito dominó de problemas de segurança.

O Que Podemos Aprender?

A principal mensagem que extraio do artigo não é que devemos evitar as ferramentas de IA, mas sim que precisamos desenvolver uma nova mentalidade de segurança:

A revisão humana continua sendo insubstituível
Ferramentas automatizadas de segurança não são mais opcionais
A segurança precisa ser parte do processo desde o início, não uma reflexão posterior

Reflexão Final

O artigo nos leva a uma conclusão importante: estamos em um ponto de inflexão onde precisamos equilibrar velocidade com segurança. A IA na codificação é inevitável, mas seu uso seguro requer uma mudança cultural nas equipes de desenvolvimento.

Não se trata apenas de adotar novas ferramentas, mas de repensar fundamentalmente como abordamos a segurança no desenvolvimento de software em uma era onde o código é cada vez mais gerado por máquinas.

Fonte: https://www.veracode.com/blog/securing-code-and-agentic-ai-risk/

Mockoon: O Que é e Como Criar APIs Simuladas de Forma Rápida

Zoranildo Santos — Thu, 06 Mar 2025 13:47:04 +0000

Introdução

O Mockoon é uma ferramenta open-source popular para simulação de APIs, criada em 2017 por Guillaume Monnet. Ela permite que desenvolvedores criem rapidamente APIs simuladas e testem suas aplicações sem depender de APIs de terceiros, que podem ser instáveis, lentas ou caras para uso em ambientes de desenvolvimento e teste.

Como Funciona

O Mockoon oferece uma interface gráfica intuitiva que facilita a criação e gerenciamento de APIs simuladas. Com ele, você pode:

Definir rotas personalizadas
Criar respostas dinâmicas
Simular latências para replicar comportamentos reais
Importar e exportar no formato OpenAPI/Swagger

Características Principais

Operações CRUD em bancos de dados JSON falsos
Respostas stateful com valores dinâmicos e templating
Múltiplas respostas por rota (acionadas por regras ou aleatoriamente)
Suporte a callbacks/webhooks
Gravação e reprodução de solicitações
Proxying para APIs de terceiros

Como Instalar

O Mockoon está disponível para os principais sistemas operacionais. Siga estes passos:

Acesse a página de downloads do Mockoon
Escolha a versão para seu sistema operacional (Windows, macOS ou Linux)
Baixe e execute o instalador
Siga as instruções específicas do seu sistema

💡 Dica: Além da aplicação desktop, o Mockoon oferece um CLI para execução em ambientes headless ou automatizados!

Exemplos de Uso

Criando uma API Simulada Básica

Abra o Mockoon e crie um novo ambiente clicando em "New environment"
Adicione um novo endpoint:
- Clique em "Add route"
Defina a rota(GET /users) e configure o corpo da resposta:

{
  "id": 1,
  "nome": "João Silva",
  "email": "joao.silva@example.com"
}

Inicie o servidor clicando em "Start"
Acesse: http://localhost:3000/users

Simulando Latência

Para simular delays de uma API real:

Selecione o endpoint desejado
No painel de configurações, ajuste o campo "Latency"
Defina o valor desejado em milissegundos

Utilizando o CLI em Pipelines CI/CD

O Mockoon CLI é perfeito para integração em pipelines de CI/CD:

Instalação global:

npm install -g @mockoon/cli

Iniciando uma API simulada:

mockoon-cli start --data ./caminho/para/arquivo-de-dados.json

Conclusão

O Mockoon é uma ferramenta poderosa e versátil que simplifica o processo de simulação de APIs. Sua interface amigável e recursos avançados o tornam uma escolha excelente para equipes que buscam:

Agilizar fluxos de trabalho
Melhorar a qualidade dos testes
Reduzir dependências externas
Automatizar processos de desenvolvimento

Gostou do artigo? Me siga para mais conteúdo sobre desenvolvimento e ferramentas! 🚀

Explorando Técnicas de Prompting para Modelos de IA

Zoranildo Santos — Tue, 04 Mar 2025 01:09:06 +0000

Os modelos de inteligência artificial, como o ChatGPT, podem gerar respostas impressionantes dependendo da maneira como são instruídos. O processo de elaborar instruções eficazes para esses modelos é chamado de prompting. A escolha da técnica de prompting pode impactar significativamente a precisão, a relevância e a utilidade das respostas geradas.

Neste artigo, vamos explorar algumas das principais técnicas de prompting e como elas podem ser utilizadas para otimizar as interações com modelos de IA.

1. Zero-shot Prompting

O que é?

Zero-shot prompting refere-se a fornecer um prompt sem exemplos explícitos, confiando na capacidade do modelo de generalizar a resposta com base em seu treinamento prévio.

Exemplo:

"Explique o conceito de entropia na física."

Quando usar?

Quando o modelo já possui conhecimento suficiente sobre o tópico
Para obter respostas diretas e concisas

2. Few-shot Prompting

O que é?

Few-shot prompting fornece alguns exemplos antes de fazer uma pergunta, ajudando o modelo a entender o padrão desejado.

Exemplo:

"Traduza as seguintes frases para o francês:
1. Olá, como vai você? -> Bonjour, comment ça va?
2. Eu gosto de café. -> J'aime le café.
3. Onde fica a estação de trem? ->"

Quando usar?

Para tarefas que exigem um estilo específico de resposta
Quando a resposta esperada pode variar e exemplos podem guiar o modelo

3. Chain of Thought (CoT) Prompting

O que é?

Essa técnica incentiva o modelo a raciocinar passo a passo, melhorando a precisão em problemas complexos.

Exemplo:

"Se João tem 3 maçãs e compra mais 5, e depois dá 2 para Ana, quantas maçãs ele tem agora? Explique o raciocínio passo a passo."

Quando usar?

Para problemas matemáticos ou lógicos
Quando a resposta final depende de múltiplas etapas

4. Contextual Prompting

O que é?

Fornece informações adicionais relevantes para ajudar o modelo a gerar respostas mais precisas.

Exemplo:

"Em um contexto de desenvolvimento web, explique o que é uma API RESTful e como ela funciona."

Quando usar?

Quando a resposta pode variar dependendo do contexto
Para evitar ambiguidades

5. Style-Specific Prompting

O que é?

Orienta o modelo a responder em um estilo específico, como técnico, informal, acadêmico, etc.

Exemplo:

"Explique a teoria da relatividade em um tom informal, como se estivesse explicando para um amigo."

Quando usar?

Para adaptar a resposta ao público-alvo
Quando a forma da resposta é tão importante quanto o conteúdo

6. Length Limitation Prompting

O que é?

Restringe a resposta do modelo a um tamanho específico.

Exemplo:

"Explique a Segunda Guerra Mundial em no máximo 50 palavras."

Quando usar?

Para obter respostas mais objetivas
Quando há restrições de espaço ou tempo de leitura

7. Step-by-Step Instruction Prompting

O que é?

Pede que o modelo forneça instruções detalhadas e organizadas passo a passo.

Exemplo:

"Explique como configurar um ambiente de desenvolvimento para Node.js em 5 passos."

Quando usar?

Para tutoriais e guias técnicos
Quando a tarefa envolve múltiplas etapas sequenciais

8. Definition or Exemplification Prompting

O que é?

Solicita que o modelo forneça definições seguidas de exemplos para facilitar a compreensão.

Exemplo:

"Defina o que é machine learning e dê um exemplo prático de sua aplicação."

Quando usar?

Para ensino e aprendizado
Quando exemplos são essenciais para a clareza da explicação

Conclusão

Dominar diferentes técnicas de prompting pode melhorar significativamente a qualidade das respostas geradas por modelos de IA. Dependendo do objetivo, você pode escolher entre zero-shot, few-shot, chain of thought e outras abordagens para obter respostas mais precisas, organizadas e úteis.

Se você trabalha com modelos de IA ou deseja melhorar suas interações com eles, experimente essas técnicas e veja como a escolha do prompt pode fazer toda a diferença!

Como Construir um Chat AI usando Python e Groq Cloud

Zoranildo Santos — Sun, 02 Mar 2025 00:07:58 +0000

Neste artigo, vou mostrar como construir um assistente virtual utilizando Python, LangChain e a API da Groq Cloud. Vamos criar uma aplicação que permite interagir com modelos de linguagem avançados de forma simples e eficiente.

O que é Groq?

Groq é uma empresa que oferece acesso a modelos de linguagem de última geração através de sua API. Uma das principais vantagens da Groq é sua velocidade de inferência, oferecendo respostas mais rápidas em comparação com outras soluções disponíveis no mercado.

O que é LangChain?

O LangChain é um framework poderoso que facilita o desenvolvimento de aplicações baseadas em modelos de linguagem (LLMs). Ele oferece várias funcionalidades importantes:

Gerenciamento de memória e contexto
Criação de cadeias de processamento (chains)
Integração com diferentes modelos de IA
Manipulação de documentos e dados
Criação de agentes autônomos

No nosso projeto, o LangChain será fundamental para:

Gerenciar o contexto das conversas
Criar prompts estruturados
Integrar o modelo da Groq de forma eficiente
Manter o histórico de interações

Pré-requisitos

Python 3.8+
Conhecimento básico de Python
Uma conta na Groq (para obter a API key)
FastAPI
Uvicorn (servidor ASGI)

Estrutura do Projeto

├── src/
│   ├── domain/
│   │   └── ai_chat/
│   │       ├── entities/
│   │       │   └── message.py
│   │       └── use_cases/
│   │           └── process_message_use_case.py
│   └── interfaces/
│       ├── controllers/
│       │   └── ai_chat_controller.py
│       └── routes/
│           └── ai_chat_routes.py
├── config/
│   └── langchain_groq_config.py
└── requirements.txt

Configuração Inicial

Primeiro, crie um novo projeto e instale as dependências necessárias:

mkdir chat
cd chat
python -m venv venv
source venv/bin/activate  # No Windows use: .\venv\Scripts\activate

Instale as dependências necessárias:

pip install fastapi uvicorn langchain-groq python-dotenv pydantic

Crie um arquivo requirements.txt:

fastapi==0.109.2
uvicorn==0.27.1
pydantic>=2.7.4,<3.0.0
groq==0.4.2
python-dotenv==1.0.1
langchain==0.3.19
langchain-groq==0.2.4

Crie um arquivo .env na raiz do projeto:

GROQ_API_KEY=sua_api_key_aqui

Implementação

1. Configuração do Cliente Groq com LangChain

Primeiro, vamos configurar o cliente da Groq usando o LangChain. Crie o arquivo config/langchain_groq_config.py:

import os
from dotenv import load_dotenv
from langchain_groq import ChatGroq
from langchain.memory import ConversationBufferMemory
from langchain.prompts import ChatPromptTemplate

load_dotenv()

DEFAULT_MODEL = "mixtral-8x7b-32768"
DEFAULT_ROLE = "user"

def create_groq_client() -> ChatGroq:
    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        raise ValueError("GROQ_API_KEY não encontrada nas variáveis de ambiente")

    # Criando o cliente Groq com configurações otimizadas
    return ChatGroq(
        groq_api_key=api_key,
        model_name=DEFAULT_MODEL,
        temperature=0.7,
        max_tokens=1000
    )

def create_memory() -> ConversationBufferMemory:
    return ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True
    )

def create_prompt_template() -> ChatPromptTemplate:
    return ChatPromptTemplate.from_messages([
        ("system", "Você é um assistente pessoal chamado ZAgent, especializado em ajudar com tarefas domésticas."),
        ("human", "{input}"),
        ("assistant", "Vou ajudar você com isso. {chat_history}")
    ])

2. Definindo a Entidade Message

Crie o arquivo src/domain/ai_chat/entities/message.py:

from pydantic import BaseModel

class Message(BaseModel):
    content: str

3. Implementando o Use Case

Crie o arquivo src/domain/ai_chat/use_cases/process_message_use_case.py:

from typing import Optional
from langchain_groq import ChatGroq
from langchain.prompts import ChatPromptTemplate
from langchain.memory import ConversationBufferMemory
from src.domain.ai_chat.entities.message import Message
from config.langchain_groq_config import create_groq_client, create_memory, create_prompt_template


class ProcessMessageUseCase:
    def __init__(self, groq_client: Optional[ChatGroq] = None):
        self.groq_client = groq_client or create_groq_client()
        self.memory = create_memory()
        self.prompt_template = create_prompt_template()

    async def execute(self, message: Message) -> str:
        try:
            # Criando a chain com memória e prompt template
            chain = self.prompt_template | self.groq_client

            # Executando a chain com o histórico de conversa
            response = await chain.ainvoke({
                "input": message.content,
                "chat_history": self.memory.chat_memory.messages
            })

            # Salvando a interação na memória
            self.memory.save_context(
                {"input": message.content},
                {"output": response.content}
            )

            return str(response.content)

        except Exception as e:
            raise Exception(f"Erro ao processar mensagem: {str(e)}")

4. Criando o Controller

Crie o arquivo src/interfaces/controllers/ai_chat_controller.py:

from fastapi import APIRouter, HTTPException
from src.domain.ai_chat.entities.message import Message
from src.domain.ai_chat.use_cases.process_message_use_case import ProcessMessageUseCase

class AIChatController:
    def __init__(self):
        try:
            self.process_message_use_case = ProcessMessageUseCase()
            self.router = APIRouter()
            self._setup_routes()
        except ValueError as e:
            raise ValueError(f"Erro na configuração do controlador: {str(e)}")

    def _setup_routes(self):
        self.router.add_api_route(
            "/chat",
            self.chat,
            methods=["POST"],
            response_model=dict,
            summary="Processa uma mensagem usando IA",
            description="Recebe uma mensagem e retorna a resposta gerada pelo modelo de IA"
        )

    async def chat(self, message: Message) -> dict:
        try:
            response = await self.process_message_use_case.execute(message)
            return {"response": response}
        except ValueError as e:
            raise HTTPException(status_code=400, detail=str(e))
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))

5. Configurando as Rotas

Crie o arquivo src/interfaces/routes/ai_chat_routes.py:

from fastapi import APIRouter
from src.interfaces.controllers.ai_chat_controller import AIChatController

def setup_routes() -> APIRouter:
    controller = AIChatController()
    router = APIRouter(prefix="/api/v1", tags=["AI Chat"])

    router.include_router(controller.router)
    return router

6. Implementando o Arquivo Principal

Agora, vamos criar o arquivo principal da aplicação main.py:

import sys
from fastapi import FastAPI
from src.interfaces.routes.ai_chat_routes import setup_routes

app = FastAPI(
    title="Minha API FastAPI",
    description="Uma API de exemplo usando FastAPI com chat IA",
    version="1.0.0"
)

try:
    app.include_router(setup_routes())
except ValueError as e:
    print(f"Erro fatal na inicialização da aplicação: {str(e)}", file=sys.stderr)
    print("Certifique-se de que a variável de ambiente GROQ_API_KEY está configurada corretamente", file=sys.stderr)
    sys.exit(1)

Como Usar

Configure suas variáveis de ambiente:

export GROQ_API_KEY=sua_api_key_aqui

Execute o servidor:

uvicorn main:app --reload

Acesse a documentação da API:

http://localhost:8000/docs

Faça uma requisição para o chat:

curl -X POST "http://localhost:8000/api/v1/chat" \
     -H "Content-Type: application/json" \
     -d '{"content": "Olá, tudo bem?"}'

Considerações de Segurança

Nunca compartilhe sua API key
Utilize variáveis de ambiente para armazenar informações sensíveis
Implemente rate limiting para controlar o uso da API
Considere implementar um sistema de cache para respostas frequentes
Monitore o uso de tokens para controlar custos

Próximos Passos

Algumas sugestões para expandir o projeto:

Adicionar interface frontend (React, Vue.js, etc.)
Implementar histórico de conversas com banco de dados
Adicionar suporte a diferentes modelos
Implementar cache de respostas com Redis
Adicionar testes automatizados com pytest
Implementar autenticação e autorização
Adicionar rate limiting e middleware de segurança
Implementar diferentes tipos de memória do LangChain (ConversationSummaryMemory, ConversationBufferWindowMemory)
Adicionar suporte a diferentes tipos de prompts e templates
Implementar agentes autônomos para tarefas específicas

Conclusão

Neste artigo, aprendemos como construir um chat utilizando Python, LangChain e a API da Groq. A implementação segue boas práticas de desenvolvimento e aproveita os recursos poderosos do LangChain para criar uma experiência mais inteligente e contextualizada.

Recursos Úteis

API Node Desacoplada: Criando os AdaptRouter para o Express e o Fastify

Zoranildo Santos — Tue, 01 Aug 2023 21:34:00 +0000

Neste artigo vamos criar os adaptadores de rota para o express e para o fastify. Com isso nossa aplicação finalmente será capaz de funcionar com express ou fastify, apenas alterando o valor da variável SERVER_TYPE no arquivo .env.

Dentro da pasta infra crie uma nova pasta chamada adapter. Dentro da pasta adapter crie dois arquivos adaptRouteFastify.ts e adaptRouteExpress.ts.

Criando o adaptador para o Express

No arquivo adaptRouteExpress.ts insira o código abaixo:

import { Request, Response } from 'express'
import { HttpRequest } from '../shared/protocols/http'
import { IController } from '../shared/protocols/controller'

export const adaptRouteExpress = (controller: IController) => {
  // A função adaptRouteExpress é exportada para que possa ser 
  // utilizada em outros módulos da aplicação. Ela recebe um 
  // parâmetro controller, que é uma instância da classe que 
 //  implementa a interface IController.

  return async (req: Request, res: Response) => {
    // Retorna uma função assíncrona que será utilizada como 
    // callback para o roteamento no Express.js. A função callback 
    // recebe os parâmetros req (requisição) e res (resposta) do 
    // Express.js.

    const httpRequest: HttpRequest = {
      body: req.body
    }

    // Estamos adaptando a estrutura de dados da requisição 
    // recebida pelo Express.js para o formato esperado pela 
    // interface HttpRequest. Neste caso, estamos apenas pegando o 
    // corpo da requisição (req.body) e atribuindo ao campo body 
    // do objeto httpRequest.

    const httpResponse = await controller.handle(httpRequest)
    res.status(httpResponse.statusCode).json(httpResponse.body)

    // A resposta obtida do controller é adaptada para o formato 
    // esperado pelo Express.js. Utilizamos os métodos status e 
    // json do objeto res para definir o status code HTTP da 
    // resposta e enviar o corpo no formato JSON para o client.
  }
}

Agora precisamos utilizar o adapter criado. No arquivo signUp.routes.ts faça as alteração necessárias para ultilizar o adaptador:

Antes:

import { Router } from 'express'
import { CreateSignUpFactory } from '../../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'
const signupRoutes = Router()

signupRoutes.post('/signup', (req, res) =>  CreateSignUpFactory().handle(req, res))

export { signupRoutes }

Depois:

import { Router } from 'express'
import { CreateSignUpFactory } from '../../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'
import { adaptRouteExpress } from '../../../infra/adapters/adaptRouteExpress'
const signupRoutes = Router()

signupRoutes.post('/signup', adaptRouteExpress(CreateSignUpFactory()))

export { signupRoutes }

Criando o adaptador para o Fastify

No arquivo adaptRouteFastify.ts insira o código abaixo:

Aqui a estrutura é a mesma com uma pequena diferença: a tipagem usada é a do fastify naturalmente.

import { FastifyRequest, FastifyReply } from 'fastify'
import { HttpRequest } from '../shared/protocols/http'
import { IController } from '../shared/protocols/controller'

export const adaptRouteFastify = (controller: IController) => {
  return async (req: FastifyRequest, res: FastifyReply) => {
    const httpRequest: HttpRequest = {
      body: req.body
    }
    const httpResponse = await controller.handle(httpRequest)
    res.status(httpResponse.statusCode).send(httpResponse.body)
  }
}

Agora precisamos utilizar o adapter criado. No arquivo index.ts que fica dentro da pasta fastify responsável pelas rotas(src/infra/routes/fastify/index.ts) faça as alteração necessárias para ultilizar o adaptador:

Antes:

import { FastifyPluginAsync } from 'fastify'
import { CreateSignUpFactory } from '../../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'


export const signUpRouter: FastifyPluginAsync = async (
  fastify
): Promise<void> => {
  fastify.post('/signup', (req, res) => CreateSignUpFactory().handle(req, res))
}

Depois:

import { FastifyPluginAsync } from 'fastify'
import { CreateSignUpFactory } from '../../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'
import { adaptRouteFastify } from '../../../infra/adapters/adaptRouteFastify'

export const signUpRouter: FastifyPluginAsync = async (
  fastify
): Promise<void> => {
  fastify.post('/signup', adaptRouteFastify(CreateSignUpFactory()))
}

Testando a aplicação

Agora que já temos os adaptadores das rotas podemos testar se nossa aplicação vai funcionar tanto com Express quanto com Fastify.

Testando com Express

Coloque o valor express para a variável SERVER_TYPE no arquivo .env

SERVER_TYPE=express
PORT_SERVER=5000

Execute o comando yarn start:dev no terminal. Teste a requisição no insomnia ou qualquer outra ferramenta, se tudo estiver correto teremos esse resultado:

O status code retornado é o 201 que foi definido na função create no arquivo httpHelper.ts o body stá vázio porque não definimos mensagem de criação bem sucedida.

Testando com Fastify

Pare a aplicação e altere o valor da variável SERVER_TYPE para fastify(no arquivo .env).

Execute novamente o comando yarn start:dev no terminal. Teste a requisição no insomina ou qualquer outra ferramenta. O resultado obtido deverá ser o mesmo do anterior demonstrado no print acima.

Conclusão

Como prometido temos agora uma aplicação que funciona tanto com fastify quanto com express mudando apenas uma variável de ambiente(SERVER_TYPE), sem ser necessário alterar nosso código principal. Nossa camada de domínio(entidades e usecases dentro da pasta aplication) não precisa saber que ferramentas externas estamos usando, isso não interessa.

Se quisermos usar outro framework que não o express ou o fastify não será necessário alterar código na nossa camada de domínio, apenas na camada de infraestrutura.

Ainda temos alguma coisas pra melhorar na nossa aplicação que será feito nos próximos artigos. Até breve.

API Node Desacoplada: Criando Interfaces para Requisições e Respostas HTTP

Zoranildo Santos — Tue, 01 Aug 2023 21:25:45 +0000

Como mencionado no artigo anterior, nosso controller(CreateSignUpController.ts) está totalmente acoplado. Antes de criar os adaptadores para as rotas vamos alterar nosso controller pra que fique desacoplado e independente de qualquer ferramenta esterna.

Padronizando as respostas e requisições em uma API Node desacoplada

Vamos definir interfaces para as respostas e requisições de nossa api.

Crie uma pasta chamada shared dentro da pasta infra.
Dentro da pasta shared crie a pasta protocols.
Dentro da pasta protocols crie o arquivo http.ts.

Agora no arquivo http.ts insira o código abaixo:

export type HttpResponse = {
  statusCode: number
  body: unknown
}

export interface HttpRequest {
  body?: unknown
}

HttpResponse:

A interface HttpResponse define a estrutura padrão da resposta que a API enviará para o client após processar uma requisição. Ela possui dois campos:

statusCode: É um campo do tipo number que representa o código de status HTTP que será enviado como resposta ao client(EX: 200, 201, 400, 500).

body: É um campo do tipo unknown, o que significa que a resposta pode conter qualquer tipo de dado. Esse campo armazenará o corpo da resposta enviada ao client, que pode ser, por exemplo, um objeto JSON, uma mensagem de sucesso ou erro, ou até mesmo null, caso a resposta não precise conter um corpo.

Utilizando essa interface, a API pode padronizar o formato das respostas enviadas, o que facilita o tratamento das informações pelo client que está consumindo a API.

HttpRequest:

A interface HttpRequest define a estrutura padrão das requisições que a API receberá do client. Ela possui apenas um campo e é opcional:

body: É um campo do tipo unknown, que representa o corpo da requisição. Esse campo pode conter qualquer tipo de dado, e é geralmente utilizado para passar dados ao servidor, como parâmetros de busca, dados de formulários, ou payloads em requisições POST/PUT.

Ao definir essa interface, a API estabelece um formato padrão para as requisições que ela espera receber, mas permite que o client envie dados de forma flexível, já que o campo body é opcional.

Isso permite que a API se adapte a diferentes tipos de requisições sem impor restrições rígidas. Essas duas interfaces, HttpResponse e HttpRequest, ajudam a promover a separação de responsabilidades e o desacoplamento entre as camadas da aplicação.

Criando um contrato para nossos controllers

Dentro da pasta protocols crie o arquivo controller.ts
No arquivo controller.ts insira o seguinte código:

import { HttpResponse } from './http'

export interface IController<T = unknown> {
  handle(request: T): Promise<HttpResponse>

  // O método handle possui a seguinte assinatura:
  // handle(request:T): Promise<HttpResponse>.

  // Ele recebe um parâmetro chamado request do tipo genérico T,
  // que representa o objeto de requisição que será passado para o 
  // controlador. O método retorna uma Promise que resolve o 
  // HttpResponse
}

Essa interface IController serve como um contrato que deve ser implementado por qualquer classe que atue como um controlador na aplicação. Ao utilizar essa interface, você pode definir vários controladores para diferentes rotas ou recursos da API, mas garantindo que todos eles sigam o mesmo padrão de implementação e retornem uma resposta do tipo HttpResponse.

A vantagem dessa abordagem é a padronização e a flexibilidade que ela proporciona. Essa abstração ajuda a manter o código organizado, facilita a criação de novos controladores e torna a API mais flexível, permitindo a fácil substituição ou adição de controladores sem modificar a lógica central da aplicação.

Criando um contrato para o CREATE do CRUD

Dentro da pasta shared crie o arquivo httpHelper.ts
No arquivo httpHelper.ts insira o seguinte código:

import { HttpResponse } from '../protocols/http'

export const create = (data: unknown): HttpResponse => ({
  statusCode: 201,
  body: data
})

Uma função create é exportada e recebe um parâmetro data do tipo unknown. O tipo unknown indica que a função pode receber qualquer tipo de dado.

A função retorna um objeto do tipo HttpResponse, conforme definido pela interface importada na linha acima.

O objeto retornado pela função create possui dois campos:

statusCode: Representa o código de status HTTP a ser enviado como resposta ao cliente. Neste caso, o valor 201 indica que a requisição foi bem-sucedida e resultou na criação de um novo recurso (usualmente utilizado após uma operação de criação, como um POST).

body: O campo body é definido com o valor do parâmetro data recebido pela função. Isso significa que o conteúdo do campo body será igual ao valor do parâmetro data passado para a função create. Esse campo armazenará o corpo da resposta enviada ao cliente, que pode ser qualquer tipo de dado, incluindo objetos JSON, strings, arrays ou até mesmo null.

A função create é útil para padronizar a criação de respostas no formato HttpResponse, tornando mais fácil e claro o envio de respostas para o client. Outros contratos podem ser criados para update, read e delete com o statusCode 200.

Refatorando o controller(CreateSignUpController.ts)

Código antes da refatoração:

Perceba que o controller está acoplado ao express. Imagine que a aplicação tem dezenas de controllers, se por acaso for necessário mudar o framework, teriamos muito trabalho pra fazer alterando essa tipagem manualmente em todos os controllers.

Com a refatoração, mesmo se a aplicação tiver dezenas de controllers a alteração a ser feita será apenas na camada de infraestrutura, claro, isso se todos os controllers tiverem sido criados seguindo o contrato definido.

import { Response, Request } from "express"
import { CreateSignUpUseCase } from './CreateSignUpUseCase'

interface ICreateSignUpDTO {
  name: string
  password: string
}

export class CreateSignUpController {
  constructor(private readonly useCase: CreateSignUpUseCase) {}

  async handle(req: Request, res: Response): Promise<Response> {
    const { name, password } = req.body as ICreateSignUpDTO

    const data = { name, password }
    await this.useCase.execute(data)

    return res.status(201).send({ message: 'User created successfully' })
  }
}

Código refatorado:

import { CreateSignUpUseCase } from './CreateSignUpUseCase'
import { IController } from '../../../../../infra/shared/protocols/controller'
import { HttpRequest, HttpResponse } from '../../../../../infra/shared/protocols/http'
import { create } from '../../../../../infra/shared/protocols/httpHelper'

interface ICreateSignUpDTO {
  name: string
  password: string
}

export class CreateSignUpController implements IController {
  constructor(private readonly useCase: CreateSignUpUseCase) {}

  async handle(request: HttpRequest): Promise<HttpResponse> {
    const { name, password } = request.body as ICreateSignUpDTO

    const data = { name, password }
    const useCase = await this.useCase.execute(data)

    return create(useCase)
  }
}

Esse foi um belo trabalho. Mesmo assim ainda não é possível alternar entre express e fastify, ainda precisamos criar os adaptadores, o que será feito no próximo artigo.

API Node Desacoplada: Criando Cadastro de Usuários

Zoranildo Santos — Fri, 28 Jul 2023 02:05:56 +0000

Neste artigo vamos dar continuidade a nossa série Guia Prático: Aprenda a Construir uma API Node.js Desacoplada e criar um simples endpoint para cadastro de usuários. Por mais que seja simples vamos abordar métodos essenciais para termos um código limpo e desacoplado. Lembrando que nesse artigo vamos criar essa feature como normalmente vemos em alguns cursos e vídeos no youtube ferindo os princios S.O.L.I.D. No próximo artigo aí sim, vamos refatorar essa feature seguindo os princípios do S.O.L.I.D, com isso você terá uma ideia do que muda no código e porque.

Definindo a estrutura de pastas

A estrutura de pastas usada nesse projeto é uma escolha pessoal, você pode usar outra estutura, o importante é entender os conceitos e metodologias utilizadas.

Vamos criar dentro de src uma pasta chamada application. A ideia é de ser possível mudar qualquer framework ou ferramenta da infraestrutura sem mudar uma linha sequer no código da nossa aplicação.

Dentro de application vamos criar uma pasta chamada modules e dentro de modules vamos criar pastas de acordo com as nossas features que por sua vez terá uma estrutura particular.

A feature que vamos desenvolver agora é um endpoint para cadastrar usuários, então dentro da pasta modules vamos criar outra chamada SignUp. Dentro da pasta SignUp vamos criar mais três pastas, entitie, repository, useCase.

Ao final deveremos ter a seguinte estrutura de pastas:

Criando a entidade

Dentro da pasta entitie crie o arquivo User.ts e insira o código abaixo:

Escrevemos comentários dentro do código explicando detalhadamente cada linha.

import { randomUUID } from 'node:crypto'

// Importa a função do randomUUID do pacote Node.js crypto para
// gerar um identificador único para cada objeto User.

export interface IUserProps {
  name: string
  password: string;
}

// Essa interface descreve a estrutura esperada para as
// propriedades do usuário. Ela define que o objeto user deve ter
// duas propriedades: name (que deve ser uma string) e password
// (que também deve ser uma string).

export class User {
// A classe User é declarada e contém as propriedades e métodos
// relacionados ao usuário.

  private _id: string
  private _createdAt: Date
  private _updatedAt: Date
  private props: IUserProps

// A classe possui três propriedades privadas: _id, _createdAt e
// _updatedAt, que armazenam o identificador único, a data de
// criação e a data de atualização, respectivamente.

// Além das propriedades privadas, também há uma propriedade
// props, que armazena um objeto do tipo IUserProps. Essa
// propriedade é usada para armazenar os dados de nome (name) e
// senha (password) do usuário.

  constructor(props: IUserProps) {
    this._id = randomUUID()
    this._createdAt = new Date()
    this._updatedAt = new Date()
    this.props = props
  }

// O construtor da classe recebe um objeto do tipo IUserProps
// como argumento. Ele é responsável por inicializar as
// propriedades _id, _createdAt e _updatedAt, além de armazenar as
// propriedades name e password passadas no objeto props.

  public get id() {
    return this._id
  }

  public set name(name: string) {
    this.props.name = name
  }

  public get name(): string {
    return this.props.name
  }

  public set password(password: string) {
    this.props.password = password
  }

  public get password(): string {
    return this.props.password
  }

  public get createdAt(): Date {
    return this._createdAt
  }

  public get updatedAt(): Date {
    return this._updatedAt
  }

// A classe define os getters e setters para permitir o acesso
// controlado às propriedades.

// Os getters são métodos que permitem obter o valor das
// propriedades, enquanto os setters são métodos que permitem
// definir os valores das propriedades.

// O uso de getters e setters é uma forma de encapsular as
// propriedades da classe e controlar como elas são acessadas e
// modificadas. Isso é útil para garantir a integridade dos dados
// e aplicar lógicas adicionais ao acessar ou definir essas
// propriedades.

}

Criando o Repository

Dentro da pasta repository crie o arquivo UserRepository.ts e insira o código abaixo:

import { User } from '../entitie/User'

export class UserRepository {
  public users: User[] = []

  async create(data: User): Promise<void> {
    this.users.push(data)
  }
}

Criando o useCase

Dentro da pasta useCases vamos criar uma nova pasta que levará o nome do nosso caso de uso que é o cadastro de um novo usuário, ou seja, crie uma pasta chamada CreateSignUp.

Dentro da pasta CreateSignUp crie o arquivo CreateSignUpUseCase.ts e insira o código abaixo:

import { User } from '../../entitie/User'
import { UserRepository } from '../../repository/UserRepository'

interface IRequest {
  name: string
  password: string
}

export class CreateSignUpUseCase {
  constructor(private repository: UserRepository) {}

  async execute(request: IRequest): Promise<void> {
    const { name, password } = request

    const user = new User({
      name,
      password,
    })

    await this.repository.create(user)
  }
}

Criando o Controller

Crie dentro da pasta CreateSignUp o arquivo CreateSignUpController.ts e insira o código abaixo:

import { Response, Request } from "express"
import { CreateSignUpUseCase } from './CreateSignUpUseCase'

interface ICreateSignUpDTO {
  name: string
  password: string
}

export class CreateSignUpController {
  constructor(private readonly useCase: CreateSignUpUseCase) {}

  async handle(req: Request, res: Response): Promise<Response> {
    const { name, password } = req.body as ICreateSignUpDTO

    const data = { name, password }
    await this.useCase.execute(data)

    return res.status(201).send({ message: 'User created successfully' })
  }
}

Criando o Factory

Crie dentro da pasta CreateSignUp o arquivo CreateSignUpFactory.ts e insira o código abaixo:

import { UserRepository } from '../../repository/UserRepository'
import { CreateSignUpController } from './CreateSignUpController'
import { CreateSignUpUseCase } from './CreateSignUpUseCase'

export const CreateSignUpFactory = (): CreateSignUpController => {
  const repository = new UserRepository()
  const useCase = new CreateSignUpUseCase(repository)
  const controller = new CreateSignUpController(useCase)

  return controller
}

Criando rotas com Express

Aqui nosso projeto vai ferir mais alguns princípios, mas tudo bem, vamos corrigir isso nos próximos artigos.

Dentro da pasta infra crie uma nova pasta chamada routes e dentro crie dois arquivo signUp.routes.ts e index.ts.

Insira no arquivo signUp.routes.ts o código abaixo:

import { Router } from 'express'
import { CreateSignUpFactory } from '../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'
const signupRoutes = Router()

signupRoutes.post('/signup', (req, res) =>  CreateSignUpFactory().handle(req, res))

export { signupRoutes }

Insira no arquivo index.ts o código abaixo:

import { Router } from 'express'

import { signupRoutes } from './signUp.routes'


const router = Router()

router.use('/v1', signupRoutes)

export { router }

Feito isso é necessário registrar as rotas no server do express. Atualize o arquivo index.ts(src/infra/ports/express/index.ts) do express com o código abaixo :

import 'dotenv/config'
import express from 'express'
import { router } from '../../routes'

const PORT = 5000

const app = express()

// código novo 
app.use(express.json())
app.use(router)
// 

app.listen(PORT, () => {
  console.log(`Express app listening on port ${PORT}`)
})

export { app }

app.use(express.json())
O middleware express.json() é um middleware embutido no Express que é usado para analisar o corpo das requisições HTTP com o formato JSON. Ele verifica o corpo da requisição e, se encontrar dados JSON válidos, os converte em um objeto JavaScript, que é então acessível através do objeto req.body.

Quando você usa app.use(express.json()), você está adicionando esse middleware à instância do servidor, o que significa que todas as rotas que estão definidas após esta chamada terão acesso aos dados JSON enviados no corpo das requisições e poderão acessá-los através do req.body.

app.use(router)
Nesta linha, estamos usando outro middleware, mas em vez de usar um middleware embutido como express.json(), estamos usando um middleware personalizado chamado router. Esse router é uma instância do express.Router() que foi definida nos arquivos dentro da pasta routes para organizar as rotas da nossa aplicação.

O express.Router() permite agrupar as rotas relacionadas em um único objeto, tornando mais fácil definir e organizar as rotas em diferentes arquivos, o que ajuda a manter o código limpo e modularizado.

Testando a requisição

Muito bem, agora é hora de testar a aplicação desenvolvida até aqui. Use alguma ferramenta como insomnia ou postman para testar a requisição.

Primeiro confira se o valor da variável SERVER_TYPE no arquivo .env é express e suba a aplicação rodando o comando yarn start:dev no terminal. A url pra acessar é essa: http://localhost:5000/v1/signup. Se tudo estiver certo até aqui deveremos ter esse resultado:

Se colocarmos um console.log no repository veremos o objeto que foi criado e salvo na memória, então altere o arquivo UserRepository.ts inserindo um console.log:

...
  async create(data: User): Promise<void> {
    this.users.push(data)
    console.log("Objeto salvo na memória", this.users)
  }
...

Agora faça o seguinte teste:

Pare a aplicação:
Mude o valor da variável SERVER_TYPE para fastify.
Inicialize a aplicação novamente rodando o comando yarn start:dev no terminal.

Com isso nosso app não vai conseguir criar um novo cadastro de usuário pois não vai encontrar a rota definida, tendo em vista que essa rota só existe no express. Para o nosso app rodar sem problemas tanto com express, quanto com o fastfy teremos que criar o roteamento do fastify.

Criando rotas com Fastify

Dentro da pasta routes Crie duas novas pastas express e fastify.

Mova os arquivos index.ts e signUp.routes.ts que estão dentro da pasta routes para a pasta express.

No arquivo signUp.routes.ts altere o path que importa o arquivo CreateSignUpFactory.ts.

// Antes
import { CreateSignUpFactory } from '../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'

// Depois
import { CreateSignUpFactory } from '../../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'

No arquivo index.ts dentro da pasta express que fica dentro da pasta ports, altere o path que importa o arquivo de rotas.

// Antes
import { router } from '../../routes'

// Depois
import { router } from '../../routes/express'

Antes de continuar confira se a aplicação continua rodando.

Depois de feito a refatoração acima, finalmente vamos criar a rota. Dentro da pasta fastify que fica dentro de routes crie o arquivo index.ts e insira o seguinte código:

import { FastifyPluginAsync } from 'fastify'
import { CreateSignUpFactory } from '../../../application/modules/SignUp/useCases/CreateSignUp/CreateSignUpFactory'


export const signUpRouter: FastifyPluginAsync = async (
  fastify
): Promise<void> => {
  fastify.post('/signup', (req, res) => CreateSignUpFactory().handle(req, res))
}

A estrutura de pastas até aqui deverá ser essa:

Registrar a rota

Depois de criada a rota é necessário registrá-la. No arquivo index.ts dentro da pasta fastify que fica dentro da pasta ports(src/infra/ports/fastify/index.ts) importe o arquivo de rotas e registre na instância do fastify. Com a atualização o arquivo ficará assim:

import 'dotenv/config'
import fastify from 'fastify'
// Código novo: importa o arquivo de rota do fastify
import { signUpRouter } from '../../routes/fastify/index'

const server = fastify({ logger: true })

// Código novo: registra a rota na instância criada
server.register(signUpRouter, { prefix: '/v1' })

const app = async () => {
  try {
    server.listen({
      host: '0.0.0.0',
      port: process.env.PORT_SERVER ? Number(process.env.PORT_SERVER) : 5000,
    })
    console.log(`Server fastify running in port ${5000}`)
  } catch (error) {
    console.error(`Erro server fastify`, error)
  }
}

app()

Isso ainda não é o suficiente pra nossa aplicação funcionar com o fastify. Como já mencionei, nosso controller(CreateSignUpController) está totalmente acoplado ao express e o fastify tem tipagens e métodos diferentes. Mas pra testarmos a aplicação funcionando com o fastify, vamos fazer uma pequena alteração no CreateSignUpController.ts.

No controller vamos remover o import da tipagem do express e importar a tipagem do fastify.

// código para remover
import { Response, Request } from "express"
// Código novo
import { FastifyRequest, FastifyReply } from 'fastify'

import { CreateSignUpUseCase } from './CreateSignUpUseCase'

interface ICreateSignUpDTO {
  name: string
  password: string
}

export class CreateSignUpController {
  constructor(private readonly useCase: CreateSignUpUseCase) {}

// aqui no lugar das tipagens do express(Request, Reponse) colocamos a tipagem do fastify(FastifyRequest, FastifyReply)
  async handle(req: FastifyRequest, res: FastifyReply): Promise<Response> {
    const { name, password } = req.body as ICreateSignUpDTO

    const data = { name, password }
    await this.useCase.execute(data)

    return res.status(201).send({ message: 'User created successfully' })
  }
}

Com isso podemos testar a requisição. Se tudo estiver certo a resposta no insomnia será a mesma do teste anterior com express e o console.log que está no repository terá essa saída no terminal:

Se você observar bem, depois de deixar a aplicação funcionado com o fastify, o arquivo signUp.routes.ts tem um erro de tipagem. Isso ocorre porque no controller(CreateSignUpController.ts) estamos usando o fastify e no arquivo signUp.routes.ts estamos usando o express. Pra resolver isso precisamos criar adaptadores pra que nossa aplicação consiga funcionar seja com fastify, seja com express sem a necessidade de alterar o controller(CreateSignUpController.ts).

Ficamos por aqui. Apesar da nossa aplicação estar ferindo alguns princípios, temos algo já bem estruturado e modularizado. Até o próximo artigo.

API Node Desacoplada: Criando servers com express e fastify

Zoranildo Santos — Wed, 26 Jul 2023 16:45:52 +0000

Neste artigo vamos criar os dois servidores, um com express e outro com fastify e deixar pronto para alternar entre um e outro mudando apenas o valor de uma variável.

Para dar continuidade ao projeto, vamos criar uma pasta src na raiz do projeto e outra pasta chamada infra dentro de src. Dentro de infra vamos criar uma pasta ports e dentro de ports mais duas pasta express e fastify. A estrutura de pastas devera ficar como o exemplo abaixo:

Antes de seguir vamos instalar algumas bibliotecas como dependencies:

yarn add dotenv express fastify

e outra como devDependencies

yarn add @types/express -D

dotenv: pacote utilizado em projetos Node.js para carregar variáveis de ambiente de arquivos .env. Ele é especialmente útil para gerenciar configurações sensíveis e variáveis que podem variar de ambiente para ambiente (por exemplo, desenvolvimento, teste e produção) sem a necessidade de codificar essas informações diretamente no código.

express: framework para aplicativo da web do Node.js mínimo e flexível que fornece um conjunto robusto de recursos.

fastify: é uma estrutura da Web altamente focada em fornecer a melhor experiência de desenvolvimento com o mínimo de sobrecarga e uma poderosa arquitetura de plug-in. É inspirado no Hapi e no Express.

@types/express: adiciona tipagem estática ao express, o que permite ao TypeScript verificar tipos em tempo de compilação. Com isso, erros relacionados a tipos são detectados antecipadamente, evitando problemas em tempo de execução.

Criando o server express

Dentro da pasta express vamos criar um arquivo index.ts e colocar o seguinte código:

import 'dotenv/config'
import express from 'express'

// dotenv/config: usado para carregar as variáveis de ambiente do arquivo .env.

// express: módulo do express para criar o servidor web e tratar
// as rotas e requisições HTTP.

const PORT = 5000
// define a porta na qual o servidor Express irá escutar as
// requisições HTTP

const app = express()

// Aqui, uma instância do servidor Express é criada e armazenada
// na variável app. Essa instância será responsável por gerenciar
// as rotas, as requisições e as respostas.

app.listen(PORT, () => {
  console.log(`Express app listening on port ${PORT}`)
})

// app.listen(...): Essa função é usada para iniciar o servidor
// Express e fazê-lo começar a ouvir as requisições HTTP na porta
// especificada. Quando uma requisição é recebida na porta
// especificada, o Express cuida de roteá-la para o handler
// apropriado.

// O console.log exibe uma mensagem indicando que o servidor
// Express foi iniciado e está ouvindo na porta 5000.

export { app }

// O objeto app é exportado para que possa ser utilizado em outros
// módulos da aplicação. Isso permite que outros arquivos acessem
// o servidor Express e adicionem rotas ou funcionalidades
// adicionais, se necessário.

Agora vamos criar dentro da pasta src um arquivo chamado server.ts e importar a instância do express:

const express = './infra/ports/express'

require(express)

No arquivo package.json vamos criar um script pra subir o servidor, pra esse fim vamos usar a biblioteca tsx que executará os arquivos .ts em modo de observação(watch):

"scripts": {
    "start:dev": "tsx watch src/server.ts"
  },

O arquivo package.json atualizado ficará assim:

{
  "name": "dev-to",
  "version": "1.0.0",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
    "start:dev": "tsx watch src/server.ts"
  },
  "devDependencies": {
    "@types/express": "^4.17.17",
    "@types/node": "^20.4.5",
    "tsup": "^7.1.0",
    "tsx": "^3.12.7",
    "typescript": "^5.1.6"
  },
  "dependencies": {
    "dotenv": "^16.3.1",
    "express": "^4.18.2",
    "fastify": "^4.20.0"
  }
}

Terminado esse trabalho execute o comando yarn start:dev no terminal pra subir a aplicação, que deverá ter a seguinte saída caso ocorra tudo como esperado:

Crindo o server com fastify

Dentro da pasta fastify vamos criar um arquivo index.ts e colocar o seguinte código:

import 'dotenv/config'
import fastify from 'fastify'

// dotenv/config: usado para carregar as variáveis de ambiente do arquivo .env.
// fastify: módulo do Fastify utilizado para criar o servidor web e tratar as rotas e requisições HTTP.

const server = fastify({ logger: true })

// Aqui, uma instância do servidor Fastify é criada com a opção
// logger: true. Isso habilita o registro de logs para as
// requisições recebidas pelo servidor, o que pode ser útil para
// depuração e monitoramento.

const app = async () => {
// O código define uma função assíncrona chamada app. Essa função
// será responsável por iniciar o servidor Fastify e ouvir as
// requisições.

  try {
    server.listen({
      host: '0.0.0.0',
      port: process.env.PORT_SERVER ? Number(process.env.PORT_SERVER) : 5000,
    })
    console.log(`Server fastify running in port ${5000}`)
  } catch (error) {
    console.error(`Erro server fastify`, error)
  }
}

// O bloco try...catch é usado para lidar com qualquer exceção que
// possa ocorrer durante o processo de inicialização do servidor.

// server.listen(...): Essa função é usada para iniciar o servidor
// e começar a ouvir as requisições HTTP. Ela recebe um objeto de
// opções como argumento. Neste caso, o servidor está configurado
// para escutar em todas as interfaces de rede (0.0.0.0) e na
// porta definida numa variável de ambiente chamada PORT_SERVER.
// Se essa variável não estiver definida, o servidor usará a porta
// 5000 por padrão.

// O console.log exibe uma mensagem indicando que o servidor
// Fastify foi iniciado e está ouvindo na porta 5000.

// Se algum erro ocorrer durante a inicialização do servidor, o
// bloco catch será acionado e exibirá uma mensagem de erro no
// console.

app()

Crie um arquivo .env na raiz do projeto e coloque o código abaixo:

SERVER_TYPE= // Os valores são express ou fastify
PORT_SERVER=5000

O próximo passo é atualizar o arquivo server.ts pra subir o servidor de acordo com o valor da variável de ambiente SERVER_TYPE fornecida no arquivo .env. Com a alteração o arquivo ficará como apresentado abaixo:

import 'dotenv/config'

const express = './infra/ports/express'
const fastify = './infra/ports/fastify'
const server = process.env.SERVER_TYPE === 'fastify' ? fastify : express

require(server)

Agora você pode alternar entre express e fastify alterando o valor da variável SERVER_TYPE. Ao escolher o fastify a saída no terminal deverá ser assim:

Aqui chega ao fim o segundo artigo da série. Qualquer dúvida deixe nos comentários que terei o prazer de responder.

Guia Prático: Aprenda a Construir uma API Node.js Desacoplada

Zoranildo Santos — Wed, 26 Jul 2023 16:45:25 +0000

O intuito dessa série de artigos é mostrar na prática como criar e estruturar inicialmente uma aplicação Node.js o mais desacoplado possível com typescript usando conceitos de S.O.L.I.D e Clean Architecture. Ao final teremos uma api onde poderemos mudar facilmente por exemplo de express para fastify, prisma para typeorm, postgresql para mongoDb mudando apenas a variável de ambiente. Acompanhe essa série e verás.

Nesse primeiro artigo vamos iniciar o projeto e configurar o typescript.

Criando o projeto:

Vamos iniciar o projeto usando o comando abaixo que irá gerar o arquivo package.json. Em qual local vai ficar o projeto na sua máquina é de sua escolha.

yarn init -y

Instalando como devDependencies as seguintes bibliotecas:

yarn add @types/node tsup tsx typescript -D

Qual a utilidade de cada pacote:

@types/node: biblioteca que fornece definições de tipos (TypeScript) para os módulos nativos do Node.js. Ela é usada em projetos TypeScript quando se deseja obter suporte para a verificação de tipos.

tsx: biblioteca utilizada para executar arquivos TypeScript (com extensão .ts) diretamente no Node.js, sem a necessidade de compilar previamente os arquivos para JavaScript (extensão .js). O pacote tsx foi aprimorado com esbuild para executar arquivos TypeScript e ESM.

tsup: é uma ferramenta de empacotamento (bundling) e compilação para projetos TypeScript. Ela facilita a criação de pacotes JavaScript a partir do código TypeScript e é uma alternativa mais simples e minimalista comparada a ferramentas mais complexas de empacotamento, como o Webpack e Rollup.

typescript: é uma linguagem(ou preset) para JavaScript. O TypeScript adiciona tipos opcionais ao JavaScript que oferecem suporte a ferramentas para aplicativos JavaScript de grande escala para qualquer navegador, para qualquer host, em qualquer sistema operacional. O TypeScript é compilado para JavaScript legível e baseado em padrões.

Configurando o typescript:

Crie na raiz do projeto um arquivo tsconfig.json
Adcione ao arquivo o seguinte código

{
  "compilerOptions": {
    "target": "es2017",
    "strictNullChecks": true,
    "module": "commonjs",
    "moduleResolution": "node",
    "baseUrl": "./src",
    "rootDir": "./",
    "outDir": "./dist",
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "strict": true,
  }
}

Crie na raiz do projeto o arquivo .gitignore com o seguinte conteúdo:

node_modules/

No final desse primeiro artigo o projeto deverá ter a estrutura abaixo:

Nesse artigo ficamos por aqui. No próximo artigo vamos codar dois server um com fastify e outro com express e alternar entre um e outro mudando apenas uma variável de ambiente.

Aprenda a Criar um Bouncy Loading Animation Apenas com CSS

Zoranildo Santos — Wed, 19 Jul 2023 10:43:51 +0000

O intuito do artigo não é apenas mostrar como podemos criar um loading bouncy apenas usando css, mas também explicar o que cada propriedade css faz para que ao fim tenhamos um bouncy loading animation.

.loader {
  display: inline-block;
}

.loader: É uma classe que define um elemento como um bloco em linha (inline-block). No contexto dessa animação, ele deve ser aplicado a um elemento que contém os elementos com a classe .loader-ball.

.loader-ball {
  display: inline-block;
  width: 20px;
  height: 20px;
  background-color: #ffff;
  margin-inline: 5px;
  border-radius: 50%;
  animation: bounce 450ms alternate infinite;
}

.loader-ball: É uma classe que define os elementos que formam as bolas animadas. Cada bola é um círculo com 20px de largura e altura (width: 20px; height: 20px;) e tem a cor de fundo branca (background-color: #ffff;).

As bolas têm um espaçamento horizontal entre elas de 5px (margin-inline: 5px) e têm o formato de um círculo perfeito devido ao border-radius: 50%. Além disso, a animação de "bounce" é aplicada a essas bolas, com duração de 450ms, alternando entre o estado inicial e final de forma infinita (animation: bounce 450ms alternate infinite).

.loader-ball:nth-child(1) {
  background-color: blue;
  animation-delay: 75ms;
}

.loader-ball:nth-child(2) {
  background-color: yellow;
  animation-delay: 150ms;
}

.loader-ball:nth-child(3) {
  background-color: green;
  animation-delay: 300ms;
}

.loader-ball:nth-child(1), .loader-ball:nth-child(2), .loader-ball:nth-child(3): Essas são regras adicionais que especificam o estilo de cada bola individualmente.

Cada uma das bolas é selecionada por seu índice (1, 2 e 3, respectivamente) e possui uma cor de fundo diferente (azul, amarelo e verde, respectivamente) e um atraso específico na animação.

O primeiro elemento (:nth-child(1)) tem um atraso de 75ms, o segundo (:nth-child(2)) tem um atraso de 150ms e o terceiro (:nth-child(3)) tem um atraso de 300ms. Isso cria um efeito de animação escalonado, onde cada bola começa a animar após um pequeno atraso em relação à bola anterior.

@keyframes bounce {
  from {
    transform: scaleX(1.25);
  }
  to {
    transform: translateY(-50px) scaleX(1);
  }
}

@keyframes bounce: Essa é uma regra de animação keyframes que define a animação chamada "bounce". Essa animação é definida com duas etapas (from e to) que representam o estado inicial e final da animação.

Durante a animação, a bola é escalada horizontalmente para 1.25 vezes o seu tamanho original (transform: scaleX(1.25);) e é movida para cima (na direção negativa do eixo Y) em 50px (transform: translateY(-50px) scaleX(1);). Isso cria o efeito de "quicar" da bola enquanto ela é reduzida horizontalmente e movida para cima e para baixo.

Código css completo:

.loader {
  display: inline-block;
}
.loader-ball {
  display: inline-block;
  width: 20px;
  height: 20px;
  background-color: #ffff;
  margin-inline: 5px;
  border-radius: 50%;
  animation: bounce 450ms alternate infinite;
}

.loader-ball:nth-child(1) {
  background-color: blue;
  animation-delay: 75ms;
}

.loader-ball:nth-child(2) {
  background-color: yellow;
  animation-delay: 150ms;
}

.loader-ball:nth-child(3) {
  background-color: green;
  animation-delay: 300ms;
}

@keyframes bounce {
  from {
    transform: scaleX(1.25);
  }
  to {
    transform: translateY(-50px) scaleX(1);
  }
}

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Static Template</title>
    <link rel="stylesheet" href="styles.css" />
  </head>
  <body>
    <span class="loader">
      <span class="loader-ball"></span>
      <span class="loader-ball"></span>
      <span class="loader-ball"></span>
      <span class="loader-ball"></span>
    </span>
  </body>
</html>

Caso queira ver o código funcionando acesse o CodeSandBox

Docker Descomplicado: Um Resumo Prático dos Principais Comandos

Zoranildo Santos — Tue, 18 Jul 2023 21:15:30 +0000

O Docker é uma plataforma de código aberto usada para criar, gerenciar e executar aplicativos em contêineres. Nas linhas abaixo vamos apresentar um resumo dos comandos essenciais do Docker com explicações para cada um deles:

docker version

Exibe a versão do Docker instalada no sistema.

docker info

Fornece informações detalhadas sobre o ambiente do Docker, como número de contêineres, imagens, redes etc.

docker pull <nome_da_imagem>

Baixa uma imagem do Docker Hub ou de um registro especificado para o seu sistema local.

docker build -t <nome_da_imagem> <caminho_do_Dockerfile>

Constrói uma nova imagem a partir de um arquivo Dockerfile no diretório especificado, e atribui a ela um nome com a opção "-t".

docker run <nome_da_imagem>

Executa um contêiner a partir de uma imagem especificada.

docker ps

Lista todos os contêineres em execução no momento.

docker ps -a

Lista todos os contêineres, incluindo os que estão parados.

docker stop <ID_do_contêiner>

Interrompe a execução de um contêiner especificado pelo seu ID.

docker start <ID_do_contêiner>

Inicia um contêiner que esteja parado, especificado pelo seu ID.

docker restart <ID_do_contêiner>

Reinicia um contêiner em execução, especificado pelo seu ID.

docker rm <ID_do_contêiner>

Remove um contêiner especificado pelo seu ID. (O contêiner deve estar parado)

docker rmi <nome_da_imagem>

Remove uma imagem específica do sistema local.

docker images

Lista todas as imagens disponíveis no sistema local.

docker exec -it <ID_do_contêiner> <comando>

Executa um comando dentro de um contêiner em execução. A opção "-it" permite a interação com o terminal do contêiner.

docker logs <ID_do_contêiner>

Exibe os logs de um contêiner específico.

docker buildx create --use

Cria um novo builder do tipo Buildx e torna-o o builder padrão.

docker-compose up

Cria e inicia todos os serviços definidos em um arquivo docker-compose.yml.

docker-compose down

Para e remove todos os contêineres, redes e volumes associados a um arquivo docker-compose.yml.

docker network create <nome_da_rede>

Cria uma nova rede personalizada para os contêineres.

docker system prune

Remove todos os recursos não utilizados, como contêineres parados, imagens não utilizadas, volumes e redes não utilizados.

Esses são alguns dos comandos mais úteis do Docker para começar a trabalhar com contêineres. Lembre-se de que o Docker oferece muitos outros comandos e opções, e a documentação oficial é uma excelente fonte de informações adicionais.

CLI Cheat Sheet oficial do docker.

Bootcamp React Feature Toggle - Apresentação do projeto

Zoranildo Santos — Tue, 18 Jul 2023 14:01:46 +0000

Bem-vindos ao Bootcamp React Feature Toggle! Neste curso, vamos utilizar uma série de tecnologias populares para desenvolvimento web, incluindo TypeScript, React, Vite, Vitest, Firebase, ESLint e Prettier.

Durante o bootcamp, iremos nos concentrar no recurso de "feature toggle" - uma técnica que permite habilitar ou desabilitar recursos de software em tempo de execução, ajudando a controlar o comportamento de uma aplicação em produção. E para isso, além das tecnologias mencionadas, também vamos utilizar o Remote Config do Firebase - uma plataforma que nos permite atualizar as configurações da nossa aplicação em tempo real.

Neste primeiro vídeo, vamos apresentar o projeto que iremos construir ao longo do bootcamp, explicando os objetivos e funcionalidades que queremos alcançar.