Aller au contenu
Me contacter

Ouvert à un CDI · Métropole lilloise

Tous les articles
Mis à jour le 6 min de lecture

Refonte de l’e-commerce Cora avec Next.js et le SSR

Pour Cora, groupe belge de la grande distribution, nous avons réalisé la refonte du front-end de la boutique en ligne en Next.js, sur une API existante, avec un rendu côté serveur par magasin, deux langues et des parcours alignés sur les applications mobiles. Je m’y suis principalement occupé de l’espace client.

  • Next.js
  • SSR
  • Performance
  • E-commerce

Cora est un groupe belge de la grande distribution. Chez Ikomobi, nous avons réalisé la refonte du front-end de sa boutique en ligne en Next.js, en conservant l’API existante. L’équipe réunissait un lead dev, deux développeurs fullstack et un intégrateur, avec un chef de projet et un designer. J’ai principalement pris en charge l’espace client, tout en intervenant sur les problématiques communes du front-end. C’est sur ces sujets transverses, notamment les performances et la gestion des données côté serveur, que se sont joués les principaux arbitrages du projet.

D’où partait le projet ?

Le site web précédent datait de plusieurs années, mais Cora disposait déjà d’applications iOS et Android, développées par les équipes mobiles d’Ikomobi. Elles servaient de référence, et le web devait reprendre leurs parcours et leurs règles métier, des formulaires au tunnel d’achat.

Le front n’avait pas sa propre couche de données métier et s’appuyait sur une API existante, maintenue par un prestataire externe. Nous devions donc composer avec sa structure et ses temps de réponse, sans pouvoir la modifier lorsqu’un problème apparaissait côté web.

S’y ajoutaient sept magasins aux configurations différentes (click & collect, livraison, services), à servir en français comme en néerlandais.

Pourquoi du SSR plutôt que des pages statiques ?

Sur ce site, presque tout dépend du magasin choisi par le client, qu’il s’agisse de l’accès à l’e-shop, de l’offre, des services ou d’une partie des contenus éditoriaux. Ce choix, mémorisé dans un cookie, est relu à chaque requête. Une page catalogue ou une fiche produit existe donc en autant de versions qu’il y a de magasins.

Prégénérer ces pages aurait impliqué de gérer une version par magasin et par langue, puis de les régénérer à chaque évolution des données. Nous avons donc retenu le rendu côté serveur à chaque requête, avec l’App Router de Next.js 14. La page arrive complète, construite pour le magasin du client, sans effet « sapin de Noël » (des blocs qui apparaissent un à un) ni squelettes de chargement. Elle reste aussi indexable, avec un sitemap dynamique et des redirections permanentes depuis les anciennes URL.

Les contenus éditoriaux proviennent d’un CMS headless, Prismic, qui dispose d’un espace principal et d’un espace par magasin. Chaque magasin gère ainsi ses propres contenus dans le CMS.

Comment travailler avec une API qu’on ne peut pas modifier ?

La gestion du token de session a été l’un des premiers problèmes concrets rencontrés côté front. L’API exigeait un token à chaque appel, et celui d’un client connecté pouvait expirer. Si plusieurs appels partaient simultanément avec un token expiré, il fallait éviter de lancer plusieurs renouvellements en parallèle, puis rejouer les appels concernés avec le nouveau token. En voici le principe, réécrit de façon générique :

// Simplified example
// Per user session: calls that fail on an expired token wait for a single
// refresh, then replay. The pending refresh is never shared between users.
async function withFreshToken(session, request) {
  try {
    return await request(session.token);
  } catch (error) {
    if (error.status !== 401) throw error;
    session.refreshing ??= refreshToken(session).finally(() => (session.refreshing = null));
    await session.refreshing;
    return request(session.token);
  }
}

L’autre problème tenait aux temps de chargement. Certaines pages, ainsi que le layout commun, attendaient environ 4 secondes la fin de leurs appels à l’API. Faute de pouvoir toucher à l’API, nous avons cherché de la marge côté front, et trois changements ont ramené ces temps d’appels sous la seconde :

  • lancer en parallèle les appels indépendants, jusque-là enchaînés ;
  • charger les données une seule fois au niveau du layout et les transmettre en props aux composants qui en ont besoin, au lieu que chacun refasse son propre appel ;
  • conserver en cookie ou en session les informations stables, comme le magasin choisi ou la session, pour ne plus les redemander à chaque page.

Le deuxième point tient à un détail de la stack. Au cours d’un même rendu, Next.js n’exécute qu’une fois les requêtes fetch identiques, même si plusieurs composants les lancent. Les appels à l’API passaient cependant par axios, que cette déduplication ne couvre pas. Charger les données une fois au layout évitait donc les appels en double. La fonction cache() de React donne le même résultat sans faire descendre les données de composant en composant, puisque chaque composant peut alors appeler la fonction lui-même :

// Simplified example: independent calls in parallel, memoized for the request
import { cache } from 'react'

export const getStores = cache(() => api.get('/stores').then((res) => res.data))
export const getNavigation = cache(() => api.get('/navigation').then((res) => res.data))

// app/layout.js: both calls start at once, and any component calling
// getStores() during the same request reuses the result
const [stores, navigation] = await Promise.all([getStores(), getNavigation()])

Un cache des réponses de l’API, déjà utilisé côté applications mobiles, a aussi été étudié pour le web. Il n’a pas été retenu, le gain attendu côté site ayant été jugé insuffisant.

Comment construire une inscription en plusieurs étapes ?

C’est sur l’espace client que j’ai passé la majeure partie de mon temps, de l’authentification au profil et au foyer, en passant par la carte de fidélité et sa cagnotte, les réductions, la gestion des magasins, les commandes, les factures et l’exercice des droits RGPD. Ces écrans étaient pour l’essentiel des formulaires, validés avec Formik et Yup, avec reCAPTCHA pour limiter les soumissions automatisées. Pour la recherche de magasins et d’adresses, j’ai également géré les clés des services Google Maps sur Google Cloud Platform.

Le parcours le plus complexe était l’inscription, en cinq étapes (identifiants, carte de fidélité, coordonnées, centres d’intérêt, magasin). Les champs demandés dans les coordonnées dépendent du choix fait pour la carte, qu’on crée une carte virtuelle, qu’on associe une carte existante ou qu’on s’en passe. Un seul formulaire Formik conserve toutes les valeurs, et le schéma de validation change avec l’étape :

// Simplified example: one Formik form, one Yup schema per step
const schemas = [credentialsSchema, loyaltyCardSchema, contactSchema, hobbiesSchema, storeSchema]
const stepFields = [['email', 'password', 'terms'], ['cardChoice'], /* ... */]

const formik = useFormik({
  initialValues,
  validationSchema: schemas[currentStep], // only the current step is validated
  onSubmit: register, // submitted from the last step
})

async function goToNextStep() {
  const errors = await formik.validateForm()
  if (Object.keys(errors).length > 0) {
    // Show the errors on the current step's fields only
    formik.setTouched(Object.fromEntries(stepFields[currentStep].map((field) => [field, true])))
    return
  }
  setCurrentStep((step) => step + 1)
}

Deux détails comptent à l’usage. Les erreurs ne s’affichent que sur les champs de l’étape en cours, pour ne pas accueillir l’utilisateur avec des messages sur des champs qu’il n’a pas encore vus. Et certaines vérifications passent par le serveur entre deux étapes, comme une adresse e-mail déjà utilisée ou un numéro de carte de fidélité, avant de laisser l’utilisateur avancer.

Comment garder le web cohérent avec les applications mobiles ?

Pour éviter de réinventer les parcours, nous nous sommes appuyés sur les applications mobiles existantes et sur les échanges avec les équipes qui les maintenaient. Le web reprenait leurs parcours, ensuite maquettés par les designers. À l’inverse, certaines pages du site s’affichent directement dans les applications, en webview, avec une session propre à l’application, et le CMS propose des blocs de contenu réservés aux applications.

L’équipe produit pilotait les décisions UX, notamment les expérimentations A/B menées sur certaines pages comme le catalogue ou les promotions. Notre rôle côté développement était de traduire ces choix dans le front-end, tout en préservant les temps de chargement.