Comment écrire une API REST en TypeScript en 30 minutes : en pratique

Introduction : pourquoi TypeScript pour une API REST ?

Le développement web moderne est impensable sans des API claires et évolutives. TypeScript, en tant que surcouche fortement typée de JavaScript, permet de créer des API REST fiables avec un minimum d'erreurs d'exécution. Dans cet article, nous allons pratiquement, étape par étape, créer une API REST complète en TypeScript en utilisant le framework populaire Express. L'ensemble du processus ne vous prendra pas plus de 30 minutes, et le résultat sera prêt à être utilisé dans des projets réels.

Nous aborderons : l'initialisation du projet, la configuration de TypeScript, la création de routes, le travail avec les middleware, la gestion des erreurs et le test des endpoints. Tous les exemples de code pourront être immédiatement exécutés et adaptés à vos besoins.

Étape 1 : Initialisation du projet et installation des dépendances

Commencez par créer un nouveau répertoire pour le projet et initialisez-le. Ouvrez le terminal et exécutez :

mkdir my-ts-api
cd my-ts-api
npm init -y

Installez maintenant les paquets nécessaires :

npm install express
npm install -D typescript @types/node @types/express ts-node nodemon

Créez le fichier de configuration TypeScript :

npx tsc --init

Modifiez tsconfig.json en incluant les options suivantes :

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

Ajoutez les scripts dans package.json :

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js",
  "dev": "nodemon --exec ts-node src/index.ts"
}

Étape 2 : Création de la structure de base et du premier endpoint

Créez le dossier src et, à l'intérieur, le fichier index.ts. Commençons par un serveur simple qui répondra aux requêtes GET :

import express, { Request, Response } from 'express';

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware pour le parsing JSON
app.use(express.json());

// Route de base
app.get('/', (req: Request, res: Response) => {
  res.send('L\'API REST en TypeScript fonctionne !');
});

app.listen(PORT, () => {
  console.log(`Serveur démarré sur http://localhost:${PORT}`);
});

Lancez le serveur avec la commande npm run dev et ouvrez http://localhost:3000. Vous verrez un message de bienvenue.

Création du modèle de données

Pour une API complète, nous avons besoin d'une entité. Créons un modèle d'utilisateur simple :

// src/models/user.ts
export interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

export type CreateUserDto = Omit;

Étape 3 : Implémentation des opérations CRUD

Créons maintenant un contrôleur et des routes pour travailler avec les utilisateurs. Créez le fichier src/routes/users.ts :

import { Router, Request, Response } from 'express';
import { User, CreateUserDto } from '../models/user';

const router = Router();
let users: User[] = [
  { id: 1, name: 'Ivan', email: 'ivan@example.com', age: 28 },
  { id: 2, name: 'Maria', email: 'maria@example.com', age: 32 }
];
let nextId = 3;

// GET /users - obtenir tous les utilisateurs
router.get('/', (req: Request, res: Response) => {
  res.json(users);
});

// GET /users/:id - obtenir un utilisateur par ID
router.get('/:id', (req: Request, res: Response) => {
  const id = parseInt(req.params.id);
  const user = users.find(u => u.id === id);
  if (!user) {
    return res.status(404).json({ message: 'Utilisateur non trouvé' });
  }
  res.json(user);
});

// POST /users - créer un nouvel utilisateur
router.post('/', (req: Request, res: Response) => {
  const { name, email, age }: CreateUserDto = req.body;
  if (!name || !email || !age) {
    return res.status(400).json