UNPKG

16.3 kBJavaScriptView Raw
1/**
2 * react-router v8.5.2
3 *
4 * Copyright (c) Remix Software Inc.
5 *
6 * This source code is licensed under the MIT license found in the
7 * LICENSE.md file in the root directory of this source tree.
8 *
9 * @license MIT
10 */
11import { ErrorResponseImpl, RouterContextProvider, createDataFunctionUrl, defaultMapRouteProperties, getRoutePattern, isRouteErrorResponse, removeTrailingSlash, stripBasename } from "../router/utils.js";
12import { instrumentHandler, instrumentationResultMetaContext } from "../router/instrumentation.js";
13import { createStaticHandler, getStaticContextFromError, isMutationMethod, isRedirectResponse, isResponse } from "../router/router.js";
14import { getManifestPath, isFogOfWarEnabled, shouldUseInitialRouteDiscovery } from "../dom/ssr/fog-of-war.js";
15import { createEntryRouteModules } from "./entry.js";
16import { isServerMode } from "./mode.js";
17import { sanitizeErrors, serializeError } from "./errors.js";
18import { matchServerRoutes } from "./routeMatching.js";
19import { getBuildTimeHeader, getDevServerHooks } from "./dev.js";
20import { createStaticHandlerDataRoutes } from "./routes.js";
21import { createServerHandoffString } from "./serverHandoff.js";
22import { getDocumentHeaders } from "./headers.js";
23import { throwIfPotentialCSRFAttack } from "../actions.js";
24import { getNormalizedPath } from "./urls.js";
25import { SERVER_NO_BODY_STATUS_CODES, encodeViaTurboStream, generateSingleFetchRedirectResponse, singleFetchAction, singleFetchLoaders } from "./single-fetch.js";
26//#region lib/server-runtime/server.ts
27function derive(build, mode) {
28 let dataRoutes = createStaticHandlerDataRoutes(build.routes);
29 let serverMode = isServerMode(mode) ? mode : "production";
30 let staticHandler = createStaticHandler(dataRoutes, {
31 basename: build.basename,
32 mapRouteProperties: defaultMapRouteProperties,
33 instrumentations: build.entry.module.instrumentations,
34 future: build.future
35 });
36 let errorHandler = build.entry.module.handleError || ((error, { request }) => {
37 if (serverMode !== "test" && !request.signal.aborted) console.error(isRouteErrorResponse(error) && error.error ? error.error : error);
38 });
39 let requestHandlerInstrumentations = build.entry.module.instrumentations?.map((i) => i.handler).filter(Boolean);
40 let requestHandler = async (request, initialContext) => {
41 let params = {};
42 let loadContext;
43 let handleError = (error) => {
44 if (mode === "development") getDevServerHooks()?.processRequestError?.(error);
45 errorHandler(error, {
46 context: loadContext,
47 params,
48 request
49 });
50 };
51 if (initialContext && !(initialContext instanceof RouterContextProvider)) {
52 let error = /* @__PURE__ */ new Error("Invalid `context` value provided to `handleRequest`. You must return an instance of `RouterContextProvider` from your `getLoadContext` function.");
53 handleError(error);
54 return returnLastResortErrorResponse(error, serverMode);
55 }
56 loadContext = initialContext || new RouterContextProvider();
57 let requestUrl = new URL(request.url);
58 let normalizedPath = getNormalizedPath(request);
59 let normalizedPathname = normalizedPath.pathname;
60 let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
61 if (!build.ssr || build.unstable_apiOnly) {
62 let decodedPath = normalizedPathname;
63 try {
64 decodedPath = decodeURI(normalizedPathname);
65 } catch {}
66 if (build.basename && build.basename !== "/") {
67 let strippedPath = stripBasename(decodedPath, build.basename);
68 if (strippedPath == null) {
69 errorHandler(new ErrorResponseImpl(404, "Not Found", `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${build.basename}\``), {
70 context: loadContext,
71 params,
72 request
73 });
74 return new Response("Not Found", {
75 status: 404,
76 statusText: "Not Found"
77 });
78 }
79 decodedPath = strippedPath;
80 }
81 if (build.prerender.length === 0) isSpaMode = true;
82 else if (!build.prerender.some((p) => removeTrailingSlash(p) === removeTrailingSlash(decodedPath))) if (requestUrl.pathname.endsWith(".data") && !build.unstable_apiOnly) {
83 errorHandler(new ErrorResponseImpl(404, "Not Found", `Refusing to SSR the path \`${decodedPath}\` because \`ssr:false\` is set and the path is not included in the \`prerender\` config, so in production the path will be a 404.`), {
84 context: loadContext,
85 params,
86 request
87 });
88 return new Response("Not Found", {
89 status: 404,
90 statusText: "Not Found"
91 });
92 } else isSpaMode = true;
93 }
94 let manifestUrl = getManifestPath(build.routeDiscovery.manifestPath, build.basename);
95 if (build.routeDiscovery.mode === "lazy" && requestUrl.pathname === manifestUrl) try {
96 return await handleManifestRequest(build, staticHandler, requestUrl);
97 } catch (e) {
98 handleError(e);
99 return new Response("Unknown Server Error", { status: 500 });
100 }
101 if (build.unstable_apiOnly && serverMode !== "development" && !requestUrl.pathname.endsWith(".data") && getBuildTimeHeader(request, "X-React-Router-SPA-Mode") !== "yes" && getBuildTimeHeader(request, "X-React-Router-Prerender") !== "yes") return new Response(null, {
102 status: 404,
103 statusText: "Not Found"
104 });
105 let matches = matchServerRoutes(build.routes, staticHandler, normalizedPathname);
106 if (matches && matches.length > 0) Object.assign(params, matches[0].params);
107 if (requestHandlerInstrumentations?.length) loadContext.set(instrumentationResultMetaContext, {
108 url: createDataFunctionUrl(request, normalizedPath),
109 pattern: matches ? getRoutePattern(matches) : "",
110 params: matches?.[0]?.params ? { ...matches[0].params } : {}
111 });
112 let response;
113 if (requestUrl.pathname.endsWith(".data")) {
114 response = await handleSingleFetchRequest(serverMode, build, staticHandler, request, loadContext, handleError);
115 if (isRedirectResponse(response)) response = generateSingleFetchRedirectResponse(response, request, build, serverMode);
116 if (build.entry.module.handleDataRequest) {
117 response = await build.entry.module.handleDataRequest(response, {
118 context: loadContext,
119 params: matches ? matches[0].params : {},
120 request
121 });
122 if (isRedirectResponse(response)) response = generateSingleFetchRedirectResponse(response, request, build, serverMode);
123 }
124 } else if (!isSpaMode && matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) response = await handleResourceRequest(serverMode, build, staticHandler, matches.slice(-1)[0].route.id, request, loadContext, handleError);
125 else {
126 let { pathname } = requestUrl;
127 let criticalCss = void 0;
128 if (build.unstable_getCriticalCss) criticalCss = await build.unstable_getCriticalCss({ pathname });
129 else if (mode === "development" && getDevServerHooks()?.getCriticalCss) criticalCss = await getDevServerHooks()?.getCriticalCss?.(pathname);
130 response = await handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss);
131 }
132 if (request.method === "HEAD") {
133 response.body?.cancel().catch(() => {});
134 return new Response(null, {
135 headers: response.headers,
136 status: response.status,
137 statusText: response.statusText
138 });
139 }
140 return response;
141 };
142 if (requestHandlerInstrumentations?.length) requestHandler = instrumentHandler(requestHandler, requestHandlerInstrumentations);
143 return {
144 serverMode,
145 staticHandler,
146 errorHandler,
147 requestHandler
148 };
149}
150/**
151* Creates a request handler for a React Router server build.
152*
153* This is a low-level API used by server adapters to translate incoming
154* requests into React Router responses.
155*
156* @category Utils
157* @param build The server build, or a function that resolves to the server
158* build, used to handle requests.
159* @param mode The mode in which the server build is running.
160* @returns A request handler that returns a response for each incoming request.
161*/
162const createRequestHandler = (build, mode) => {
163 let _build;
164 let serverMode;
165 let staticHandler;
166 let errorHandler;
167 let _requestHandler;
168 return async function requestHandler(request, initialContext) {
169 _build = typeof build === "function" ? await build() : build;
170 if (typeof build === "function") {
171 let derived = derive(_build, mode);
172 serverMode = derived.serverMode;
173 staticHandler = derived.staticHandler;
174 errorHandler = derived.errorHandler;
175 _requestHandler = derived.requestHandler;
176 } else if (!serverMode || !staticHandler || !errorHandler || !_requestHandler) {
177 let derived = derive(_build, mode);
178 serverMode = derived.serverMode;
179 staticHandler = derived.staticHandler;
180 errorHandler = derived.errorHandler;
181 _requestHandler = derived.requestHandler;
182 }
183 return _requestHandler(request, initialContext);
184 };
185};
186async function handleManifestRequest(build, staticHandler, url) {
187 if (url.toString().length > 7680) return new Response(null, {
188 statusText: "Bad Request",
189 status: 400
190 });
191 if (build.assets.version !== url.searchParams.get("version")) return new Response(null, {
192 status: 204,
193 headers: { "X-Remix-Reload-Document": "true" }
194 });
195 let patches = {};
196 if (url.searchParams.has("paths")) {
197 let pathParam = url.searchParams.get("paths") || "";
198 let paths = new Set(pathParam.split(",").filter(Boolean));
199 for (let path of paths) {
200 if (!path.startsWith("/")) path = `/${path}`;
201 let matches = matchServerRoutes(build.routes, staticHandler, path);
202 if (matches) for (let match of matches) {
203 let routeId = match.route.id;
204 let route = build.assets.routes[routeId];
205 if (route) patches[routeId] = route;
206 }
207 }
208 return Response.json(patches, { headers: { "Cache-Control": "public, max-age=31536000, immutable" } });
209 }
210 return new Response("Invalid Request", { status: 400 });
211}
212async function handleSingleFetchRequest(serverMode, build, staticHandler, request, loadContext, handleError) {
213 return isMutationMethod(request.method) ? await singleFetchAction(build, serverMode, staticHandler, request, loadContext, handleError) : await singleFetchLoaders(build, serverMode, staticHandler, request, loadContext, handleError);
214}
215async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
216 try {
217 if (isMutationMethod(request.method)) try {
218 throwIfPotentialCSRFAttack(request, Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []);
219 } catch (e) {
220 handleError(e);
221 return new Response("Bad Request", { status: 400 });
222 }
223 let result = await staticHandler.query(request, {
224 requestContext: loadContext,
225 generateMiddlewareResponse: async (query) => {
226 try {
227 let innerResult = await query(request);
228 if (!isResponse(innerResult)) innerResult = await renderHtml(innerResult, isSpaMode);
229 return innerResult;
230 } catch (error) {
231 handleError(error);
232 return new Response(null, { status: 500 });
233 }
234 },
235 normalizePath: (r) => getNormalizedPath(r)
236 });
237 if (!isResponse(result)) result = await renderHtml(result, isSpaMode);
238 return result;
239 } catch (error) {
240 handleError(error);
241 return new Response(null, { status: 500 });
242 }
243 async function renderHtml(context, isSpaMode) {
244 let headers = getDocumentHeaders(context, build);
245 if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) return new Response(null, {
246 status: context.statusCode,
247 headers
248 });
249 if (context.errors) {
250 Object.values(context.errors).forEach((err) => {
251 if (!isRouteErrorResponse(err) || err.error) handleError(err);
252 });
253 context.errors = sanitizeErrors(context.errors, serverMode);
254 }
255 let state = {
256 loaderData: context.loaderData,
257 actionData: context.actionData,
258 errors: context.errors
259 };
260 let routeDiscovery = build.routeDiscovery;
261 if (isFogOfWarEnabled(routeDiscovery, build.ssr) && shouldUseInitialRouteDiscovery(context.location.pathname, staticHandler._matchCost)) routeDiscovery = {
262 ...routeDiscovery,
263 mode: "initial"
264 };
265 let baseServerHandoff = {
266 basename: build.basename,
267 future: build.future,
268 routeDiscovery,
269 ssr: build.ssr,
270 isSpaMode,
271 unstable_apiOnly: build.unstable_apiOnly,
272 unstable_apiServerOrigin: build.unstable_apiServerOrigin
273 };
274 let entryContext = {
275 manifest: build.assets,
276 branches: [],
277 routeModules: createEntryRouteModules(build.routes),
278 staticHandlerContext: context,
279 criticalCss,
280 serverHandoffString: createServerHandoffString({
281 ...baseServerHandoff,
282 criticalCss
283 }),
284 serverHandoffStream: encodeViaTurboStream(state, request.signal, build.entry.module.streamTimeout, serverMode),
285 renderMeta: {},
286 future: build.future,
287 ssr: build.ssr,
288 routeDiscovery,
289 isSpaMode,
290 unstable_apiOnly: build.unstable_apiOnly,
291 unstable_apiServerOrigin: build.unstable_apiServerOrigin,
292 serializeError: (err) => serializeError(err, serverMode)
293 };
294 let handleDocumentRequestFunction = build.entry.module.default;
295 try {
296 return await handleDocumentRequestFunction(request, context.statusCode, headers, entryContext, loadContext);
297 } catch (error) {
298 handleError(error);
299 let errorForSecondRender = error;
300 if (isResponse(error)) try {
301 let data = await unwrapResponse(error);
302 errorForSecondRender = new ErrorResponseImpl(error.status, error.statusText, data);
303 } catch {}
304 context = getStaticContextFromError(staticHandler.dataRoutes, context, errorForSecondRender);
305 if (context.errors) context.errors = sanitizeErrors(context.errors, serverMode);
306 let state = {
307 loaderData: context.loaderData,
308 actionData: context.actionData,
309 errors: context.errors
310 };
311 entryContext = {
312 ...entryContext,
313 branches: [],
314 staticHandlerContext: context,
315 serverHandoffString: createServerHandoffString(baseServerHandoff),
316 serverHandoffStream: encodeViaTurboStream(state, request.signal, build.entry.module.streamTimeout, serverMode),
317 renderMeta: {}
318 };
319 try {
320 return await handleDocumentRequestFunction(request, context.statusCode, headers, entryContext, loadContext);
321 } catch (error) {
322 handleError(error);
323 return returnLastResortErrorResponse(error, serverMode);
324 }
325 }
326 }
327}
328async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
329 try {
330 return handleQueryRouteResult(await staticHandler.queryRoute(request, {
331 routeId,
332 requestContext: loadContext,
333 generateMiddlewareResponse: async (queryRoute) => {
334 try {
335 return handleQueryRouteResult(await queryRoute(request));
336 } catch (error) {
337 return handleQueryRouteError(error);
338 }
339 },
340 normalizePath: (r) => getNormalizedPath(r)
341 }));
342 } catch (error) {
343 return handleQueryRouteError(error);
344 }
345 function handleQueryRouteResult(result) {
346 if (isResponse(result)) return result;
347 if (typeof result === "string") return new Response(result);
348 return Response.json(result);
349 }
350 function handleQueryRouteError(error) {
351 if (isResponse(error)) return error;
352 if (isRouteErrorResponse(error)) {
353 handleError(error);
354 return errorResponseToJson(error, serverMode);
355 }
356 if (error instanceof Error && error.message === "Expected a response from queryRoute") {
357 let newError = /* @__PURE__ */ new Error("Expected a Response to be returned from resource route handler");
358 handleError(newError);
359 return returnLastResortErrorResponse(newError, serverMode);
360 }
361 handleError(error);
362 return returnLastResortErrorResponse(error, serverMode);
363 }
364}
365function errorResponseToJson(errorResponse, serverMode) {
366 return Response.json(serializeError(errorResponse.error || /* @__PURE__ */ new Error("Unexpected Server Error"), serverMode), {
367 status: errorResponse.status,
368 statusText: errorResponse.statusText
369 });
370}
371function returnLastResortErrorResponse(error, serverMode) {
372 let message = "Unexpected Server Error";
373 if (serverMode !== "production") message += `\n\n${String(error)}`;
374 return new Response(message, {
375 status: 500,
376 headers: { "Content-Type": "text/plain" }
377 });
378}
379function unwrapResponse(response) {
380 let contentType = response.headers.get("Content-Type");
381 return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
382}
383//#endregion
384export { createRequestHandler };