Comment démarrer avec ElysiaJS, OpenAPI et Bun en 2026

Choisir le bon framework peut faire toute la différence dans la construction d'APIs efficaces et évolutives. ElysiaJS, un framework Node.js léger, s'associe exceptionnellement bien avec le runtime haute performance de Bun et la standardisation d'OpenAPI pour la documentation et la génération de clients. Cette combinaison offre aux développeurs une voie simplifiée pour créer des services RESTful robustes avec un minimum de surcharge. Alors que les APIs deviennent l'épine dorsale des applications modernes, démarrer avec ElysiaJS, OpenAPI et Bun vous permet de livrer rapidement des points de terminaison (endpoints) typés et bien documentés. Dans ce guide, nous couvrirons tout, des fondamentaux d'ElysiaJS à la configuration pratique, aux étapes d'installation sur différentes plateformes et aux exemples de code pratiques. Ce tutoriel vous aidera à intégrer ElysiaJS avec OpenAPI de manière transparente, en tirant parti de la vitesse de Bun pour une expérience de développement optimale.

Qu'est-ce qu'ElysiaJS ?

ElysiaJS est un framework web Node.js léger et rapide, conçu pour être minimaliste mais hautement extensible pour la création d'APIs RESTful. Il met l'accent sur une faible empreinte, un support TypeScript propre et une API intuitive pour définir les routes, les middlewares et les plugins. ElysiaJS vise à offrir des performances avec une expérience conviviale pour les développeurs et une forte intégration OpenAPI prête à l'emploi. Ses points forts incluent un support OpenAPI de premier ordre, un écosystème de plugins et une conception qui privilégie la vitesse et la simplicité sans vous enfermer dans des abstractions lourdes. Cela rend ElysiaJS particulièrement attrayant pour les développeurs qui veulent se concentrer sur la logique plutôt que sur le code passe-partout, tout en s'assurant que leurs APIs sont faciles à documenter et à consommer via les spécifications OpenAPI.

Pourquoi choisir ElysiaJS en 2026 ?

Choisir ElysiaJS apporte plusieurs avantages convaincants qui améliorent votre processus de développement d'API.

1. La performance se distingue par son runtime léger et son accent sur la gestion rapide des routes et la faible surcharge, permettant aux applications de s'adapter efficacement sous charge. La préparation OpenAPI intégrée signifie que vous pouvez générer et servir des spécifications OpenAPI sans effort, ce qui simplifie la documentation de l'API et la génération de clients – crucial pour les équipes collaborant sur des microservices ou des APIs publiques.
2. L'expérience développeur est un autre point fort : ElysiaJS est compatible avec TypeScript, avec des définitions de routes concises et une architecture modulaire qui favorise la croissance à mesure que votre projet s'étend. Son écosystème comprend un ensemble croissant de plugins pour le support OpenAPI, la documentation et les utilitaires de test, s'intégrant en douceur avec les outils existants. La conception axée sur OpenAPI assure la cohérence entre votre code et votre documentation, réduisant les efforts de maintenance.

Qu'est-ce que Bun ?

Bun est un runtime JavaScript rapide, un gestionnaire de paquets et un bundler tout-en-un. Il est conçu pour être un remplacement direct de Node.js dans de nombreux cas, offrant des temps de démarrage plus rapides et des outils efficaces. Bun peut accélérer les flux de travail de développement, l'installation des dépendances et l'exécution des scripts, ce qui en fait un compagnon populaire pour les frameworks modernes comme ElysiaJS. En gérant plusieurs rôles dans l'écosystème JavaScript, Bun réduit le changement de contexte, permettant aux développeurs de se concentrer sur la construction plutôt que sur la gestion des outils. Sa compatibilité avec les APIs Node assure une transition en douceur, tandis que le support natif de TypeScript et JSX améliore la productivité dans les projets ElysiaJS.

Installation de Bun (MacOS, Linux et Windows)

Installer et faire fonctionner Bun est simple sur toutes les plateformes, vous assurant de pouvoir l'associer rapidement à ElysiaJS.

1. Pour MacOS, ouvrez le Terminal et exécutez le script d'installation : curl -fsSL https://bun.sh/install | bash. Cela télécharge et configure Bun, l'ajoutant à votre PATH. Vérifiez avec bun --version.
2. Sous Linux, utilisez la même commande curl dans votre terminal : curl -fsSL https://bun.sh/install | bash. Il prend en charge les principales distributions comme Ubuntu et Fedora. Redémarrez votre shell ou sourcez votre profil, puis vérifiez bun --version pour confirmer.
3. Les utilisateurs de Windows peuvent l'installer via PowerShell en tant qu'administrateur : powershell -c "irm bun.sh/install.ps1 | iex". Cela gère la configuration, y compris l'intégration de Chocolatey si nécessaire. Lancez à nouveau PowerShell et exécutez bun --version pour vérifier.

Dans tous les cas, Bun s'installe en quelques secondes et est prêt pour les projets ElysiaJS – aucune configuration supplémentaire n'est requise pour une utilisation de base.

Démarrer avec ElysiaJS

Se lancer dans un projet ElysiaJS commence par quelques prérequis :

• Un environnement Node.js ou Bun installé (si vous optez pour les outils plus rapides de Bun, téléchargez-le depuis bun.sh comme indiqué précédemment).
• Un répertoire de projet.

Pour initialiser, utilisez Bun pour la vitesse : bun create elysia my-api. Cela génère une structure de base avec package.json et le support TypeScript.

Sans Bun, exécutez npm create elysia my-api via npm. Naviguez dans le dossier avec cd my-api, et vous êtes prêt à définir les routes.

La configuration minimale d'ElysiaJS encourage le prototypage rapide – importez le module principal, définissez les gestionnaires et écoutez sur un port. Cette base s'adapte facilement, intégrant OpenAPI pour la documentation dès le départ.

Installation et configuration d'ElysiaJS

L'installation est une seule ligne une fois que votre runtime est prêt. Avec Bun : bun install elysia.

Pour npm : npm install elysia. Si vous utilisez TypeScript, ajoutez @types/node pour une complétude.

La configuration implique la création d'un fichier d'entrée, index.ts :

import { Elysia } from "elysia";

const app = new Elysia().get("/", () => "Hello Elysia").listen(3000);

console.log(
  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
);

Exécutez avec Bun : bun run index.ts, ou Node : npx ts-node index.ts. Visitez "http://localhost:3000" pour voir la réponse. Cette application de base confirme la simplicité d'ElysiaJS – étendez-la avec des middlewares ou des plugins selon vos besoins.

Intégrer ElysiaJS avec OpenAPI

Le support OpenAPI d'ElysiaJS brille à travers les plugins, permettant des spécifications auto-générées à partir de vos routes. Installez le plugin : bun add @elysiajs/openapi (ou l'équivalent npm).

Configurez dans votre application :

import { Elysia } from 'elysia'
import { openapi, fromTypes } from '@elysiajs/openapi'

export const app = new Elysia()
    .use(
        openapi({
            references: fromTypes()
        })
    )
    .get(
        '/pets',
        () => [
            { id: 1, name: 'Fluffy' },
            { id: 2, name: 'Spot' }
        ],
        ({
            summary: 'Get all pets',
            responses: { 200: { description: 'Success' } }
        } as any)
    )
    .listen(3000)

Accédez à la documentation à "/openapi" ou "/docs" (c'est-à-dire "http://localhost:3000/openapi"), où Swagger UI affiche des schémas interactifs. ElysiaJS infère les types des gestionnaires, renforçant l'alignement code-spécification. Pour des configurations avancées, générez à partir de TypeScript en utilisant les outils de l'écosystème, assurant que ElysiaJS avec OpenAPI évolue avec votre base de code.

Cliquez sur "Test Request" pour tester le point de terminaison d'API "Pets" que nous venons de créer.

Exemple de code : Construire et tester une application ElysiaJS de base

Le test d'ElysiaJS commence par une application simple. Développez le "hello world" :

import { Elysia } from 'elysia'

const app = new Elysia()
  .get('/', () => 'Hello from ElysiaJS!')
  .post('/echo', ({ body }) => body, {
    body: t.Object({ message: t.String() })
  })
  .listen(3000, () => console.log('Server listening on http://localhost:3000'))

Exécutez et testez avec curl : curl -X POST http://localhost:3000/echo -H "Content-Type: application/json" -d "{\"message\": \"Test\"}". Attendez-vous à la réponse en écho.

Pour les tests unitaires, utilisez bun:test. Créez un dossier "test" dans le répertoire racine de votre projet et ajoutez un fichier index.test.ts avec le code suivant :

import { describe, expect, it } from 'bun:test'
import { Elysia } from 'elysia'

describe('Elysia', () => {
    it('returns a response', async () => {
        const app = new Elysia().get('/', () => 'hi')

        const response = await app
            .handle(new Request('http://localhost/'))
            .then((res) => res.text())

        expect(response).toBe('hi')
    })
})

Pour exécuter les tests, utilisez simplement la commande : bun test.

Ceci valide les fonctionnalités de base, confirmant la fiabilité d'ElysiaJS.

Exemple de code : ElysiaJS avec OpenAPI en action

Pour ElysiaJS avec OpenAPI, construisez une API de gestion d'animaux de compagnie :

import { Elysia, t } from 'elysia'
import { openapi, fromTypes } from '@elysiajs/openapi'

const app = new Elysia()
  .use(
    openapi({
      references: fromTypes()
    })
  )
  .get('/pets', () => [
    { id: 1, name: 'Fluffy', type: 'Cat' },
    { id: 2, name: 'Spot' }
  ], ({
    summary: 'List pets',
    responses: {
      200: {
        description: 'Success',
        content: {
          'application/json': {
            schema: {
              type: 'array',
              items: { type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' }, type: { type: 'string' } } }
            }
          }
        }
      }
    }
  } as any))
  .post('/pets', ({ body }) => ({ id: Date.now(), ...body }), {
    body: t.Object({ name: t.String(), type: t.String() }),
    summary: 'Create pet',
    responses: { 200: { description: 'Created' } }
  })
  .listen(3000, () => console.log('Server listening on http://localhost:3000'))
import { Elysia, t } from 'elysia'
import { openapi, fromTypes } from '@elysiajs/openapi'

const app = new Elysia()
  .use(
    openapi({
      references: fromTypes()
    })
  )
  .get('/pets', () => [
    { id: 1, name: 'Fluffy', type: 'Cat' },
    { id: 2, name: 'Spot' }
  ], ({
    summary: 'List pets',
    responses: {
      200: {
        description: 'Success',
        content: {
          'application/json': {
            schema: {
              type: 'array',
              items: { type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' }, type: { type: 'string' } } }
            }
          }
        }
      }
    }
  } as any))
  .post('/pets', ({ body }) => ({ id: Date.now(), ...body }), {
    body: t.Object({ name: t.String(), type: t.String() }),
    summary: 'Create pet',
    responses: { 200: { description: 'Created' } }
  })
  .listen(3000, () => console.log('Server listening on http://localhost:3000'))

Testez la requête POST : curl -X POST http://localhost:3000/pets -H "Content-Type: application/json" -d '{"name": "Scooby Doo", "type": "Dog"}'. Visitez /openapi pour la documentation Swagger, vérifiant les schémas et les chemins.

Conseils pratiques pour la production

La sûreté des types est primordiale : Utilisez les types TypeScript pour les corps de requête, les réponses et les paramètres de route afin d'améliorer la fiabilité et la précision de la génération OpenAPI. L'observabilité nécessite l'ajout de middlewares de journalisation, de métriques et de gestion des erreurs pour surveiller le comportement de l'API. Les mesures de sécurité incluent l'implémentation de contrôles CORS, la validation des entrées, la limitation de débit et l'authentification si nécessaire. Le packaging implique l'utilisation des étapes de construction de production de Bun ou de votre bundler pour produire un paquet de déploiement léger. La documentation exige de maintenir la spécification OpenAPI synchronisée avec le code pour garantir que les SDK clients et la documentation restent à jour.

Foire Aux Questions

Q1 : ElysiaJS est-il adapté aux applications à grande échelle ?
Rép : Oui, sa conception modulaire et son accent sur la performance le rendent évolutif pour les APIs d'entreprise.

Q2 : ElysiaJS nécessite-t-il TypeScript ?
Rép : Non, mais c'est fortement recommandé pour une génération OpenAPI avec sûreté des types.

Q3 : Comment Bun se compare-t-il à Node.js avec ElysiaJS ?
Rép : Bun offre des installations et des exécutions plus rapides, mais Node.js fonctionne si vous préférez la familiarité.

Q4 : Puis-je générer des spécifications OpenAPI à partir de code existant ?
Rép : Absolument, en utilisant des plugins ElysiaJS qui infèrent à partir des définitions de routes.

Q5 : Quels frameworks de test s'associent le mieux à ElysiaJS ?
Rép : Apidog, Vitest ou Jest pour les tests unitaires, avec Supertest pour les simulations d'API.

Conclusion : Créez des APIs plus intelligentes avec ElysiaJS, OpenAPI et Bun

ElysiaJS, avec son mélange de vitesse et de simplicité, associé à l'efficacité du runtime de Bun et à la puissance de documentation d'OpenAPI, forme une pile convaincante pour le développement d'API. De l'installation aux tests, ce guide vous a préparé à commencer à construire. Expérimentez avec les exemples, affinez vos routes et voyez vos projets prospérer – ElysiaJS est prêt à alimenter votre prochaine création.