Cours Svelte et SvelteKit · Module 14: Hooks, API et déploiement

La garde de Heimdall - Hooks

2 min de lecture ·
Dans cette leçon4

Bienvenue à l'avant-poste de Heimdall ! Il garde le Bifrost et voit tout. Les hooks dans SvelteKit sont les gardiens de ton application - ils voient chaque requête !

hooks.server.js

// src/hooks.server.js

export async function handle({ event, resolve }) {
  // Avant de traiter la requête
  console.log('Request:', event.url.pathname);

  // Ajouter des données à locals
  const session = await getSession(event.cookies.get('session'));
  event.locals.user = session?.user;

  // Traiter la requête
  const response = await resolve(event);

  // Après le traitement
  console.log('Response status:', response.status);

  return response;
}

Middleware d'authentification

// hooks.server.js
import { redirect } from '@sveltejs/kit';

export async function handle({ event, resolve }) {
  const session = event.cookies.get('session');

  if (session) {
    const user = await getUserFromSession(session);
    event.locals.user = user;
  }

  // Protéger les routes
  if (event.url.pathname.startsWith('/dashboard') && !event.locals.user) {
    redirect(303, '/login');
  }

  return resolve(event);
}

Comme dans les fonctions load, redirect() dans le hook handle lève l'exception elle-même, et SvelteKit la transforme en réponse de redirection.

Plusieurs gardiens : sequence

Quand un hook fait beaucoup de choses, découpe-le en petites fonctions et relie-les avec l'utilitaire sequence. Elles s'exécutent l'une après l'autre, comme les postes de garde sur le pont Bifrost :

// hooks.server.js
import { sequence } from '@sveltejs/kit/hooks';

async function auth({ event, resolve }) {
  event.locals.user = await getUserFromSession(event.cookies.get('session'));
  return resolve(event);
}

async function logger({ event, resolve }) {
  console.log('Requête :', event.url.pathname);
  return resolve(event);
}

export const handle = sequence(auth, logger);

handleError

// hooks.server.js
export function handleError({ kind, error, event }) {
  // kind : 'app', 'framework', 'validation' ou 'unknown'
  if (kind !== 'unknown') {
    return error; // les erreurs de error() passent sans changement
  }

  console.error('Error:', error);

  // Envoyer à Sentry, LogRocket, etc.
  Sentry.captureException(error);

  return {
    message: 'Une erreur est survenue'
  };
}

Dans SvelteKit 3, handleError reçoit toutes les erreurs, et le champ kind indique leur origine. Tu journalises les erreurs inattendues (unknown) et tu les transformes en message sûr, pour que l'utilisateur ne voie jamais les détails du serveur.

Heimdall voit tout - tes hooks aussi !

Code de cette leçon : App.svelte
<script>
  // Garde de Heimdall - Hooks
  // hooks.server.js - gardien de chaque requête

  let requests = $state([]);
  let isAuthenticated = $state(false);
  let user = $state(null);
  let nextId = 1;

  // Simulation du hook handle
  function simulateRequest(path) {
    const timestamp = new Date().toLocaleTimeString();
    const log = {
      id: nextId++,
      time: timestamp,
      path,
      user: isAuthenticated ? user?.name : 'anonyme'
    };

    requests = [log, ...requests].slice(0, 5);

    // Simulation d’une route protégée
    if (path.startsWith('/dashboard') && !isAuthenticated) {
      return { redirect: '/login', status: 303 };
    }

    return { ok: true };
  }

  function login() {
    isAuthenticated = true;
    user = { name: 'Ragnar', role: 'jarl' };
  }

  function logout() {
    isAuthenticated = false;
    user = null;
  }
</script>

<main class="heimdall">
  <h1>Garde de Heimdall - Hooks</h1>
  <p class="subtitle">hooks.server.js - voit chaque requête</p>

  <section class="code">
    <h2>hooks.server.js</h2>
    <pre>
import {"{"} redirect {"}"} from '@sveltejs/kit';

export async function handle({"{"} event, resolve {"}"}) {"{"}
  // 1. Avant le traitement
  console.log('Requête :', event.url.pathname);

  // 2. Ajouter des données à locals
  const session = event.cookies.get('session');
  event.locals.user = await getUser(session);

  // 3. Protéger les routes
  if (event.url.pathname.startsWith('/dashboard')) {"{"}
    if (!event.locals.user) {"{"}
      redirect(303, '/login');
    {"}"}
  {"}"}

  // 4. Traiter la requête
  const response = await resolve(event);

  // 5. Après le traitement
  console.log('Statut :', response.status);

  return response;
{"}"}
    </pre>
  </section>

  <section class="auth">
    <h2>Statut de l’utilisateur</h2>
    {#if isAuthenticated}
      <p>Connecté en tant que : <strong>{user.name}</strong></p>
      <button onclick={logout}>Se déconnecter</button>
    {:else}
      <p>Non connecté</p>
      <button onclick={login}>Se connecter en tant que Ragnar</button>
    {/if}
  </section>

  <section class="test">
    <h2>Tester les routes</h2>
    <div class="paths">
      <button onclick={() => simulateRequest('/')}>/ (Accueil)</button>
      <button onclick={() => simulateRequest('/warriors')}>/warriors</button>
      <button onclick={() => simulateRequest('/dashboard')}>/dashboard</button>
    </div>
  </section>

  <section class="logs">
    <h2>Journal des requêtes</h2>
    {#each requests as req (req.id)}
      <div class="log">
        <span class="time">{req.time}</span>
        <span class="path">{req.path}</span>
        <span class="user">{req.user}</span>
      </div>
    {:else}
      <p class="empty">Aucune requête</p>
    {/each}
  </section>
</main>

<style>
  .heimdall {
    font-family: 'Georgia', serif;
    max-width: 600px;
    margin: 0 auto;
    padding: 2rem;
    background: linear-gradient(135deg, #0a1628 0%, #1a2d4e 100%);
    color: #b8d4f7;
    min-height: 100vh;
  }

  h1 {
    color: #ffd700;
    text-align: center;
  }

  .subtitle {
    text-align: center;
    color: #6a8ab9;
  }

  section {
    background: rgba(74, 144, 217, 0.1);
    border: 1px solid #4a90d9;
    border-radius: 8px;
    padding: 1rem;
    margin: 1rem 0;
  }

  h2 {
    color: #4a90d9;
    font-size: 1rem;
    margin-top: 0;
  }

  pre {
    background: rgba(0,0,0,0.5);
    padding: 1rem;
    border-radius: 4px;
    font-size: 0.75rem;
    overflow-x: auto;
  }

  strong {
    color: #ffd700;
  }

  button {
    padding: 0.5rem 1rem;
    background: #1e3a5f;
    color: #b8d4f7;
    border: 1px solid #4a90d9;
    border-radius: 4px;
    cursor: pointer;
    margin-right: 0.5rem;
  }

  .paths {
    display: flex;
    flex-wrap: wrap;
    gap: 0.5rem;
  }

  .log {
    display: flex;
    gap: 1rem;
    padding: 0.5rem;
    background: rgba(0,0,0,0.3);
    border-radius: 4px;
    margin-bottom: 0.25rem;
    font-size: 0.9rem;
  }

  .time {
    color: #6a8ab9;
    font-family: monospace;
  }

  .path {
    color: #ffd700;
    flex: 1;
  }

  .user {
    color: #90ee90;
  }

  .empty {
    color: #6a8ab9;
    font-style: italic;
  }
</style>

Entrées de la documentation utilisées dans cette leçon

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Dans quel fichier définit-on les server hooks ?

  2. 2. Que fait la fonction handle() dans hooks.server.js ?

  1. QuestionLe fichier des hooks serveur
  2. QuestionLa fonction handle()

Articles utiles