Por que TypeScript no backend

JavaScript com tipos

TypeScript é um superconjunto de JavaScript: todo JS válido é TS válido, mas o TS adiciona um sistema de tipos estático. Você anota qual forma têm seus dados e um compilador os verifica antes de executar o programa.

function somar(a: number, b: number): number {
  return a + b;
}

somar(2, 3);      // OK
somar(2, "3");    // ❌ erro de COMPILAÇÃO: "3" não é number

Em JavaScript esse somar(2, "3") seria executado e retornaria "23" (um bug silencioso). Em TypeScript nem sequer compila.

O que você ganha

• Detectar erros em compilação, não em produção: typos, argumentos trocados, propriedades que não existem, undefined não previstos.
• Autocompletar e refatorações confiáveis: o editor conhece a forma exata de cada objeto, então sugere campos e avisa se você renomeia algo.
• Documentação viva: a assinatura function criarUsuario(dto: UsuarioDTO) já diz o que a função espera.

tsconfig e compilação

A configuração do projeto vive em tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "strict": true,
    "outDir": "dist"
  }
}

strict: true ativa as verificações mais úteis (entre elas strictNullChecks, que te obriga a tratar null/undefined).

Para executar seu código você tem dois caminhos:

• Compilar com tsc para JavaScript e executar a saída com Node: tsc && node dist/index.js.
• ts-node (ou tsx) para executar o .ts diretamente em desenvolvimento: ts-node src/index.ts.

Chave: em runtime continua sendo JavaScript

O compilador apaga os tipos (type erasure). O .js que o Node executa não tem nem rastro de : number nem de interface:

interface Usuario { nome: string; idade: number; }

function saudar(u: Usuario) {
  return "Olá " + u.nome;
}

compila aproximadamente para:

function saudar(u) {
  return "Olá " + u.nome;
}

A interface desaparece. Isso tem uma consequência enorme, que veremos no final: os tipos não existem em tempo de execução, então não protegem contra dados externos (o que chega por HTTP, do banco de dados, de um JSON.parse...). Os tipos garantem que seu código é coerente; não garantem que os dados de entrada tenham a forma prometida.