Référence de l'API de routage Fetch

Ajouté à la version : astro@7.0.0 Nouveau

Le module astro/fetch fournit des gestionnaires de routage avancé construits sur l’API Fetch standard.

Importations depuis astro/fetch

import {
  FetchState,
  astro,
  actions,
  cache,
  i18n,
  middleware,
  pages,
  redirects,
  sessions,
  trailingSlash,
} from "astro/fetch";

FetchState

L’objet d’état propre à la requête. Créez-en un au début de votre méthode fetch :

import { FetchState } from 'astro/fetch';

const state = new FetchState(request);

FetchState assure le suivi de la route correspondante, des cookies, des fournisseurs de session et d’autres données propres à chaque requête. Toutes les fonctions de gestion exigent cet objet comme premier argument.

Découvrez comment composer des gestionnaires avec FetchState dans le guide de routage avancé.

Propriétés

state.request

Type : Request

L’objet Request entrant.

state.url

Type : URL

Une URL normalisée dérivée de la requête.

state.pathname

Type : string

Le chemin de la requête, décodé et sans le préfixe de base (par exemple /a-propos ou /blog/mon-article).

state.routeData

Type : RouteData | undefined

La route correspondante pour cette requête, le cas échéant. Elle est résolue automatiquement lorsque FetchState est créé.

state.cookies

Type : AstroCookies

Une instance AstroCookies pour lire et définir des cookies sur cette requête.

state.locals

Type : App.Locals

Un objet spécifique à la requête pour stocker des données personnalisées. Il s’agit du même objet locals disponible dans les middlewares et les routes d’API.

state.params

Type : Params | undefined

Les paramètres de route dérivés de la route correspondante et du chemin d’accès (par exemple { slug: 'mon-article' } pour une route [slug].astro).

state.status

Type : number
Par défaut : 200

Le code de statut HTTP pour la réponse. Vous pouvez le définir avant le rendu pour contrôler le statut de la réponse (par exemple state.status = 404).

state.response

Type : Response | undefined
Par défaut : undefined

La réponse (Response) produite par les gestionnaires après la fin du rendu. Elle est définie automatiquement par pages() et middleware(), vous permettant d’inspecter ou d’utiliser la réponse plus tard dans le pipeline :

const response = await middleware(state, (s) => pages(s));
// `state.response` est maintenant le même objet que `response`

Méthodes

state.rewrite()

Type : (payload: RewritePayload) => Promise<Response>

Déclenche une réécriture vers une autre route. Le payload peut être une chaîne de caractères correspondant au chemin ('/autre-page'), une URL ou un objet Request :

const response = await state.rewrite('/autre-page');

astro()

Type : (state: FetchState) => Promise<Response>

Le gestionnaire tout-en-un qui exécute l’ensemble du pipeline d’Astro (sessions, cache, redirections, trailing-slash, actions, middleware, pages et internationalisation) dans l’ordre par défaut. Utilisez-le lorsque vous souhaitez ajouter une logique avant ou après Astro sans modifier l’ordre interne du pipeline :

src/fetch.ts

import { FetchState, astro } from 'astro/fetch';

export default {
  async fetch(request: Request): Promise<Response> {
    const state = new FetchState(request);
    // prétraitement personnalisé ici...
    const response = await astro(state);
    // post-traitement personnalisé ici...
    return response;
  },
};

actions()

Type : (state: FetchState) => Promise<Response | undefined> | undefined

Gère les actions d’Astro (RPC et soumissions de formulaires). Renvoie un objet Response pour les actions RPC, ou undefined pour les actions de formulaire et les requêtes ne constituant pas une action. Vérifiez la valeur de retour pour décider s’il faut poursuivre le rendu :

const actionResponse = await actions(state);
if (actionResponse) return actionResponse;
// sinon, poursuivre le rendu de la page...

cache()

Type : (state: FetchState, next: () => Promise<Response>) => Promise<Response>

Enveloppe une fonction de rappel de rendu avec la logique d’un fournisseur de cache. Gère la mise en cache à l’exécution, les fournisseurs reposant sur un CDN et le cas sans cache.

i18n()

Type : (state: FetchState, response: Response) => Promise<Response>

Post-traite une réponse en fonction de votre configuration i18n. Gère les redirections de paramètres régionaux, les erreurs 404 pour les paramètres régionaux invalides et le routage de repli. Appelez-la après le rendu :

const response = await middleware(state, (s) => pages(s));
return i18n(state, response);

middleware()

Type : (state: FetchState, next: (state: FetchState) => Promise<Response>) => Promise<Response>

Exécute la chaîne de middleware d’Astro (à partir de src/middleware.ts). La fonction de rappel next est appelée en bas de la chaîne pour produire la réponse, généralement en appelant pages() :

const response = await middleware(state, (s) => pages(s));

pages()

Type : (state: FetchState) => Promise<Response>

Transmet la requête à la route Astro correspondante (page, point de terminaison ou solution de repli). Il s’agit du gestionnaire de rendu principal, et la plupart des pipelines personnalisés l’incluront.

redirects()

Type : (state: FetchState) => Promise<Response> | undefined

Gère les routes de redirection définies dans votre configuration d’Astro. Renvoie un objet Response de redirection si la route correspondante est une redirection, ou undefined si l’appelant doit poursuivre le traitement.

sessions()

Type : (state: FetchState) => Promise<void> | void

Enregistre le fournisseur de session. Les sessions sont créées de manière différée lorsque votre code accède à ctx.session et sont automatiquement conservées à la fin de la requête. Appelez cette fonction tôt dans le pipeline (avant l’exécution du middleware) :

await sessions(state);
// ...pipeline de rendu...

trailingSlash()

Type : (state: FetchState) => Response | undefined

Vérifie si le chemin de la requête nécessite une normalisation de la barre oblique finale et renvoie un objet Response de redirection le cas échéant. Renvoie undefined lorsqu’aucune redirection n’est nécessaire.