one
Version:
One is a new React Framework that makes Vite serve both native and web.
233 lines (230 loc) • 10.8 kB
JavaScript
import { readFile } from "node:fs/promises";
import { extname, join, resolve } from "node:path";
import {
CSS_PRELOAD_JS_POSTFIX,
LOADER_JS_POSTFIX_UNCACHED,
PRELOAD_JS_POSTFIX
} from "../constants";
import {
compileManifest,
getURLfromRequestURL,
runMiddlewares
} from "../createHandleRequest";
import { getPathFromLoaderPath } from "../utils/cleanUrl";
import { toAbsolute } from "../utils/toAbsolute";
import { getFetchStaticHtml } from "./staticHtmlFetcher";
const debugRouter = process.env.ONE_DEBUG_ROUTER;
async function oneServe(oneOptions, buildInfo, app, options) {
const { resolveAPIRoute, resolveLoaderRoute, resolvePageRoute } = await import("../createHandleRequest"), { isResponse } = await import("../utils/isResponse"), { isStatusRedirect } = await import("../utils/isStatus"), isAPIRequest = /* @__PURE__ */ new WeakMap(), redirects = oneOptions.web?.redirects;
if (redirects)
for (const redirect of redirects)
app.get(redirect.source, (context) => {
const destinationUrl = redirect.destination.replace(/:\w+/g, (param) => {
const paramName = param.substring(1);
return context.req.param(paramName) || "";
});
return debugRouter && console.info(`[one] \u21AA redirect ${context.req.path} \u2192 ${destinationUrl}`), context.redirect(destinationUrl, redirect.permanent ? 301 : 302);
});
if (!buildInfo)
throw new Error("No build info found, have you run build?");
const { routeToBuildInfo, routeMap } = buildInfo, serverOptions = {
...oneOptions,
root: "."
}, apiCJS = oneOptions.build?.api?.outputFormat === "cjs", useRolldown = buildInfo.useRolldown ?? !1;
let render = null;
async function getRender() {
return render || (render = (options?.lazyRoutes?.serverEntry ? await options.lazyRoutes.serverEntry() : await import(resolve(
process.cwd(),
`${serverOptions.root}/dist/server/_virtual_one-entry.${typeof oneOptions.build?.server == "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`
))).default.render), render;
}
const requestHandlers = {
async handleAPI({ route }) {
if (options?.lazyRoutes?.api?.[route.page])
return await options.lazyRoutes.api[route.page]();
const fileName = useRolldown ? route.page.slice(1) : route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
return await import(join(
process.cwd(),
"dist",
"api",
fileName + (apiCJS ? ".cjs" : ".js")
));
},
async loadMiddleware(route) {
return options?.lazyRoutes?.middlewares?.[route.contextKey] ? await options.lazyRoutes.middlewares[route.contextKey]() : await import(toAbsolute(route.contextKey));
},
async handleLoader({ route, loaderProps }) {
const routeFile = route.routeFile || route.file, exports = options?.lazyRoutes?.pages?.[routeFile] ? await options.lazyRoutes.pages[routeFile]() : await import(toAbsolute(join("./", "dist/server", route.file))), { loader } = exports;
if (!loader)
return console.warn("No loader found in exports", route.file), null;
const json = await loader(loaderProps);
return `export function loader() { return ${JSON.stringify(json)} }`;
},
async handlePage({ route, url, loaderProps }) {
const buildInfo2 = routeToBuildInfo[route.file];
if (route.type === "ssr") {
if (!buildInfo2)
throw console.error("Error in route", route), new Error(
`No buildinfo found for ${url}, route: ${route.file}, in keys:
${Object.keys(routeToBuildInfo).join(`
`)}`
);
try {
const exported = options?.lazyRoutes?.pages?.[route.file] ? await options.lazyRoutes.pages[route.file]() : await import(toAbsolute(buildInfo2.serverJsPath));
let loaderData;
try {
loaderData = await exported.loader?.(loaderProps);
} catch (loaderErr) {
if (isResponse(loaderErr))
return loaderErr;
throw loaderErr;
}
const headers = new Headers();
headers.set("content-type", "text/html"), globalThis.__vxrnresetState?.();
const rendered = await (await getRender())({
mode: route.type,
loaderData,
loaderProps,
path: loaderProps?.path || "/",
// Use separated preloads for optimal loading
preloads: buildInfo2.criticalPreloads || buildInfo2.preloads,
deferredPreloads: buildInfo2.deferredPreloads,
css: buildInfo2.css,
cssContents: buildInfo2.cssContents
});
return new Response(rendered, {
headers,
status: route.isNotFound ? 404 : 200
});
} catch (err) {
if (isResponse(err))
return err;
console.error(`[one] Error rendering SSR route ${route.file}
${err?.stack ?? err}
url: ${url}`);
}
} else {
const htmlPath = routeMap[url.pathname] || routeMap[buildInfo2?.cleanPath];
if (htmlPath) {
const fetchStaticHtml = getFetchStaticHtml();
let html = null;
if (fetchStaticHtml && (html = await fetchStaticHtml(htmlPath)), !html)
try {
html = await readFile(join("dist/client", htmlPath), "utf-8");
} catch {
}
if (html) {
const headers = new Headers();
return headers.set("content-type", "text/html"), new Response(html, {
headers,
status: route.isNotFound ? 404 : 200
});
}
}
}
}
};
function createHonoHandler(route) {
return async (context, next) => {
try {
const request = context.req.raw;
if ((route.page.endsWith("/+not-found") || Reflect.ownKeys(route.routeKeys).length > 0) && options?.serveStaticAssets) {
const staticAssetResponse = await options.serveStaticAssets({
context
});
if (staticAssetResponse)
return await runMiddlewares(
requestHandlers,
request,
route,
async () => staticAssetResponse
);
}
if (extname(request.url) === ".js" || extname(request.url) === ".css")
return next();
const url = getURLfromRequestURL(request), response = await (() => {
if (url.pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
const originalUrl = getPathFromLoaderPath(url.pathname), finalUrl = new URL(originalUrl, url.origin), cleanedRequest = new Request(finalUrl, request);
return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route);
}
switch (route.type) {
case "api":
return debugRouter && console.info(
`[one] \u26A1 ${url.pathname} \u2192 matched API route: ${route.page}`
), resolveAPIRoute(requestHandlers, request, url, route);
case "ssg":
case "spa":
case "ssr":
return debugRouter && console.info(
`[one] \u26A1 ${url.pathname} \u2192 matched page route: ${route.page} (${route.type})`
), resolvePageRoute(requestHandlers, request, url, route);
}
})();
if (response) {
if (isResponse(response)) {
if (isStatusRedirect(response.status)) {
const location = `${response.headers.get("location") || ""}`;
return response.headers.forEach((value, key) => {
context.header(key, value);
}), context.redirect(location, response.status);
}
if (isAPIRequest.get(request))
try {
return !response.headers.has("cache-control") && !response.headers.has("Cache-Control") && response.headers.set("cache-control", "no-store"), response;
} catch (err) {
console.info(
`Error updating cache header on api route "${context.req.path}" to no-store, it is ${response.headers.get("cache-control")}, continue`,
err
);
}
return response;
}
return next();
}
} catch (err) {
console.error(` [one] Error handling request: ${err.stack}`);
}
return next();
};
}
const compiledManifest = compileManifest(buildInfo.manifest);
for (const route of compiledManifest.apiRoutes)
app.get(route.urlPath, createHonoHandler(route)), app.put(route.urlPath, createHonoHandler(route)), app.post(route.urlPath, createHonoHandler(route)), app.delete(route.urlPath, createHonoHandler(route)), app.patch(route.urlPath, createHonoHandler(route)), route.urlPath !== route.urlCleanPath && (app.get(route.urlCleanPath, createHonoHandler(route)), app.put(route.urlCleanPath, createHonoHandler(route)), app.post(route.urlCleanPath, createHonoHandler(route)), app.delete(route.urlCleanPath, createHonoHandler(route)), app.patch(route.urlCleanPath, createHonoHandler(route)));
for (const route of compiledManifest.pageRoutes)
app.get(route.urlPath, createHonoHandler(route)), route.urlPath !== route.urlCleanPath && app.get(route.urlCleanPath, createHonoHandler(route));
const { preloads, cssPreloads } = buildInfo;
app.get("*", async (c, next) => {
if (c.req.path.endsWith(PRELOAD_JS_POSTFIX) && !preloads[c.req.path])
return c.header("Content-Type", "text/javascript"), c.status(200), c.body("");
if (c.req.path.endsWith(CSS_PRELOAD_JS_POSTFIX) && !cssPreloads?.[c.req.path])
return c.header("Content-Type", "text/javascript"), c.status(200), c.body("export default Promise.resolve()");
if (c.req.path.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
const request = c.req.raw, url = getURLfromRequestURL(request), originalUrl = getPathFromLoaderPath(c.req.path);
for (const route of compiledManifest.pageRoutes) {
if (route.file === "" || !route.compiledRegex.test(originalUrl))
continue;
const loaderRoute = {
...route,
routeFile: route.file,
// preserve original for lazy route lookup
file: route.loaderServerPath || c.req.path
}, finalUrl = new URL(originalUrl, url.origin), cleanedRequest = new Request(finalUrl, request);
try {
return await resolveLoaderRoute(
requestHandlers,
cleanedRequest,
finalUrl,
loaderRoute
);
} catch (err) {
return console.error(`Error running loader: ${err}`), next();
}
}
}
return next();
});
}
export {
oneServe
};
//# sourceMappingURL=oneServe.js.map