rwsdk
Version:
Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime
186 lines (185 loc) • 9.71 kB
JavaScript
import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
import { transformRscToHtmlStream } from "./render/transformRscToHtmlStream";
import { renderToRscStream } from "./render/renderToRscStream";
import { rscActionHandler } from "./register/worker";
import { injectRSCPayload } from "rsc-html-stream/server";
import { ErrorResponse } from "./error";
import { getRequestInfo, runWithRequestInfo, runWithRequestInfoOverrides, } from "./requestInfo/worker";
import { defineRoutes } from "./lib/router";
import { generateNonce } from "./lib/utils";
import { ssrWebpackRequire } from "./imports/worker";
export const defineApp = (routes) => {
return {
fetch: async (request, env, cf) => {
globalThis.__webpack_require__ = ssrWebpackRequire;
const router = defineRoutes(routes);
// context(justinvdm, 5 Feb 2025): Serve assets requests using the assets service binding
// todo(justinvdm, 5 Feb 2025): Find a way to avoid this so asset requests are served directly
// rather than first needing to go through the worker
if (request.url.includes("/assets/")) {
const url = new URL(request.url);
url.pathname = url.pathname.slice("/assets/".length);
return env.ASSETS.fetch(new Request(url.toString(), request));
}
else if (import.meta.env.VITE_IS_DEV_SERVER &&
request.url.includes("/__vite_preamble__")) {
return new Response('import RefreshRuntime from "/@react-refresh"; RefreshRuntime.injectIntoGlobalHook(window); window.$RefreshReg$ = () => {}; window.$RefreshSig$ = () => (type) => type; window.__vite_plugin_react_preamble_installed__ = true;', {
headers: {
"content-type": "text/javascript",
},
});
}
try {
const url = new URL(request.url);
const isRSCRequest = url.searchParams.has("__rsc") ||
request.headers.get("accept")?.includes("text/x-component");
const isSmokeTest = url.searchParams.has("__smoke_test");
const userHeaders = new Headers();
const rw = {
Document: DefaultDocument,
nonce: generateNonce(),
rscPayload: true,
ssr: true,
databases: new Map(),
pageRouteResolved: undefined,
};
const userResponseInit = {
status: 200,
headers: new Headers(),
};
const outerRequestInfo = {
request,
headers: userHeaders,
cf,
params: {},
ctx: {},
rw,
response: userResponseInit,
};
const createPageElement = (requestInfo, Page) => {
let pageElement;
if (isClientReference(Page)) {
const { ctx, params } = requestInfo; // context(justinvdm, 25 Feb 2025): If the page is a client reference, we need to avoid passing
// down props the client shouldn't get (e.g. env). For safety, we pick the allowed props explicitly.
pageElement = _jsx(Page, { ctx: ctx, params: params });
}
else {
pageElement = _jsx(Page, { ...requestInfo });
}
if (isSmokeTest) {
pageElement = _jsx(SmokeTestWrapper, { children: pageElement });
}
return pageElement;
};
const renderPage = async (requestInfo, Page, onError) => {
if (isClientReference(requestInfo.rw.Document)) {
if (import.meta.env.DEV) {
console.error("Document cannot be a client component");
}
return new Response(null, {
status: 500,
});
}
let actionResult = undefined;
const isRSCActionHandler = url.searchParams.has("__rsc_action_id");
if (isRSCActionHandler) {
actionResult = await rscActionHandler(request);
}
const pageElement = createPageElement(requestInfo, Page);
const { rscPayload: shouldInjectRSCPayload } = rw;
let rscPayloadStream = renderToRscStream({
node: pageElement,
actionResult: actionResult instanceof Response ? null : actionResult,
onError,
});
if (isRSCRequest) {
const responseHeaders = new Headers(userResponseInit.headers);
responseHeaders.set("content-type", "text/x-component; charset=utf-8");
return new Response(rscPayloadStream, {
status: userResponseInit.status,
statusText: userResponseInit.statusText,
headers: responseHeaders,
});
}
let injectRSCPayloadStream;
if (shouldInjectRSCPayload) {
const [rscPayloadStream1, rscPayloadStream2] = rscPayloadStream.tee();
rscPayloadStream = rscPayloadStream1;
injectRSCPayloadStream = injectRSCPayload(rscPayloadStream2, {
nonce: rw.nonce,
});
}
let html = await transformRscToHtmlStream({
stream: rscPayloadStream,
Document: rw.Document,
requestInfo: requestInfo,
onError,
});
if (injectRSCPayloadStream) {
html = html.pipeThrough(injectRSCPayloadStream);
}
const responseHeaders = new Headers(userResponseInit.headers);
responseHeaders.set("content-type", "text/html; charset=utf-8");
return new Response(html, {
status: userResponseInit.status,
statusText: userResponseInit.statusText,
headers: responseHeaders,
});
};
const response = await runWithRequestInfo(outerRequestInfo, async () => new Promise(async (resolve, reject) => {
try {
resolve(await router.handle({
request,
renderPage,
getRequestInfo: getRequestInfo,
runWithRequestInfoOverrides,
onError: reject,
}));
}
catch (e) {
reject(e);
}
}));
// context(justinvdm, 18 Mar 2025): In some cases, such as a .fetch() call to a durable object instance, or Response.redirect(),
// we need to return a mutable response object.
const mutableResponse = new Response(response.body, response);
// Merge user headers from the legacy headers object
for (const [key, value] of userHeaders.entries()) {
if (!response.headers.has(key)) {
mutableResponse.headers.set(key, value);
}
}
// Merge headers from user response init (these take precedence)
if (userResponseInit.headers) {
const userResponseHeaders = new Headers(userResponseInit.headers);
for (const [key, value] of userResponseHeaders.entries()) {
if (!response.headers.has(key)) {
mutableResponse.headers.set(key, value);
}
}
}
await rw.pageRouteResolved?.promise;
return mutableResponse;
}
catch (e) {
if (e instanceof ErrorResponse) {
return new Response(e.message, { status: e.code });
}
if (e instanceof Response) {
return e;
}
console.error("Unhandled error", e);
throw e;
}
},
};
};
export const SmokeTestWrapper = async ({ children }) => {
const smokeTestInfo = await Object.values(await import.meta.glob("/src/app/components/__SmokeTest.tsx"))[0]();
const SmokeTestInfo = smokeTestInfo.SmokeTestInfo;
return (_jsxs(_Fragment, { children: [_jsx(SmokeTestInfo, {}), children] }));
};
export const DefaultDocument = ({ children, }) => (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx("meta", { charSet: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" })] }), _jsx("body", { children: _jsx("div", { id: "root", children: children }) })] }));
const isClientReference = (Component) => {
return Object.prototype.hasOwnProperty.call(Component, "$$isClientReference");
};