Referencia de la API de enrutamiento de búsquedas

Agregado en: astro@7.0.0

El módulo astro/fetch ofrece controladores de enrutamiento avanzado basados en la API estándar de búsqueda.

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 registra la ruta coincidente, las cookies, los proveedores de sesión y otros datos específicos de cada solicitud. Todas las funciones de gestión lo requieren como primer argumento.

Aprenda a componer controladores con FetchState en la guía de enrutamiento avanzado.

Propiedades

state.request

Tipo: Request

El objeto Request entrante.

state.url

Tipo: URL

Una URL normalizada derivada de la solicitud.

state.pathname

Tipo: string

La ruta de la solicitud sin la base y descodificada (p. ej., /sobre-mí o /blog/mi-artículo).

state.routeData

Tipo: RouteData | undefined

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

state.cookies

Tipo: AstroCookies

Una instancia de AstroCookies (EN) para leer y configurar cookies en esta solicitud.

state.locals

Tipo: App.Locals

Un objeto con ámbito de solicitud para almacenar datos personalizados. Se trata del mismo objeto locals (EN) disponible en middleware (EN) y en rutas de la API (EN).

state.params

Tipo: Params | undefined

Parámetros de ruta derivados de la ruta y el nombre de ruta coincidentes (p. ej., { slug: 'mi-artículo' } para una ruta [slug].astro).

state.status

Tipo: number
Por defecto: 200

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

state.response

Tipo: Response | undefined
Por defecto: undefined

La Response generada por los controladores una vez finalizada la representación. Se establece automáticamente mediante pages() y middleware(), lo que te permite inspeccionar o utilizar la respuesta más adelante en el proceso:

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

Métodos

state.rewrite()

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

Activa una reescritura a una ruta diferente. El payload puede ser una cadena de ruta ('/otra-página'), una URL o un objeto Request:

const response = await state.rewrite('/otra-página');

astro()

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

El controlador todo en uno que ejecuta todo el proceso de Astro (sesiones, caché, redireccionamientos, barra final, acciones, middleware, páginas e i18n) en el orden predeterminado. Úsalo cuando quieras para añadir lógica antes o después de Astro sin modificar el orden interno del proceso:

src/fetch.ts

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

export default {
  async fetch(request: Request): Promise<Response> {
    const state = new FetchState(request);
    // preprocesamiento personalizado aquí...
    const response = await astro(state);
    // posprocesamiento personalizado aquí...
    return response;
  }
};

actions()

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

Gestiona las acciones Astro (RPC y envíos de formularios). Devuelve un Response para las acciones RPC, o undefined para las acciones de formularios y las solicitudes que no sean de acción. Comprueba el valor devuelto para decidir si continuar con la renderización:

const actionResponse = await actions(state);
if (actionResponse) return actionResponse;
// de lo contrario, continuar con la renderización de la página...

cache()

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

Envuelve una llamada de retorno de renderizado con la lógica del proveedor de cache (EN). Gestiona el almacenamiento en caché en tiempo de ejecución, los proveedores basados en CDN y el caso en el que no se utiliza caché.

i18n()

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

Procesa posteriormente una respuesta según tu configuración de internacionalización (EN). Gestiona las redirecciones de configuración regional, los errores 404 para configuraciones regionales no válidas y el enrutamiento fallback. Llama a esta función después de la renderización:

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). La función de llamada next se invoca al final de la cadena para generar la respuesta, normalmente llamando a pages():

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

pages()

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

Envía la solicitud a la ruta Astro correspondiente (página, punto final o fallback) . Este es el controlador de renderizado principal, y la mayoría de los flujos de trabajo personalizados lo incluirán.

redirects()

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

Gestiona las rutas de redirección definidas en tu configuración de Astro (EN). Devuelve una Response de redirección si la ruta coincidente es una redirección, o undefined si la función que la invoca debe continuar con el procesamiento.

sessions()

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

Registra el proveedor de una sesión. Las sesiones se crean de forma diferida cuando tu código accede a ctx.session y se guardan automáticamente al final de la solicitud. Llama a esta función al principio del proceso (antes de que se ejecute el middleware):

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

trailingSlash()

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

Comprueba si la ruta de la solicitud necesita normalización con barra final (EN) y, en caso afirmativo, devuelve una Respuesta de redireccionamiento. Devuelve undefined cuando no es necesario ningún redireccionamiento.