Por qué TypeScript en el backend

JavaScript con tipos

TypeScript es un superconjunto de JavaScript: todo JS válido es TS válido, pero TS añade un sistema de tipos estático. Anotas qué forma tienen tus datos y un compilador los verifica antes de ejecutar el programa.

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

sumar(2, 3);      // OK
sumar(2, "3");    // ❌ error de COMPILACIÓN: "3" no es number

En JavaScript ese sumar(2, "3") se ejecutaría y devolvería "23" (un bug silencioso). En TypeScript ni siquiera compila.

Qué ganas

• Detectar errores en compilación, no en producción: typos, argumentos cambiados, propiedades que no existen, undefined no contemplados.
• Autocompletado y refactors fiables: el editor conoce la forma exacta de cada objeto, así que sugiere campos y avisa si renombras algo.
• Documentación viva: la firma function crearUsuario(dto: UsuarioDTO) ya dice qué espera la función.

tsconfig y compilación

La configuración del proyecto vive en tsconfig.json:

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

strict: true activa las comprobaciones más útiles (entre ellas strictNullChecks, que te obliga a tratar null/undefined).

Para ejecutar tu código tienes dos caminos:

• Compilar con tsc a JavaScript y ejecutar la salida con Node: tsc && node dist/index.js.
• ts-node (o tsx) para ejecutar el .ts directamente en desarrollo: ts-node src/index.ts.

Clave: en runtime sigue siendo JavaScript

El compilador borra los tipos (type erasure). El .js que Node ejecuta no tiene ni rastro de : number ni de interface:

interface Usuario { nombre: string; edad: number; }

function saludar(u: Usuario) {
  return "Hola " + u.nombre;
}

compila aproximadamente a:

function saludar(u) {
  return "Hola " + u.nombre;
}

La interface desaparece. Esto tiene una consecuencia enorme, que veremos al final: los tipos no existen en tiempo de ejecución, así que no protegen contra datos externos (lo que llega por HTTP, de la base de datos, de un JSON.parse...). Los tipos garantizan que tu código es coherente; no garantizan que los datos de entrada tengan la forma prometida.