Contract First et @feelai/contract : Une nouvelle approche pour le développement d'applications sécurisées par typage

Dans le monde du développement logiciel moderne, assurer la cohérence entre le client et le serveur représente un défi de taille. L'approche Contract First s'est imposée comme une solution efficace, et est maintenant fortement soutenue par la bibliothèque @feelai/contract.

Contract First : La méthode de programmation qui définit le contrat en premier

Contract First est une méthode de développement logiciel où la définition de l'interface de programmation d'application (API) est établie avant l'implémentation détaillée. Au lieu d'écrire le code puis de définir l'API, cette méthode exige :

Définition claire des points d'accès (endpoints), des entrées et des sorties
Création d'un contrat (contract) entre le client et le serveur
Développement parallèle des deux côtés basé sur le contrat défini

Les avantages du Contract First incluent :

Minimisation des erreurs de communication entre les équipes
Permet le développement parallèle du front-end et du back-end
Assure la cohérence des types de données
Facilite les tests et la génération de données factices (mock data)

@feelai/contract : Bibliothèque TypeScript pour le Contract First

@feelai/contract est une bibliothèque npm qui aide à implémenter la méthode Contract First dans les projets TypeScript. Cette bibliothèque fournit des outils pour définir les contrats d'API de manière sûre par typage (type-safe), partageable entre le client et le serveur sans problèmes de dépendance circulaire.

Fonctionnalités clés

Sécurité des types : Utilise typebox pour définir des schémas
Définition centralisée des contrats : Gère les contrats d'API, de flux (Stream) et de socket au même endroit
Inférence de types statique : Extrait les types TypeScript des définitions de contrats à l'exécution
Séparation des préoccupations : Sépare la définition de l'API des détails d'implémentation

Installation

bun add @feelai/contract
# ou
npm install @feelai/contract
# ou
yarn add @feelai/contract

Utilisation pratique

Voici un exemple de définition de contrat pour une application de gestion de tâches :

import { Contract, defineApiMap, defineSocketMap } from "@feelai/contract";
import { Type } from "typebox";

// Définition du schéma
export const TaskSchema = Type.Object({
  id: Type.String(),
  title: Type.String(),
  completed: Type.Boolean(),
  createdAt: Type.Number(),
});

// Définition des points d'accès API
const api = defineApiMap({
  getTasks: {
    output: Type.Array(TaskSchema),
  },
  createTask: {
    input: Type.Object({
      title: Type.String(),
    }),
    output: TaskSchema,
  },
});

// Définition des événements Socket
const socket = defineSocketMap({
  taskUpdates: {
    client: {
      subscribe: Type.Object({}),
    },
    server: {
      taskCreated: TaskSchema,
      taskUpdated: TaskSchema,
    },
  },
});

// Création et export du contrat
export const todoListContract = new Contract().api(api).socket(socket);
export type TodoListContract = typeof todoListContract;

Inférence de types de données

L'une des forces de @feelai/contract est sa capacité d'inférence de types automatique :

import { StaticApiMap, StaticSocketMap } from "@feelai/contract";
import { todoListContract } from "./todoListContract";

// Types pour l'implémentation API
export type ApiTypes = StaticApiMap<typeof todoListContract>;

// Types pour l'implémentation Socket
export type SocketTypes = StaticSocketMap<typeof todoListContract>;

Avantages de l'utilisation de @feelai/contract

Développement parallèle : Les équipes front-end et back-end peuvent travailler indépendamment sur la base du contrat défini
Réduction des erreurs : La vérification des types à la compilation permet de détecter les erreurs précocement
Documentation automatique : Le contrat sert de documentation vivante pour l'API
Maintenance facilitée : Les changements d'API sont gérés de manière centralisée en un seul endroit

Conclusion

L'approche Contract First, combinée à la bibliothèque @feelai/contract, offre une méthode structurée pour le développement d'applications web modernes. Avec sa capacité à garantir la sécurité des types de données de bout en bout, à minimiser les erreurs de communication entre le client et le serveur, et à soutenir le développement parallèle, c'est un outil précieux pour les projets TypeScript de taille moyenne à grande.

Pour en savoir plus sur @feelai/contract, visitez : https://www.npmjs.com/package/@feelai/contract