yatta/next

The request headers a server render should forward.

A Server Component fetching on the server has to pass the caller's cookie on, or the API sees an anonymous request and returns 401 — which looks like a permissions bug rather than a missing header.

The per-request cache.

Deliberately module-level and set by a provider per request. A module-level *value* that survives between requests would leak one user's data into the next response, so it must be replaced on every request and never outlive one.

Reads a request body as text, for a platform that streams it.

Next.js has already consumed the stream by the time a route handler runs in some configurations, so `request.text()` can throw. Returns `undefined` rather than throwing, because an unreadable body on a route that takes no body is not an error worth failing the request over.

Clears the request cache, taking the cache it was given.

Server-side data fetching for React Server Components.

Reads from the request cache instead of issuing a second request, which is the whole point: a Server Component and a client component below it should see one fetch, not two. Needs a `YattaProvider` above it in the server tree. If there is none, this fetches directly rather than throwing, so a component that is server-rendered on its own still works — it just does not share.

1// app/users/[id]/page.tsx2export default async function Page({ params }) {3  const user = await serverQuery(["getUser", params.id], () =>4    api.getUser({ params: { id: params.id } }),5  );6  return <Profile user={user} />;7}

Builds a `NextRequest`-shaped argument from the standard `Request`.

Next.js passes a `NextRequest`, which is a superset of `Request`. This exists so a handler can read the same headers either way without checking the type.

Builds every HTTP method from one route table.

Next.js route handlers are exported per verb, so a table has to become seven named exports. Written out by hand that is seven chances to pass a different route table to one of them.

1// app/api/[[...path]]/route.ts2import { toNextRoute } from "yatta/next";3import { routes } from "@/api-contract";4import { handlers } from "@/api-handlers";5 6export const { GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS } =7  toNextRoute(routes, { handlers });

Scopes a cache to one request.

Call this at the top of a server tree, in a layout or middleware. Pass `undefined` afterwards — leaving a cache in place after the request has been served is how two users see each other's data.

1// app/layout.tsx2export default function RootLayout({ children }) {3  const cache = withRequestCache();4  try {5    return <>{children}</>;6  } finally {7    releaseRequestCache(cache);8  }9}

Aliases: these names read better from an adapter's point of view.