Next.js

Next.js : où placer use client et la frontière serveur ?

Othmane Ibn Dahou Idrissi ·

Schéma : les données privées alimentent une page serveur, qui transmet les données utiles à une interaction client.

Un bouton qui ouvre un panneau a besoin de JavaScript dans le navigateur. Le titre, le prix public et la description qui entourent ce bouton n’en ont pas nécessairement besoin. Dans une application Next.js, la bonne question est donc rarement « toute cette page doit-elle être côté client ? ». Il faut identifier la plus petite partie de l’interface qui possède une interaction, puis choisir les données qui franchissent cette frontière.

Ce guide utilise l’App Router de Next.js 16 et React 19. Le cas étudié est un catalogue fictif : une fiche présente un produit et un bouton permet de l’ajouter à une sélection locale. Il sert à expliquer une décision d’architecture, sans prétendre représenter une mission client ni un gain de performance mesuré.

Ce que signifie réellement « use client »

La directive "use client", placée en tête d’un module, définit une entrée dans le graphe de modules client. Les modules qu’il importe peuvent alors rejoindre le JavaScript du navigateur. Elle ne signifie pas que le composant sera systématiquement absent du HTML initial : Next.js peut produire son HTML sur le serveur, puis React l’hydrate. La documentation Next.js sur cette frontière décrit cette distinction.

Un composant serveur convient à la lecture des données et à la composition d’une page. Un composant client convient à un état interactif, un gestionnaire de clic ou une API du navigateur. La présence d’une animation ne justifie pas, à elle seule, de déplacer tous les accès aux données dans le navigateur. On peut isoler l’animation dans une enveloppe interactive.

Deux décisions restent indépendantes : où s’exécute une partie du code, et pendant combien de temps ses données sont réutilisées. Transformer un composant en Server Component ne définit pas automatiquement la fraîcheur d’un catalogue. Pour cette deuxième question, il faut une politique de cache explicite.

Dessiner la frontière avant de modifier les fichiers

Pour notre fiche produit, on peut commencer par une liste de responsabilités. Le serveur connaît la source de données, choisit les champs publics et décide si le produit existe. Le navigateur gère le bouton et son retour visuel. Le prix commercial affiché peut être transmis, mais un prix d’achat interne ou un jeton d’API n’a aucune raison de traverser la frontière.

Source de données privée
          |
          v
Page serveur : lecture + sélection des champs
          |
          +-- Titre et description
          |
          +-- Bouton client : identifiant public + interaction

Cette représentation permet de repérer une erreur fréquente : passer tout l’objet de base de données au composant client « pour plus tard ». Même si certaines propriétés ne sont pas affichées, leur transmission peut déjà les exposer. Un type TypeScript ne supprime pas les propriétés à l’exécution ; il faut construire explicitement l’objet public.

Le même raisonnement s’applique à un tableau de bord. Le serveur vérifie le droit de lire un dossier ; le composant client reçoit seulement les informations nécessaires à l’action proposée. Masquer une colonne dans le CSS n’est jamais une règle d’autorisation.

Un exemple minimal avec une interaction isolée

Le premier fichier est une page serveur, sans directive client. Les données sont volontairement statiques pour rendre l’exemple exécutable sans ajouter une base ou inventer une API. Dans une application réelle, la lecture serait remplacée par une fonction serveur validant ses entrées et les droits nécessaires.

// app/catalogue/page.tsx
import SelectionButton from './selection-button';

export default function CataloguePage() {
  const product = {
    id: 'support-ecran',
    name: 'Support pour écran',
    description: 'Un exemple de produit public.',
  };

  return (
    <main>
      <h1>{product.name}</h1>
      <p>{product.description}</p>
      <SelectionButton productId={product.id} />
    </main>
  );
}

Le second fichier porte l’interaction. Il n’importe ni le client de base de données ni le service qui connaît des secrets. Son identifiant est public et son état ne prétend pas enregistrer une commande.

// app/catalogue/selection-button.tsx
'use client';

import { useState } from 'react';

export default function SelectionButton({
  productId,
}: { productId: string }) {
  const [selected, setSelected] = useState(false);

  return (
    <button
      type="button"
      data-product-id={productId}
      aria-pressed={selected}
      onClick={() => setSelected(value => !value)}
    >
      {selected ? 'Retirer de la sélection' : 'Sélectionner'}
    </button>
  );
}

L’intérêt n’est pas le nombre de lignes. La dépendance est lisible : le bouton dépend d’un contrat réduit. On peut changer la provenance du produit sans modifier son comportement. Pour organiser plusieurs fonctionnalités de ce type, le guide sur l’architecture React par fonctionnalités prolonge cette séparation.

Composition : un panneau client peut entourer du contenu serveur

Un piège consiste à importer directement un module serveur depuis un fichier client. Une autre composition est possible : le parent serveur construit le contenu et le transmet au panneau interactif via children. Le panneau contrôle son ouverture ; le contenu reste composé par le parent serveur.

Ce mécanisme ne transforme pas les données rendues en informations privées. Tout ce qui doit arriver au navigateur doit être considéré comme observable. Il permet surtout de conserver une frontière de modules claire et de limiter les dépendances nécessaires à l’interaction.

Avant d’introduire un provider global, vérifiez aussi la portée réelle de son état. Si une préférence concerne uniquement une grille, placer son provider autour du site entier agrandit inutilement la zone concernée. Un état partagé n’est utile que lorsqu’il existe effectivement plusieurs consommateurs qui doivent rester synchronisés.

Les erreurs à rechercher en revue de code

La première est la directive client ajoutée au layout principal pour résoudre une erreur de hook située dans un petit composant. Cette correction fait disparaître le symptôme mais déplace la frontière beaucoup plus haut que nécessaire. Extraire le composant interactif offre généralement un meilleur point de départ.

La deuxième est une lecture de window ou localStorage pendant le rendu initial. Le fichier est client, mais son premier rendu peut encore participer au HTML serveur. Il faut organiser une valeur initiale stable puis une lecture côté navigateur au bon moment. Le diagnostic des erreurs d’hydratation détaille cette méthode.

La troisième est une fonction de chargement universelle qui mélange requête privée, stockage navigateur et formatage visuel. Le nom utils ne rend pas ce mélange sûr. Un module consacré à l’accès serveur, marqué import 'server-only', aide à détecter les imports incompatibles pendant le développement. Il ne remplace ni l’autorisation ni le contrôle des données renvoyées.

Comment vérifier que la séparation est utile

Commencez par une construction de production : le comportement de développement et les outils de diagnostic ajoutent du travail qui ne représente pas le site livré. Inspectez ensuite les requêtes réseau et les modules client. Cherchez surtout les dépendances lourdes arrivées avec un bouton, un formulaire ou un simple formatage.

Vérifiez le parcours sans interaction : le titre, la description et les liens doivent être présents dans le document attendu. Activez ensuite JavaScript et testez le clavier, le changement d’état, la navigation et le retour arrière. Une page qui s’affiche vite mais dont les contrôles ne fonctionnent pas n’a pas atteint son objectif.

Conservez une trace avant et après : route testée, version du build, appareil, dépendances déplacées et résultat observé. N’annoncez pas de réduction du JavaScript sans mesure comparable. Une bibliothèque déjà chargée par une autre partie du site peut rendre le gain moins spectaculaire que prévu.

Questions fréquentes

Faut-il convertir tous les composants existants en composants serveur ?

Non. Commencez par une route coûteuse ou difficile à maintenir. Repérez ses dépendances et réduisez progressivement la frontière client. Une réécriture globale ajoute du risque sans garantir de bénéfice pour l’utilisateur.

Un composant serveur peut-il déclencher une écriture ?

Une interaction peut appeler une Server Action ou une route serveur, avec validation et autorisation. La séparation serveur/client ne constitue pas une protection automatique de cette écriture. La mutation doit vérifier elle-même ce que l’utilisateur a le droit de faire.

Cette architecture améliore-t-elle forcément le référencement ?

Elle peut faciliter la livraison du contenu, mais elle ne corrige pas une mauvaise canonical, un contenu pauvre ou une page bloquée. Le référencement dépend du document finalement accessible et de son utilité. Mes domaines d’expertise situent ces choix techniques dans une approche plus large du développement web.

Next.jsReactServer ComponentsArchitecture frontend