10 - Glossaire

Tous les termes utilises dans cette serie, plus quelques concepts proches que tu croiseras dans la litterature. Chaque définition va droit au but avec un exemple TypeScript quand c'est utile.

---

A

Abstract Factory

Un pattern qui créé des familles d'objets lies sans spécifier leurs classes concrètes. Rarement utile en TypeScript backend. Voir l'article Factory.

Adapter

Un wrapper qui traduit l'interface d'un composant externe vers l'interface que ton code attend. Tres frequent en TypeScript pour intégrer des API tierces.

typescriptclass StripeAdapter implements PaymentPort {
  async charge(amount: number): Promise<PaymentResult> {
    const intent = await stripe.paymentIntents.create({ amount: amount * 100 });
    return { id: intent.id, status: intent.status === "succeeded" ? "ok" : "failed" };
  }
}

Voir l'article Adapter.

Anti-pattern

Une solution recurrente qui semble bonne sur le moment mais créé plus de problèmes qu'elle n'en resout. Exemples : God Object, Spaghetti Code, Lava Flow. Voir l'article Anti-patterns.

B

Builder

Un pattern qui construit un objet complexe étape par étape avec des méthodes chainees. Utile quand un constructeur a trop de paramètres optionnels.

typescriptconst email = new EmailBuilder()
  .setFrom("contact@paltemps.fr")
  .setTo("client@example.com")
  .setSubject("Confirmation")
  .build();

Voir l'article Builder.

C

Callback Hell

Des callbacks imbriques sur plusieurs niveaux qui rendent le code illisible. Resolu par async/await en TypeScript moderne. Voir l'article Anti-patterns.

Chain of Responsibility

Un pattern ou une requête passe à travers une chaîne de handlers. Chaque handler décidé de traiter la requête ou de la passer au suivant. Les middlewares Express/Elysia en sont un exemple : chaque middleware peut répondre ou appeler next().

typescriptapp.use(authMiddleware);    // handler 1 : verifie l'auth
app.use(rateLimiter);       // handler 2 : limite le debit
app.use(corsMiddleware);    // handler 3 : gere les CORS

Composition Root

L'endroit dans l'application ou toutes les dépendances sont assemblees. Généralement main.ts ou index.ts. C'est le seul fichier qui connaît les implementations concrètes et fait les new. Voir l'article DI.

Copy-Paste Programming

Un anti-pattern ou le meme code est duplique dans plusieurs fichiers au lieu d'etre extrait dans une fonction ou un module. Regle : extraire à partir de la troisieme copie (Rule of Three).

D

Decorator

Un pattern qui ajoute des comportements a un objet ou une fonction sans modifier son code. En TypeScript, souvent implemente comme une higher-order function.

typescriptconst fetchUser = withLogging(withCache(originalFetchUser));

Voir l'article Decorator.

Dependency Injection (DI)

Passer les dépendances d'un objet par son constructeur au lieu de les créer en interne ou de les importer en global. Rend le code testable et les dépendances explicites.

typescriptclass OrderService {
  constructor(
    private repo: OrderRepository,
    private emailer: EmailSender,
  ) {}
}

Voir l'article DI.

DIP (Dependency Inversion Principle)

Le D de SOLID. Les modules de haut niveau ne dependent pas des modules de bas niveau. Les deux dependent d'abstractions (interfaces). C'est le principe qui sous-tend la DI et l'architecture hexagonale.

E

Event Emitter

L'implementation Node.js/Bun du pattern Observer. Un objet emet des événements nommes, des listeners s'abonnent pour y reagir.

typescriptconst bus = new EventEmitter();
bus.on("order:created", (order) => sendEmail(order));
bus.emit("order:created", newOrder);

Voir l'article Observer.

F

Façade

Un wrapper qui simplifie une interface complexe. Contrairement a l'Adapter, il n'y a pas d'interface cible predéfinie : on expose une API plus simple.

Factory

Un pattern qui centralise la création d'objets. En TypeScript, souvent une simple fonction qui retourne l'instance appropriee selon le contexte.

typescriptfunction createLogger(env: "dev" | "prod"): Logger {
  if (env === "dev") return new ConsoleLogger();
  return new FileLogger("/var/log/app.log");
}

Voir l'article Factory.

G

God Object

Un anti-pattern : une classe qui a trop de responsabilités. Signal d'alerte : 500+ lignes, 30+ méthodes, des imports de partout. Fix : découper par responsabilité (Single Responsibility). Voir l'article Anti-patterns.

H

Higher-Order Function

Une fonction qui prend une fonction en paramètre ou retourne une fonction. Base du pattern Decorator en TypeScript.

typescriptfunction withRetry<T>(fn: () => Promise<T>, attempts: number): () => Promise<T> {
  return async () => { /* retry logic */ };
}

I

Interface Segregation Principle (ISP)

Le I de SOLID. Pas d'interface "fourre-tout" avec 20 méthodes. Prefere plusieurs petites interfaces spécifiques. Un client ne devrait pas dépendre de méthodes qu'il n'utilise pas.

L

Lava Flow

Un anti-pattern : du code mort qu'on garde par peur de casser quelque chose. Des fichiers *-old.ts, des fonctions commentees, des branches if (false). Fix : supprimer, git conserve l'historique. Voir l'article Anti-patterns.

Liskov Substitution Principle (LSP)

Le L de SOLID. Si B hérité de A, alors B doit pouvoir remplacer A sans casser le programme. En pratique : si ton InMemoryOrderRepository se comporte differemment de PgOrderRepository sur les memes inputs, tu violes LSP.

M

Middleware

Un handler qui s'intercale entre la requête et la réponse dans un framework web. C'est le pattern Chain of Responsibility en action, et souvent aussi un Decorator applique aux routes.

O

Observer

Un pattern ou un objet (le subject) notifie automatiquement ses abonnes (observers) quand son état change. En Node.js/Bun, l'EventEmitter est l'implementation standard. Voir l'article Observer.

Open/Closed Principle (OCP)

Le O de SOLID. Un module est ouvert a l'extension, ferme a la modification. En pratique : tu ajoutes un nouveau Strategy sans modifier le code existant, tu ajoutes un nouvel Adapter sans toucher aux autres.

P

Premature Abstraction

Un anti-pattern : créer des interfaces, des classes abstraites et des génériques avant d'avoir un deuxieme cas d'usage. Resiste a l'envie d'abstraire, attends la duplication. Voir l'article Anti-patterns.

R

Repository

Un pattern qui abstrait l'acces aux donnees derrière une interface qui ressemble a une collection. Le code métier manipule repo.findById(id) sans savoir si c'est PostgreSQL, un fichier JSON ou une Map en mémoire.

typescriptinterface OrderRepository {
  save(order: Order): Promise<void>;
  findById(id: string): Promise<Order | null>;
}

Voir l'article Repository.

S

Service Locator

Un registre global qui fournit des dépendances a la demande. C'est un Singleton de Singletons. A éviter : les dépendances sont complètement cachees. Prefere la DI. Voir l'article DI.

Singleton

Un pattern qui garantit une seule instance d'une classe. En TypeScript, un simple export de module fait le travail. Problèmes : dépendance cachee, tests difficiles, état global mutable. Voir l'article DI.

SOLID

Cinq principes de conception orientes objet par Robert C. Martin :

• S - Single Responsibility : une classe, une raison de changer
• O - Open/Closed : ouvert a l'extension, ferme a la modification
• L - Liskov Substitution : les sous-types remplacent les types parents
• I - Interface Segregation : des interfaces petites et spécifiques
• D - Dependency Inversion : dépendre d'abstractions, pas de concretions

Ce ne sont pas des lois absolues. Ce sont des heuristiques. Les appliquer a 100% sur un projet de 500 lignes, c'est du sur-engineering. Les ignorer sur un projet de 50 000 lignes, c'est du suicide technique.

Spaghetti Code

Un anti-pattern : pas de structure, pas de couches, tout appelle tout. Le controller fait du SQL, le service formate du HTML, le repository envoie des mails. Fix : couches separees. Voir l'article Anti-patterns.

Strategy

Un pattern qui encapsule des algorithmes interchangeables derrière une interface commune. En TypeScript, souvent un simple type de fonction.

typescripttype PricingStrategy = (items: CartItem[]) => number;

Voir l'article Strategy.

T

Template Method

Un pattern ou une classe abstraite definit le squelette d'un algorithme, les sous-classes implementent certaines étapes. En TypeScript, on préféré généralement la composition (passer des fonctions) a l'héritage.

typescript// Plutot que Template Method avec heritage :
function processOrder(
  validate: (data: OrderData) => boolean,
  calculateTotal: (items: CartItem[]) => number,
  notify: (order: Order) => Promise<void>,
) { /* ... */ }

---

Tous ces concepts sont utilises dans des projets réels, y compris sur paltemps.fr. Si un terme te manque, les series sur l'architecture hexagonale et le DDD completent ce glossaire.

---

Article précédent : 09 - Anti-patterns

Sources

• Refactoring Guru - Design Patterns
• Source Making - Design Patterns
• Martin Fowler - Patterns of Enterprise Application Architecture
• Robert C. Martin - Clean Architecture