createLocalServerFetch

createLocalServerFetch(options) crea una ServerFetch: una función (request, context) => Promise<Response> que atiende una petición a /api o /_meeko/rpc con el pipeline de la aplicación, dentro del proceso, reutilizando la sesión, los servicios, el estado y el requestId de la petición en curso. Es lo que hay debajo de api.* y rpc.* mientras el servidor renderiza una página: la página llama a su propia API sin red y sin una segunda sesión.

Como reutiliza la sesión de context, sólo acepta peticiones de su mismo origen y con sus mismas credenciales: cualquier otra responde 403. Así nadie puede usarla para hablar con la API en nombre de otro usuario.

Uso#

import { pathToFileURL } from "node:url";
import { createLocalServerFetch } from "@meekojs/meeko/server";

const serverFetch = createLocalServerFetch({ manifest, sessions, load: (file) => import(pathToFileURL(file).href) });
// Mismo origen y mismas credenciales que la petición original.
const request = new Request(new URL("/api/users", context.request.url), { headers: context.request.headers });
const response = await serverFetch(request, context);

Tipo#

function createLocalServerFetch<S>(
  options: Pick<ServerDispatcherOptions<S>, "manifest" | "sessions" | "load" | "onError">,
): ServerFetch

type ServerFetch = (request: Request, context: RequestContext) => Promise<Response>

Parámetros#

createLocalServerFetch(options):

Valor devuelto#

Una ServerFetch: (request: Request, context: RequestContext) => Promise<Response>.

Ejemplos#

Medir las llamadas internas de un render#

import type { ServerFetch } from "@meekojs/meeko/server";

export const logged = (inner: ServerFetch): ServerFetch => async (request, context) => {
  const start = performance.now();
  const response = await inner(request, context);
  console.log(context.requestId, request.method, new URL(request.url).pathname, response.status, `${Math.round(performance.now() - start)} ms`);
  return response;
};

Un cliente tipado de servidor a nivel de módulo#

import { createApiClient } from "@meekojs/meeko/framework";
import { createServerClientOptions } from "@meekojs/meeko/server";

// Cada llamada lee la URL, las credenciales y el despacho local de la petición en curso:
// el cliente nunca retiene las credenciales de otro usuario.
export const api = createApiClient<ApiContract>(manifest, createServerClientOptions());

Así son los clientes api y rpc generados para el SSR. Fuera de una petición de Meeko, cada llamada lanza un error.

Errores comunes#

Reenviar otra cookie#

const request = new Request(new URL("/api/admin/users", context.request.url), { headers: { cookie: adminCookie } });
await serverFetch(request, context);

Responde 403 {"code":"INVALID_CREDENTIALS"}: el despacho local comparte la sesión de context y no puede cambiarla. Para actuar como otro usuario, haga una petición HTTP real.

const request = new Request(new URL("/api/admin/users", context.request.url), { headers: context.request.headers });
await serverFetch(request, context);

Llamar a otro host#

await serverFetch(new Request("https://api.otro.example/users", { headers: context.request.headers }), context);

Responde 403 {"code":"INVALID_ORIGIN"}. Para un servicio externo, use fetch con context.signal.

await fetch("https://api.otro.example/users", { signal: context.signal });

Notas#

• Seguridad. La comparación de origen y credenciales evita que el despacho local se use como proxy con la sesión de otro.
• requestId. La llamada comparte el de la petición original: los logs y onError agrupan el render y sus llamadas.
• Origin. Los clientes api.* y rpc.* del SSR envían el origen de la petición en curso, así que la comprobación de Origin de las mutaciones (por defecto desde 1.8) funciona también en local.

Relacionado#

• createLocalCallsLlama a la API y al RPC de la aplicación dentro del proceso, con las credenciales de la petición en curso y las mismas guardas, validaciones y límites que por HTTP.
• createServerDispatcherCrea un handler HTTP que atiende /api/... y /_meeko/rpc/... de un host propio, con las mismas sesiones, guardas, validaciones y errores que la aplicación.
• createServerClientOptionsOpciones de cliente para el servidor: leen la URL, las cookies, authorization, el token CSRF y el despacho local de la petición en curso en cada llamada, así que un cliente creado a nivel de módulo nunca retiene credenciales de otro usuario.
• apiCliente generado de los endpoints de server/api, tipado por sus schemas, que funciona igual en el navegador y en el servidor.
• API y RPCMeeko como framework full-stack