Aller au contenu
Meubles Morinière

Les choix d’ingénierieÉtudes de cas techniques3 min de lecture

Deux applications nées d’un fork

Le site est parti d’une copie allégée de l’ERP. Je raconte comment on empêche deux copies d’une même règle de calcul de diverger, sans tout réécrire d’un coup.

Le problème

Le site public est parti d’un fork allégé de l’ERP. Il avait la même stack, les mêmes règles d’argent (TVA, remises, port, totaux), les mêmes formulaires et le même schéma. En partant d’une copie, le site a pu ouvrir vite, avec du code qui avait déjà fait ses preuves.

Sauf qu’une copie, ça diverge. Si on corrige une règle de TVA dans l’ERP et qu’on l’oublie dans le site, la facture ne correspond plus au montant encaissé en ligne. Et avec une copie, rien ne signale l’oubli. Les deux applications compilent et passent leurs tests, chacune de son côté.

Les contraintes

  • Sortir tout le code commun d’un coup aurait cassé les tests. Dans chaque application, des centaines de tests mockent un fichier par son chemin (vi.mock("@/shared/lib/…")). Un code déplacé dans un paquet échappe à ces mocks.
  • On ne peut pas compter sur la discipline. Plusieurs sessions retouchent le projet en parallèle, humaines ou non.
  • Les deux applications doivent rester séparées. Le site est ouvert à tout Internet, et l’ERP gère l’argent (ADR 0002).

Les alternatives

  • Tout sortir dans des paquets d’un coup. Les mocks par chemin cassent par centaines, et tant que le chantier dure, on ne peut rien retoucher d’autre.
  • Garder les deux copies et compter sur la relecture. Sauf que rien ne signale l’oubli, et les sessions qui retouchent le code ne se relisent pas entre elles.
  • Réunir les deux applications. La copie disparaît, mais on perd aussi la séparation entre ce qu’une faille du site peut atteindre et ce que l’ERP protège.
  • Sortir le code commun morceau par morceau, et en attendant, empêcher une copie de diverger.

La décision

On sort le code commun dans des paquets, un morceau à la fois. Et en attendant, on ne peut pas pousser une divergence.

L’implémentation

  1. Le code commun part dans packages/* (domain pour les règles, ui pour le kit d’interface, infra pour l’outillage, contracts pour les échanges). Chaque application n’en garde qu’un relais d’une ligne (export * from "@meublesmoriniere/domain/vat";). Ce relais est au chemin que les imports et les mocks visent déjà, donc aucun test ne change. La règle ESLint moriniere/prefer-relay oblige à passer par le relais.
  2. Un contrôle des jumeaux, pnpm check:twins (scripts/check-twins.mjs), compare les deux applications fichier par fichier.
    • Un fichier identique des deux côtés est refusé, sauf s’il est dans la liste de ceux qu’on tolère encore. Cette liste ne peut que diminuer : --write refuse d’y ajouter un fichier.
    • Un fichier qui diffère déjà n’est pas libre non plus. Chaque déclaration de premier niveau qu’on retrouve des deux côtés (fonction, constante, type) doit garder le même texte.
    • Un écart voulu est enregistré avec l’empreinte de son texte dans chaque application. S’il bouge, le contrôle échoue à nouveau.
  3. Parfois le site range un fichier ailleurs. Son tunnel de commande est dans modules/checkout, et il correspond aux paiements de l’ERP. Dans ce cas, une table de correspondance (SITE_RENAMES) associe les deux chemins.

Le contrôle tourne dans le hook pre-push. Du coup, une règle corrigée d’un seul côté ne part pas en prod.

sharedDeclarationDriftsscripts/check-twins.mjs · lignes 168–183
function sharedDeclarationDrifts() {
	return comparedSources()
		.filter((file) => existsSync(siteFile(file)) && !areIdentical(file))
		.flatMap((file) => {
			const erp = topLevelDeclarations(join(ERP, file));
			const site = topLevelDeclarations(siteFile(file));
			return [...erp]
				.filter(([name, text]) => site.has(name) && site.get(name) !== text)
				.map(([name, text]) => ({
					declaration: `${file}#${name}`,
					erp: fingerprint(text),
					site: fingerprint(site.get(name)),
				}));
		})
		.sort((left, right) => left.declaration.localeCompare(right.declaration));
}

Les résultats

Au 12 novembre 2026, il y a 247 relais vers les paquets. Il reste 28 fichiers de code encore copiés et 77 divergences suivies, chacune enregistrée avec son empreinte. Une correction de calcul faite d’un seul côté est refusée au push. Et chaque fichier qui sort dans un paquet retire une entrée de la liste des tolérés.

Les limites

  • Chaque élément partagé a deux noms. Quand on cherche la règle de TVA, on tombe d’abord sur un relais d’une ligne. L’audit de rangement du 12 novembre a relevé que seulement 20 des 247 relais étaient vraiment mockés par un test. Il propose de mocker directement le paquet pour supprimer les relais.
  • Les formulaires sont toujours des jumeaux. Environ 140 fichiers de test mockent le module des toasts, et des formulaires sortis dans un paquet passeraient à côté de ces mocks.
  • Le contrôle compare seulement des fichiers rangés au même chemin, ou associés par la table. Si on recopie un code commun sous un autre nom, il ne le voit pas. La règle est écrite dans le README : un code commun sort dans un paquet.

Sur cette page