Referencia de la API de enrutamiento Fetch

Añadido en: astro@7.0.0 Nuevo

El módulo astro/fetch proporciona handlers de enrutamiento avanzado construidos sobre la Fetch API estándar.

Importaciones desde astro/fetch

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

FetchState

El objeto de estado por solicitud. Crea uno al inicio de tu método fetch:

import { FetchState } from 'astro/fetch';

const state = new FetchState(request);

FetchState rastrea la ruta coincidente, las cookies, los proveedores de sesiones y otros datos por solicitud. Todas las funciones handler lo requieren como su primer argumento.

Aprende cómo componer handlers con FetchState en la guía de enrutamiento avanzado.

Propiedades

state.request

Type: Request

El objeto Request entrante.

state.url

Type: URL

Una URL normalizada derivada de la solicitud.

state.pathname

Type: string

El pathname decodificado y sin base de la solicitud (ej. /about o /blog/my-post).

state.routeData

Type: RouteData | undefined

La ruta coincidente para esta solicitud, si la hay. Esto se resuelve automáticamente cuando se crea el FetchState.

state.cookies

Type: AstroCookies

Una instancia de AstroCookies para leer y establecer cookies en esta solicitud.

state.locals

Type: App.Locals

Un objeto de ámbito de solicitud para almacenar datos personalizados. Este es el mismo objeto locals disponible en middleware y API routes.

state.params

Type: Params | undefined

Parámetros de ruta derivados de la ruta coincidente y el pathname (ej. { slug: 'my-post' } para una ruta [slug].astro).

state.status

Type: number
Default: 200

El código de estado HTTP para la respuesta. Puedes establecerlo antes de renderizar para controlar el estado de la respuesta (ej. state.status = 404).

state.response

Type: Response | undefined
Default: undefined

El Response producido por los handlers después de que se completa el renderizado. Esto es establecido automáticamente por pages() y middleware(), permitiéndote inspeccionar o usar la respuesta más adelante en el pipeline:

const response = await middleware(state, (s) => pages(s));
// state.response is now the same object as response

Métodos

state.rewrite()

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

Dispara un rewrite a una ruta diferente. El payload puede ser un string de pathname ('/other-page'), una URL, o un Request:

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

astro()

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

El handler todo-en-uno que ejecuta el pipeline completo de Astro (sesiones, caché, redirecciones, trailing-slash, actions, middleware, páginas e i18n) en el orden por defecto. Usa esto cuando quieras añadir lógica antes o después de Astro sin cambiar el orden interno del pipeline:

src/fetch.ts

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

export default {
  async fetch(request: Request): Promise<Response> {
    const state = new FetchState(request);
    // custom pre-processing here...
    const response = await astro(state);
    // custom post-processing here...
    return response;
  },
};

actions()

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

Maneja Astro Actions (RPC y envíos de formularios). Devuelve una Response para actions de RPC, o undefined para actions de formularios y solicitudes que no son actions. Verifica el valor devuelto para decidir si continuar renderizando:

const actionResponse = await actions(state);
if (actionResponse) return actionResponse;
// otherwise continue to page rendering...

cache()

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

Envuelve un callback de renderizado con lógica de proveedor de caché. Maneja caché en runtime, proveedores basados en CDN, y el caso sin caché.

i18n()

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

Post-procesa una respuesta contra tu configuración i18n. Maneja redirecciones de locale, 404s para locales inválidos, y enrutamiento de fallback. Llama esto después de renderizar:

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

middleware()

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

Ejecuta la cadena de middleware de Astro (desde src/middleware.ts). El callback next se llama al final de la cadena para producir la respuesta, típicamente llamando a pages():

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

pages()

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

Despacha la solicitud a la ruta de Astro coincidente (página, endpoint, o fallback). Este es el handler de renderizado principal, y la mayoría de los pipelines personalizados lo incluirán.

redirects()

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

Maneja rutas de redirección definidas en tu configuración de Astro. Devuelve una Response de redirección si la ruta coincidente es una redirección, o undefined si el llamador debe continuar procesando.

sessions()

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

Registra el proveedor de session. Las sesiones se crean de forma diferida cuando tu código accede a ctx.session y se persisten automáticamente al final de la solicitud. Llama esto al inicio del pipeline (antes de que se ejecute el middleware):

await sessions(state);
// ...render pipeline...

trailingSlash()

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

Verifica si el pathname de la solicitud necesita normalización de trailing-slash y devuelve una Response de redirección si es así. Devuelve undefined cuando no se necesita redirección.