Cinq API natives de Node.js qui remplacent des packages npm

Si vous installez encore des packages npm pour des requêtes HTTP basiques, des opérations sur fichiers ou des tests, vous ajoutez des dépendances inutiles à vos projets Node.js. Node.js moderne (v20+) inclut des API natives puissantes qui éliminent le besoin de nombreux packages populaires, réduisant la taille de votre bundle, améliorant la sécurité et simplifiant la maintenance.

Explorons cinq API natives essentielles de Node.js qui peuvent remplacer des packages npm que vous utilisez probablement en ce moment, avec des exemples pratiques montrant exactement comment effectuer la transition.

1. fetch() global remplace axios et node-fetch

L’API fetch native, stable depuis Node.js 18, gère la plupart des requêtes HTTP sans dépendances externes. Bien que des packages comme axios offrent des commodités telles que les intercepteurs et les nouvelles tentatives automatiques, fetch() couvre la majorité des cas d’usage.

Avant (avec axios) :

const axios = require('axios');
const response = await axios.get('https://api.github.com/users/nodejs');
console.log(response.data);

Après (fetch natif) :

const response = await fetch('https://api.github.com/users/nodejs');
const data = await response.json();
console.log(data);

Pour les timeouts, utilisez AbortController :

const controller = new AbortController();
setTimeout(() => controller.abort(), 5000);
const response = await fetch(url, { signal: controller.signal });

Quand conserver axios : Chaînes d’intercepteurs complexes, suivi de progression ou nouvelles tentatives automatiques de requêtes.

2. Le test runner node:test remplace Jest et Mocha

Le test runner intégré (stable et recommandé dans Node.js 20+) fournit une solution de test sans dépendances, parfaite pour les bibliothèques et les applications simples.

Avant (avec Jest) :

// Nécessite l'installation et la configuration de jest
describe('Math operations', () => {
  test('adds numbers', () => {
    expect(2 + 2).toBe(4);
  });
});

Après (node:test natif) :

import { test } from 'node:test';
import assert from 'node:assert';

test('adds numbers', () => {
  assert.strictEqual(2 + 2, 4);
});

Exécutez les tests avec : node --test ou node --test --watch pour une réexécution automatique.

Quand conserver Jest : Tests de snapshot, utilitaires de mocking étendus ou besoins de rapports de couverture de code.

3. Les helpers du système de fichiers remplacent rimraf, mkdirp et glob

Les méthodes fs modernes gèrent nativement les opérations récursives et la correspondance de motifs.

Avant (plusieurs packages) :

const rimraf = require('rimraf');
const mkdirp = require('mkdirp');
const glob = require('glob');

await rimraf('dist');
await mkdirp('dist/assets');
const files = await glob('src/**/*.js');

Après (fs natif) :

import { rm, mkdir } from 'node:fs/promises';
import { glob } from 'node:fs';

await rm('dist', { recursive: true, force: true });
await mkdir('dist/assets', { recursive: true });

// Note : glob() nécessite Node.js 22+
for await (const file of glob('src/**/*.js')) {
  console.log(file);
}

Ces fonctionnalités natives de Node.js éliminent trois dépendances avec une fonctionnalité identique.

4. crypto.randomUUID() remplace le package uuid

Générez des UUID cryptographiquement sécurisés sans le package uuid (161M de téléchargements hebdomadaires).

Avant :

const { v4: uuidv4 } = require('uuid');
const id = uuidv4();

Après :

import { randomUUID } from 'node:crypto';
const id = randomUUID();

Cette API intégrée génère des UUID version 4 conformes à la RFC-4122 avec les mêmes garanties de sécurité que le package uuid.

Quand conserver uuid : Génération de versions d’UUID autres que v4 (v1, v3, v5).

5. Le client WebSocket remplace le package ws

Node.js inclut un client WebSocket global (stable dans Node.js 22+). Il convient pour une utilisation côté client, mais le support WebSocket côté serveur nécessite toujours des packages comme ws.

Avant (avec ws) :

const WebSocket = require('ws');
const ws = new WebSocket('wss://echo.websocket.org');
ws.on('open', () => ws.send('Hello'));

Après (WebSocket natif) :

const ws = new WebSocket('wss://echo.websocket.org');
ws.onopen = () => ws.send('Hello');
ws.onmessage = (event) => console.log(event.data);

Quand conserver ws : Implémentations WebSocket côté serveur ou utilisation en production jusqu’à la stabilisation de l’API.

Effectuer la transition : considérations pratiques

Avant de remplacer des packages npm par des API natives, considérez :

• Exigences de version Node.js : Assurez-vous que votre environnement de production exécute Node.js 20+ (idéalement 22 LTS)
• Parité des fonctionnalités : Les API natives peuvent manquer de fonctionnalités avancées (intercepteurs axios, snapshots Jest)
• Familiarité de l’équipe : Prenez en compte les courbes d’apprentissage pour différentes API

Commencez par remplacer les utilitaires simples comme randomUUID() et les opérations sur le système de fichiers. Ceux-ci offrent des avantages immédiats avec un risque minimal. Pour des remplacements plus complexes comme les frameworks de test ou les clients HTTP, évaluez si les fonctionnalités natives répondent à vos exigences spécifiques.

Conclusion

Ces cinq API natives de Node.js démontrent comment la plateforme a évolué pour réduire la dépendance aux packages externes. En tirant parti de fetch natif, node:test, des méthodes fs modernes, des utilitaires crypto et du support WebSocket, vous pouvez réduire significativement l’empreinte de dépendances de votre projet tout en maintenant—ou même en améliorant—les fonctionnalités.

La clé est de savoir quand les API natives suffisent et quand les packages npm spécialisés apportent encore de la valeur. Commencez petit, testez minutieusement et migrez progressivement vers des solutions natives là où elles ont du sens pour votre cas d’usage.

FAQ

Gain Debugging Superpowers

Unleash the power of session replay to reproduce bugs, track slowdowns and uncover frustrations in your app. Get complete visibility into your frontend with OpenReplay — the most advanced open-source session replay tool for developers. Check our GitHub repo and join the thousands of developers in our community.