# Intégrer la connexion dans une SPA

> Connecter les utilisateurs d'une application React, Vue ou Angular en confiant Discovery, l'échange du code et les jetons à un petit serveur.

Une SPA ne peut pas appeler Discovery ni l'API publique depuis le navigateur : ces services n'acceptent pas les appels d'origine croisée d'une wakapp. Le modèle recommandé est donc celui d'un serveur compagnon, servi sur le même nom d'hôte que la SPA, qui porte la connexion et relaie les appels à l'API. Le navigateur ne voit jamais un jeton.

```mermaid
flowchart LR
  B["SPA dans le navigateur"] -- "/login, /api/session, /api/wakastart/*<br/>cookie HttpOnly" --> S["Serveur compagnon<br/>même nom d'hôte"]
  S -- "start-login" --> D["Discovery"]
  S -- "échange, rafraîchissement" --> K["Keycloak"]
  S -- "Bearer jeton Keycloak" --> A["API publique"]
```

## Avant de commencer

- Le nom d'hôte de la SPA est un hôte IAM de l'environnement visé (voir [Déclarer les hôtes IAM et les redirect URIs](/v1.0/authentification/declarer-les-hotes-et-redirect-uris)).
- La SPA et son serveur sont servis sur ce même nom d'hôte : la SPA en fichiers statiques, le serveur sous `/login`, `/logout` et `/api/*`. Sur Wakastart, un seul service Frontend peut servir les deux.
- Vous avez lu [Intégrer la connexion dans une application serveur](/v1.0/authentification/integrer-la-connexion-application-serveur) : ce guide en réutilise le fichier `auth.ts`.

## Ajouter les routes du serveur compagnon

1. Reprenez `auth.ts` du guide serveur : il fournit `/login` et `/api/auth/callback`.
2. Dans `server.ts`, servez la SPA et ajoutez une route qui indique au navigateur si une session existe :

   ```ts title="server.ts"
   import express from "express";
   import session from "express-session";
   import path from "node:path";
   import { auth } from "./auth";

   const app = express();
   app.set("trust proxy", 1);
   app.use(
     session({
       secret: process.env.SESSION_SECRET!,
       resave: false,
       saveUninitialized: false,
       cookie: { httpOnly: true, secure: true, sameSite: "lax" },
     }),
   );
   app.use(auth);

   // La SPA demande si l'utilisateur est connecté, sans jamais recevoir de jeton.
   app.get("/api/session", (req, res) => {
     res.json({ authenticated: Boolean(req.session.accessToken) });
   });

   // Relais vers l'API publique : le serveur ajoute le jeton de la session.
   app.use("/api/wakastart", express.json(), async (req, res) => {
     if (!req.session.accessToken) return res.status(401).json({ error: "not_authenticated" });
     const upstream = await fetch(`https://api.wakastart.app/api${req.url}`, {
       method: req.method,
       headers: {
         Authorization: `Bearer ${req.session.accessToken}`,
         "Content-Type": "application/json",
       },
       body: ["GET", "HEAD"].includes(req.method) ? undefined : JSON.stringify(req.body),
     });
     res.status(upstream.status).type("json").send(await upstream.text());
   });

   app.use(express.static(path.join(__dirname, "dist")));
   app.get(/.*/, (_req, res) => res.sendFile(path.join(__dirname, "dist", "index.html")));

   app.listen(Number(process.env.PORT ?? 3000));
   ```

   Résultat : `/api/wakastart/me` renvoie le contexte de l'utilisateur connecté, et les mêmes chemins que l'API publique sont disponibles sous `/api/wakastart`.

:::tip
Limitez le relais aux chemins dont votre SPA a besoin (par exemple `/me` et `/invitations`) plutôt que de tout transmettre.
:::

## Brancher la SPA

Dans la SPA, lancez la connexion par une navigation complète vers `/login` et lisez le contexte par le relais. Exemple avec React :

```tsx title="src/useSession.ts"
import { useEffect, useState } from "react";

export interface Me {
  wid: string;
  email: string;
  firstName?: string;
  lastName?: string;
  customer: { wid: string; name: string };
  profile: { wid: string; name: string; rights?: { code: string; name: string }[] };
}

export function useSession() {
  const [me, setMe] = useState<Me | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch("/api/wakastart/me", { credentials: "same-origin" })
      .then((res) => (res.ok ? res.json() : null))
      .then(setMe)
      .finally(() => setLoading(false));
  }, []);

  return {
    me,
    loading,
    can: (code: string) => Boolean(me?.profile.rights?.some((r) => r.code === code)),
    login: () => window.location.assign("/login"),
    logout: () => window.location.assign("/logout"),
  };
}
```

```tsx title="src/App.tsx"
import { useSession } from "./useSession";

export function App() {
  const { me, loading, can, login, logout } = useSession();
  if (loading) return <p>Chargement…</p>;
  if (!me) return <button onClick={login}>Se connecter</button>;
  return (
    <main>
      <p>Bonjour {me.firstName}, {me.customer.name}</p>
      {can("dossiers.update") && <button>Modifier le dossier</button>}
      <button onClick={logout}>Se déconnecter</button>
    </main>
  );
}
```

Utilisez les droits côté SPA pour l'affichage seulement : votre serveur et l'API publique restent les seuls à décider.

## Vérifier le résultat

1. Ouvrez `https://mon-app.exemple.fr`. Le bouton **Se connecter** s'affiche.
2. Cliquez dessus et connectez-vous avec le compte de test.

Résultat attendu : la SPA affiche le prénom de l'utilisateur et le nom de son client. Dans les outils de développement du navigateur, aucun jeton n'apparaît dans le stockage local ; seul le cookie de session `HttpOnly` est présent.

## Voir aussi

- [Déconnecter un utilisateur](/v1.0/authentification/deconnecter-un-utilisateur) : la route `/logout`.
- [Rafraîchir la session](/v1.0/authentification/rafraichir-la-session) : renouveler le jeton avant chaque relais.
- [Charger le contexte utilisateur](/v1.0/authentification/charger-le-contexte-utilisateur).
