Aller au contenu

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.

GuideDéveloppeur
Durée
30 min
Voir en Markdown

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.

Chargement du schéma…

Avant de commencer

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 :

    server.tsTypeScript
    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.

Conseil

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 :

src/useSession.tsTSX
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"),
  };
}
src/App.tsxTSX
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