Hoje em dia, criar uma API eficiente e escalável com Node.js e TypeScript é mais simples e poderoso do que nunca. No CodeInit, gostamos de abordar tutoriais de maneira prática e direta, ajudando você a construir soluções profissionais que o mercado realmente pede. Neste artigo, vou te mostrar, passo a passo, como configurar uma API moderna utilizando as melhores práticas para 2025.
Se você é iniciante ou mesmo um desenvolvedor experiente buscando acelerar seu workflow, este guia é para você. Vamos juntos nessa jornada!
Por que usar Node.js e TypeScript?
Node.js continua sendo uma das tecnologias mais populares para backend, e quando combinado com TypeScript, você tem o melhor dos dois mundos: velocidade e segurança. TypeScript adiciona tipagem estática, o que torna seu código mais fácil de manter e reduz erros comuns.
Em 2025, é fundamental dominar ferramentas que trazem produtividade e que estão alinhadas com o mercado.
O que você precisa antes de começar
Antes de iniciar, você precisa garantir que o ambiente está preparado. Aqui estão os pré-requisitos:
- Node.js 20 ou superior
- Editor de texto - Recomendo o Visual Studio Code
- Conhecimento básico de JavaScript e terminal
- npm, yarn ou pnpm instalado no sistema
Dica: Use o terminal integrado do VS Code para seguir este tutorial mais facilmente.
Eu particularmente gosto de usar o pnpm. Para instlar o pnpm globalmente utitlize o comando abaixo:
npm i -g pnpm
Passo 1: Configurando o ambiente
Primeiro, certifique-se de que o Node.js está instalado:
node -v
Se tudo estiver certo, você deve ver a versão do Node.js. Caso contrário, instale a versão mais recente pelo site oficial.
Agora, vamos criar a estrutura do projeto:
mkdir minha-api && cd minha-api
pnpm init -y
Esse comando cria o arquivo package.json, que gerencia as dependências do projeto.
Passo 2: Instalando o TypeScript
TypeScript é essencial para quem busca manutenção e organização em projetos maiores. Vamos instalá-lo:
pnpm install typescript tsx @types/node -D
Agora, configure o TypeScript criando um arquivo tsconfig.json:
npx tsc --init
Edite o arquivo para refletir as melhores práticas de 2025:
{
"compilerOptions": {
"target": "ES2022",
"module": "CommonJS",
"strict": true,
"outDir": "dist",
"rootDir": "src"
}
}
Crie o diretório src onde vamos organizar nosso código:
mkdir src
Passo 3: Adicionando ESLint
Manter um código limpo é crucial. Vamos adicionar o ESLint para garantir qualidade e padronização.
Utilize o comando abaixo para configurar o ESLint:
pnpm create @eslint/config@latest
Configurações recomendadas para o ESLint
- How would you like to use ESLint? (To check syntax and find problems)
- What type of modules does your project use? (JavaScript modules (import/export)
- Which framework does your project use? (None)
- Does your project use TypeScript? (Yes)
- Where does your code run? (Node)
- Would you like to install them now? (Yes)
Apos a instalação, o arquivo eslint.config.js será criado na raiz do seu projeto.
Abaixo eu vou deixar a minha configuração, mas você configurar o ESlint com as regras que desejar.
import pluginJs from '@eslint/js'
import globals from 'globals'
import tseslint from 'typescript-eslint'
/** @type {import('eslint').Linter.Config[]} */
export default [
{files: ['**/*.{js,mjs,cjs,ts}']},
{languageOptions: { globals: globals.node }},
pluginJs.configs.recommended,
...tseslint.configs.recommended,
{
rules: {
semi: 'off',
quotes: ['error', 'single']
}
}
]
Vamos agora criar os comandos para executar o ESlint, adione os scripts no package.json:
...
"scripts": {
"lint": "npx eslint ./src/**",
"lint:fix": "npx eslint ./src/** --fix"
}
O primeiro comando roda o ESlint e mostra os erros no console, o segundo tenta fazer o fix do erros de forma automatica.
Execute no terminal:
pnpm lint
ou
pnpm lint:fix
Passo 4: Construindo a API
Criando a rota de saúde
Agora é hora de colocar a mão na massa e criar nossa API. Vamos usar o Express, um framework minimalista para Node.js.
Instale o Express e seus tipos:
pnpm add express @types/express
Crie o arquivo src/index.ts e adicione o seguinte código:
import express, { Request, Response } from 'express'
const app = express()
app.use(express.json())
// Rota de saúde com tipos definidos
app.get('/health', (req: Request, res: Response) => {
res.status(200).json({ status: 'API rodando com sucesso!' });
})
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
})
Para rodar o servidor, adicione o seguinte script ao package.json:
...
"scripts": {
...,
"start": "tsx watch src/index.ts"
}
E execute: npm start
Você deve ver a mensagem: "Servidor rodando na porta 3000". Teste acessando: http://localhost:3000/health para verificar a saúde da API.
Adicionando a rota de Pokémons
Agora vamos expandir a API com uma rota que retorna uma lista de Pokémons.
Atualize o arquivo src/index.ts adicionando o seguinte código:
// Interface para definir o tipo de um Pokémon
interface Pokemon {
id: number;
name: string;
type: string;
}
// Dados de exemplo
const pokemons: Pokemon[] = [
{ id: 1, name: 'Pikachu', type: 'Electric' },
{ id: 2, name: 'Charmander', type: 'Fire' },
{ id: 3, name: 'Bulbasaur', type: 'Grass/Poison' }
]
// Rota que retorna a lista de Pokémons
app.get('/pokemons', (req: Request, res: Response<Pokemon[]>) => {
res.status(200).json(pokemons)
})
Agora teste acessando: http://localhost:3000/pokemons para obter a lista de Pokémons.
Conclusão
Neste guia, você aprendeu como configurar uma API moderna com Node.js e TypeScript, começando com uma rota simples e expandindo para incluir dados tipados. Este é apenas o começo! Com essa base, você pode implementar autenticação, conexão com bancos de dados e muito mais.
Se este artigo foi útil, compartilhe com outros desenvolvedores e inscreva-se na nossa newsletter para não perder as próximas dicas. Vamos juntos dominar o mundo do desenvolvimento!
Top comments (0)