Como configurar uma API Node.js com TypeScript em 2025

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!