5 min de lecture0vue

NestJS 12 et la fin du code de liaison

NestJS 12 a posé les fondations ; les semaines suivantes ont apporté la partie amusante. Un module Drizzle officiel, un client HTTP basé sur fetch, et un adaptateur directement sur `node:http`, annoncé pour la prochaine version mineure, environ 50 % plus rapide qu'Express dans les benchmarks.

NestJSDrizzle ORMNode.jsTypeScriptExpress.jsFastifyZod

NestJS 12 est sorti fin août, et la version elle-même pose surtout des fondations : tous les paquets du cœur sont désormais publiés en ESM, les décorateurs de route acceptent des validateurs Standard Schema comme Zod et Valibot, la CLI a été reconstruite autour d'une nouvelle commande nest upgrade, et il existe un SDK d'observabilité officiel. Tout cela est bien. Mais ce qui me fait revenir, c'est ce qui est arrivé après la sortie : deux nouveaux modules officiels et un adaptateur annoncé qui, ensemble, remplacent le code de liaison que chaque projet Nest traînait avec lui.

DrizzleModule : Drizzle, à la manière de Nest

Drizzle garde le schéma en TypeScript et les requêtes proches du SQL. Jusqu'ici, l'intégrer à Nest voulait dire écrire un provider à la main ou choisir l'un des nombreux wrappers de la communauté. @nestjs/drizzle en est la version officielle, publiée par l'équipe Nest en septembre.

TypeScript
import { drizzle } from 'drizzle-orm/node-postgres';
import { DrizzleModule } from '@nestjs/drizzle';

@Module({
  imports: [
    DrizzleModule.forRoot({
      drizzle,
      connection: process.env.DATABASE_URL!,
    }),
  ],
})
export class AppModule {}

L'option drizzle reçoit la fonction drizzle() du driver de son choix : node-postgres ici, mais MySQL, SQLite, Neon, Turso et D1 passent par la même option. La base de données est globale, donc pas d'étape forFeature(). Un service n'a qu'à la demander :

TypeScript
@Injectable()
export class UsersService {
  constructor(@InjectDrizzle() private readonly db: NodePgDatabase) {}

  findOne(id: number) {
    return this.db.select().from(users).where(eq(users.id, id));
  }
}

Quelques détails montrent qu'il a été conçu par des gens qui s'y sont déjà brûlé les doigts :

  • forRootAsync() fonctionne avec ConfigService, ce qui compte car les options de forRoot() sont évaluées à l'import, parfois avant le chargement du fichier d'environnement.
  • Plusieurs bases de données ne sont que des imports nommés, injectés avec @InjectDrizzle('analytics').
  • Pour les tests, un provider personnalisé sur getDrizzleToken() suffit.
  • La documentation le dit clairement : ne pas lancer les migrations au démarrage quand plusieurs instances démarrent ensemble, mais exécuter drizzle-kit migrate comme étape de release.

Il cible la release candidate de Drizzle v1 et prend aussi en charge la v0.35 et au-delà. Il en est à la 0.0.2 sur npm, il faut donc s'attendre à ce qu'il évolue.

HttpClientModule : fetch, plus tout ce qu'on finit toujours par écrire

@nestjs/axios enveloppe Axios et renvoie des Observables RxJS, ce qui implique un firstValueFrom() autour de presque chaque appel. @nestjs/http-client repose au contraire sur le fetch natif de Node, n'a aucune dépendance tierce et renvoie des Promises.

TypeScript
@Module({
  imports: [
    HttpClientModule.register({
      name: 'github',
      baseUrl: 'https://api.github.com',
      timeout: '5s',
      retry: 3,
    }),
  ],
})
export class ReposModule {}

@Injectable()
export class ReposService {
  constructor(@InjectHttpClient('github') private readonly github: HttpClient) {}

  async find(owner: string, repo: string) {
    const { data } = await this.github.get<Repo>('/repos/:owner/:repo', {
      params: { owner, repo },
    });
    return data;
  }
}

Ce qui me plaît, c'est que ce que chaque projet réimplémente devient une option : des délais d'expiration par tentative exprimés en durées, des nouvelles tentatives avec backoff, des paramètres de chemin :name, un client nommé par API distante, et des intercepteurs écrits comme de simples fonctions ou comme des classes. Les erreurs sont typées (HttpResponseError, HttpTimeoutError, HttpNetworkError et HttpParseError, qui étendent toutes HttpClientError), et toHttpException() les convertit en exceptions Nest : un échec en amont devient une 502, un délai dépassé une 504. C'est exactement la correspondance que j'écrirais sinon à la main dans chaque service passerelle.

@nestjs/axios ne disparaît pas : la documentation fournit un tableau de migration, pas un avis de dépréciation.

platform-node : prévu pour la prochaine mineure, et celui qui m'enthousiasme le plus

Nest a deux adaptateurs HTTP. Express est celui par défaut, et le plus lent ; Fastify est rapide, mais y passer implique de réécrire les middlewares de style Express et le code @Res() pour l'API propre à Fastify. Le 9 octobre, Kamil Myśliwiec a ouvert une pull request pour un troisième : @nestjs/platform-node, qui repose directement sur node:http. Trois jours plus tard, le compte officiel de NestJS l'annonçait pour la prochaine version mineure, en se demandant ce que serait Nest s'il était « juste Nest ».

Cœur de Nest

platform-express

Express

node:http

platform-fastify

Fastify

platform-node

TypeScript
const app = await NestFactory.create(AppModule, new NodeAdapter());

Les requêtes et les réponses sont des sous-classes des IncomingMessage et ServerResponse de Node lui-même, dotées des helpers de style Express que les middlewares appellent réellement. La PR indique que helmet, compression, express-session, passport et d'autres (21 middlewares populaires au total) se sont comportés comme sur l'adaptateur Express. Le parsing du corps est intégré, et il rejette l'empoisonnement de prototype (prototype poisoning) comme le fait Fastify.

Le benchmark de la PR est le point fort. Une seule série de wrk sur un M1 Pro avec Node 24, en requêtes par seconde :

GET / GET /users/:id POST JSON
Nest + Express 37.1k 34.5k 28.2k
Nest + Fastify 52.4k 48.4k 40.2k
Nest + Node 55.1k 51.0k 42.4k

Environ 50 % plus rapide qu'Express et légèrement devant Fastify, sans quitter le modèle de programmation d'Express. Il diffère toutefois d'Express sur quelques points à connaître avant de basculer : les routes sont résolues par spécificité plutôt que par ordre de déclaration, les chemins sont sensibles à la casse, et les chaînes renvoyées par les handlers partent en text/plain.

À l'heure où j'écris ces lignes, il n'est pas encore sur npm ; la pull request est toujours ouverte. Une fois la prochaine mineure publiée, le changement tient en la ligne ci-dessus.

Où cela laisse NestJS

Au final, une nouvelle application Nest peut gérer la persistance, les appels HTTP sortants et, bientôt, son propre serveur HTTP avec uniquement des paquets officiels, en ESM, validés avec la bibliothèque de schémas qu'on utilise déjà. Le framework absorbe le code de liaison que je copiais d'un projet à l'autre, et c'est la meilleure sorte de release.

Sources