Pourquoi parler d’injection de dépendances côté frontend ?
L’injection de dépendances est souvent associée aux frameworks backend, aux conteneurs IoC ou aux architectures d’entreprise. Pourtant, le problème qu’elle résout existe aussi dans les applications web : trop de code frontend dépend directement de détails techniques.
Un composant appelle directement fetch. Une fonction métier lit directement localStorage. Un service importe directement un client analytics. Au début, cela semble simple. Puis les tests deviennent pénibles, les migrations plus risquées, et chaque changement technique se propage dans l’interface.
L’injection de dépendances consiste à fournir à un module ce dont il a besoin, plutôt que de le laisser le créer ou l’importer directement. En TypeScript, cette approche est particulièrement intéressante, car les interfaces et types permettent de décrire précisément les contrats attendus.
Ce sujet complète naturellement des approches comme le Result pattern en TypeScript, les machines à états en TypeScript ou le typage des données API en TypeScript. Toutes cherchent à rendre le code plus explicite et moins fragile.
Le problème : une fonction trop couplée
Prenons une fonction qui charge un profil utilisateur et le stocke localement :
export async function loadUserProfile(userId: string) {
const response = await fetch(`/api/users/${userId}`);
if (!response.ok) {
throw new Error("Impossible de charger le profil");
}
const user = await response.json();
localStorage.setItem("lastUserId", user.id);
return user;
}
Cette fonction mélange plusieurs responsabilités : construire une requête HTTP, interpréter une réponse, écrire dans le stockage navigateur et exposer une donnée exploitable. Elle dépend directement de fetch et de localStorage, ce qui complique les tests.
Pour tester cette fonction, il faudra simuler des API globales. Pour changer le stockage, il faudra modifier la fonction. Pour appeler une API différente, même problème.
Ce n’est pas catastrophique sur quelques lignes. Mais à l’échelle d’une application, cette forme de couplage devient coûteuse.
Décrire les dépendances avec des contrats
La première étape consiste à nommer les dépendances techniques :
type User = {
id: string;
name: string;
email: string;
};
type UserRepository = {
findById(userId: string): Promise<User>;
};
type UserPreferencesStorage = {
saveLastUserId(userId: string): void;
};
Ces types ne disent rien de fetch, localStorage, IndexedDB, SQL ou d’un SDK externe. Ils décrivent seulement ce que la logique métier attend.
On peut maintenant écrire une fonction qui dépend de contrats :
type LoadUserProfileDependencies = {
users: UserRepository;
preferences: UserPreferencesStorage;
};
export async function loadUserProfile(
userId: string,
dependencies: LoadUserProfileDependencies
): Promise<User> {
const user = await dependencies.users.findById(userId);
dependencies.preferences.saveLastUserId(user.id);
return user;
}
La fonction est maintenant beaucoup plus facile à comprendre : elle charge un utilisateur, puis mémorise son identifiant. Elle ne sait pas comment ces opérations sont réalisées. C’est précisément l’objectif.
Créer des implémentations concrètes
Les détails techniques existent toujours, mais ils sont déplacés dans des adaptateurs :
export function createHttpUserRepository(baseUrl: string): UserRepository {
return {
async findById(userId) {
const response = await fetch(`${baseUrl}/users/${userId}`);
if (!response.ok) {
throw new Error("Impossible de charger le profil utilisateur");
}
return response.json() as Promise<User>;
}
};
}
export function createLocalUserPreferencesStorage(): UserPreferencesStorage {
return {
saveLastUserId(userId) {
localStorage.setItem("lastUserId", userId);
}
};
}
Ce code reste simple, mais il est isolé. Si vous remplacez localStorage par IndexedDB, seule l’implémentation du stockage change. Si votre API évolue, le repository est l’endroit naturel où adapter la réponse.
Cette séparation devient encore plus utile quand vous combinez données distantes, cache applicatif et annulation de requêtes, comme dans les articles sur le cache frontend stale-while-revalidate et AbortController en JavaScript.
Composer les dépendances au bord de l’application
Un principe important : injecter les dépendances ne signifie pas les passer manuellement partout au hasard. Il faut choisir un point de composition, souvent proche de l’entrée de l’application.
const dependencies = {
users: createHttpUserRepository("/api"),
preferences: createLocalUserPreferencesStorage()
};
const user = await loadUserProfile("42", dependencies);
Dans une application plus grande, ce point de composition peut être un fichier dependencies.ts, un provider React, une injection Vue, ou le contexte d’un routeur.
L’objectif n’est pas de créer une abstraction pour chaque ligne de code. L’objectif est de placer les détails techniques aux frontières du système.
Exemple avec React
Dans React, on peut exposer les dépendances via un contexte :
import { createContext, useContext } from "react";
type AppDependencies = {
users: UserRepository;
preferences: UserPreferencesStorage;
};
const DependenciesContext = createContext<AppDependencies | null>(null);
export function DependenciesProvider({
dependencies,
children
}: {
dependencies: AppDependencies;
children: React.ReactNode;
}) {
return (
<DependenciesContext.Provider value={dependencies}>
{children}
</DependenciesContext.Provider>
);
}
export function useDependencies() {
const dependencies = useContext(DependenciesContext);
if (!dependencies) {
throw new Error("DependenciesProvider est manquant");
}
return dependencies;
}
Un composant peut alors consommer les dépendances sans importer directement les adaptateurs :
function UserButton({ userId }: { userId: string }) {
const dependencies = useDependencies();
async function handleClick() {
const user = await loadUserProfile(userId, dependencies);
console.log(user.name);
}
return <button onClick={handleClick}>Charger le profil</button>;
}
Le composant reste responsable de l’interaction utilisateur. La fonction métier reste responsable du cas d’usage. Les adaptateurs restent responsables des détails techniques.
Exemple avec Vue
Vue propose aussi un mécanisme naturel avec provide et inject :
import type { InjectionKey } from "vue";
export type AppDependencies = {
users: UserRepository;
preferences: UserPreferencesStorage;
};
export const dependenciesKey: InjectionKey<AppDependencies> = Symbol("dependencies");
Dans le point d’entrée :
import { createApp } from "vue";
import App from "./App.vue";
const app = createApp(App);
app.provide(dependenciesKey, {
users: createHttpUserRepository("/api"),
preferences: createLocalUserPreferencesStorage()
});
app.mount("#app");
Puis dans un composant :
<script setup lang="ts">
import { inject } from "vue";
import { dependenciesKey } from "./dependencies";
const dependencies = inject(dependenciesKey);
if (!dependencies) {
throw new Error("Dépendances manquantes");
}
async function load() {
const user = await dependencies.users.findById("42");
console.log(user.name);
}
</script>
<template>
<button @click="load">Charger</button>
</template>
L’approche est différente syntaxiquement, mais l’idée reste la même : éviter que les composants importent directement les détails d’infrastructure.
Tester sans simuler tout le navigateur
L’un des bénéfices les plus immédiats apparaît dans les tests. Il devient possible de fournir de fausses dépendances très simples :
import { describe, expect, it, vi } from "vitest";
it("charge un utilisateur et mémorise son identifiant", async () => {
const saveLastUserId = vi.fn();
const user = await loadUserProfile("42", {
users: {
async findById() {
return {
id: "42",
name: "Ada Lovelace",
email: "ada@example.com"
};
}
},
preferences: {
saveLastUserId
}
});
expect(user.name).toBe("Ada Lovelace");
expect(saveLastUserId).toHaveBeenCalledWith("42");
});
Le test ne dépend ni du réseau, ni du stockage navigateur, ni d’un environnement complexe. Il vérifie le comportement du cas d’usage.
Cette approche s’accorde bien avec des tests end-to-end comme Playwright : les tests unitaires valident la logique isolée, tandis que les tests end-to-end vérifient les parcours complets.
Quand éviter l’injection de dépendances ?
Comme toute technique d’architecture, l’injection de dépendances peut être exagérée. Il n’est pas nécessaire de créer une interface pour chaque fonction utilitaire pure.
Une fonction comme celle-ci n’a pas besoin d’injection :
export function formatUserName(firstName: string, lastName: string) {
return `${firstName.trim()} ${lastName.trim()}`;
}
Elle ne dépend d’aucun système externe, ne lit aucun état global et ne produit aucun effet de bord. L’injection devient intéressante lorsqu’un module dépend d’un détail remplaçable : réseau, stockage, date courante, génération d’identifiant, analytics, logs, permissions, environnement d’exécution.
Une bonne règle pratique : si une dépendance rend le test difficile, rend une migration risquée ou force un module métier à connaître un détail technique, elle mérite probablement d’être injectée.
Attention aux abstractions trop vagues
Le piège classique consiste à créer des interfaces génériques qui ne disent rien du métier :
type ApiClient = {
get(path: string): Promise<unknown>;
post(path: string, body: unknown): Promise<unknown>;
};
Ce type est parfois utile, mais il ne protège pas beaucoup votre code métier. Un contrat comme UserRepository est souvent plus parlant, car il exprime une intention métier : trouver un utilisateur, sauvegarder une préférence, vérifier une permission.
L’injection de dépendances ne doit pas seulement déplacer le couplage. Elle doit clarifier les frontières.
Une architecture plus calme à faire évoluer
L’injection de dépendances en TypeScript n’oblige pas à utiliser un framework spécialisé. Dans beaucoup d’applications frontend, de simples objets, fonctions de fabrique et types explicites suffisent.
Commencez par les zones qui posent réellement problème : appels API, stockage local, logique de date, analytics, clients SDK. Extrayez un contrat, créez une implémentation concrète, puis injectez-la au niveau du cas d’usage ou du contexte applicatif.
Vous obtiendrez un code moins dépendant des détails techniques, plus facile à tester, et surtout plus lisible dans le temps. C’est souvent la différence entre une base de code qui accumule les contournements et une architecture qui reste capable d’évoluer sans se fissurer à chaque changement.