Very Popular
Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401import { generateErrorHtml, TransformError } from "../framework/core/error.ts";import type { Router } from "../framework/core/router.ts";import { isPlainObject, trimSuffix } from "../shared/util.ts";import { createContext, NEXT } from "./context.ts";import { handleHMR } from "./dev.ts";import { HTMLRewriter, path } from "./deps.ts";import { existsDir, existsFile, fetchCode, getAlephPkgUri, getAppDir, getDeploymentId, getImportMap, getJSXConfig, globalIt, isNpmPkg, regFullVersion, restoreUrl, toLocalPath,} from "./helpers.ts";import { createHtmlResponse, loadIndexHtml } from "./html.ts";import log from "./log.ts";import { getContentType } from "./media_type.ts";import renderer from "./renderer.ts";import { fetchRoute, importRouteModule, initRouter } from "./router.ts";import transformer from "./transformer.ts";import type { AlephConfig, ConnInfo, Context, ModuleLoader } from "./types.ts";
export function createHandler(config: AlephConfig) { const { loaders, middlewares, onError, build, router: routerConfig, ssr } = config; const buildMode = Deno.args.includes("--build"); const isDev = Deno.args.includes("--dev"); const appDir = getAppDir();
const staticHandler = async (req: Request): Promise<Response | void> => { const { pathname, searchParams } = new URL(req.url);
// handle HMR socket if (pathname === "/-/hmr") { if (isDev) { return handleHMR(req); } const { socket, response } = Deno.upgradeWebSocket(req); socket.addEventListener("open", () => { // tell the client to reload the page if not _dev_ mode socket.send(JSON.stringify({ type: "reload" })); }); return response; }
// getStaticPaths PRC for SSR if (pathname === "/-/getStaticPaths") { const router: Router = await globalIt("__ALEPH_ROUTER", () => initRouter(appDir, routerConfig)); const pattern = searchParams.get("pattern"); const route = router.routes.find(([_, r]) => r.pattern.pathname === pattern); if (route) { const mod = await importRouteModule(route[1]); if (typeof mod.getStaticPaths === "function") { let ret = mod.getStaticPaths(); if (ret instanceof Promise) { ret = await ret; } if (Array.isArray(ret)) { return Response.json(ret); } } } return Response.json([]); }
// check if the `out` directory exists const outDir = await globalIt("__ALEPH_OUT_DIR", async () => { if (!isDev && !buildMode) { const outDir = path.join(appDir, build?.outputDir ?? "output"); if (await existsDir(outDir)) { return outDir; } } return null; });
// transform modules let loader: ModuleLoader | undefined; if ( !searchParams.has("raw") && ( // 1. check loader first (loader = loaders?.find((l) => l.test(pathname))) || // 2. check built-in modules transformer.test(pathname) ) ) { if (pathname.endsWith(".map") && pathname.startsWith("/-/")) { const [content, contentType] = await fetchCode(restoreUrl(pathname)); return new Response(content, { headers: [["Content-Type", contentType]], }); } // check and use the build output if (!isDev && !buildMode && outDir && !searchParams.has("ssr")) { let outFile = path.join(outDir, pathname); if (pathname.startsWith("/-/") && isNpmPkg(restoreUrl(pathname))) { outFile += ".js"; } if (await existsFile(outFile)) { const file = await Deno.open(outFile, { read: true }); const headers = new Headers(); if (outFile.endsWith(".css")) { headers.set("Content-Type", "text/css; charset=utf-8"); } else { headers.set("Content-Type", "application/javascript; charset=utf-8"); } if (searchParams.get("v") || (pathname.startsWith("/-/") && regFullVersion.test(pathname))) { headers.append("Cache-Control", "public, max-age=31536000, immutable"); } return new Response(file.readable, { headers }); } } try { const [importMap, jsxConfig] = await Promise.all([ getImportMap(appDir), getJSXConfig(appDir), ]); return await transformer.fetch(req, { importMap, jsxConfig, loader, isDev, }); } catch (err) { if (err instanceof TransformError) { // todo: pretty error message in terminal log.error(err.message); const alephPkgUri = toLocalPath(getAlephPkgUri()); return new Response( `import { showTransformError } from "${alephPkgUri}/framework/core/error.ts";showTransformError(${ JSON.stringify(err) });export default null;`, { headers: [ ["Content-Type", "application/javascript; charset=utf-8"], ["X-Transform-Error", "true"], ], }, ); } else if (!(err instanceof Deno.errors.NotFound)) { log.error(err); return onError?.(err, "transform", req) ?? new Response(generateErrorHtml(err.stack ?? err.message), { status: 500, headers: [["Content-Type", "text/html;"]], }); } } }
// serve static files const contentType = getContentType(pathname); if (!pathname.startsWith("/.") && contentType !== "application/octet-stream") { try { let filePath = path.join(appDir, pathname); let stat = await Deno.lstat(filePath); if (stat.isDirectory && pathname !== "/") { filePath = `${trimSuffix(filePath, "/")}/index.html`; stat = await Deno.lstat(filePath); } if (stat.isFile) { const headers = new Headers({ "Content-Type": contentType }); const deployId = getDeploymentId(); let etag: string | null = null; if (deployId) { etag = `W/${btoa(pathname).replace(/[^a-z0-9]/g, "")}-${deployId}`; } else { const { mtime, size } = stat; if (mtime) { etag = `W/${mtime.getTime().toString(16)}-${size.toString(16)}`; headers.append("Last-Modified", new Date(mtime).toUTCString()); } } if (etag) { if (req.headers.get("If-None-Match") === etag) { return new Response(null, { status: 304 }); } headers.append("ETag", etag); } if (searchParams.get("v") || regFullVersion.test(pathname)) { headers.append("Cache-Control", "public, max-age=31536000, immutable"); } const file = await Deno.open(filePath, { read: true }); return new Response(file.readable, { headers }); } } catch (err) { if (!(err instanceof Deno.errors.NotFound)) { log.error(err); return onError?.(err, "fs", req) ?? new Response(generateErrorHtml(err.stack ?? err.message), { status: 500, headers: [["Content-Type", "text/html;"]], }); } } } };
const routeHandler = async (req: Request, ctx: Context): Promise<Response> => { const { pathname, searchParams } = new URL(req.url);
// don't render special asset files switch (pathname) { case "/favicon.ico": case "/robots.txt": return new Response("Not found", { status: 404 }); default: if (pathname.startsWith("/-/") || pathname.startsWith("/.")) { return new Response("Not found", { status: 404 }); } }
// get the router const router: Router = await globalIt("__ALEPH_ROUTER", () => initRouter(appDir, routerConfig));
// for SSR dynamic data if (router.routes.length > 0) { try { const res = await fetchRoute(req, ctx, router); if (res) return res; } catch (err) { const fetchData = req.method === "GET" && searchParams.has("_data_");
// user throws a response if (err instanceof Response) { return err; }
// javascript syntax error if (err instanceof TypeError && !fetchData) { return new Response(generateErrorHtml(err.stack ?? err.message), { status: 500, headers: [["Content-Type", "text/html;"]], }); }
// use the `onError` if available const res = onError?.(err, fetchData ? "fetch-route-data" : "fetch-route", req, ctx); if (res instanceof Response) { return res; }
// prints the error stack if (err instanceof Error || typeof err === "string") { log.error(err); }
// return the error as a json let status: number = err.status ?? err.code; if (!Number.isInteger(status)) { status = 500; } return Response.json({ ...err, status, message: err.message ?? String(err), stack: err.stack, }, { status }); } }
// load index.html const indexHtml = await globalIt( "__ALEPH_INDEX_HTML", () => loadIndexHtml(path.join(appDir, "index.html"), { hmr: isDev ? { wsUrl: Deno.env.get("HMR_WS_URL") } : undefined, ssr: ssr ? { root: isPlainObject(ssr) ? ssr.root : undefined } : undefined, }), ); if (!indexHtml) { return new Response("Not found", { status: 404 }); }
// non SSR if ( !ssr || (isPlainObject(ssr) && ( (ssr.exclude instanceof RegExp && ssr.exclude.test(pathname)) || (Array.isArray(ssr.exclude) && ssr.exclude.some((p) => p.test(pathname))) || (ssr.include instanceof RegExp && !ssr.include.test(pathname)) || (Array.isArray(ssr.include) && !ssr.include.some((p) => p.test(pathname))) )) ) { const stream = new ReadableStream({ start: (controller) => { const rewriter = new HTMLRewriter("utf8", (chunk: Uint8Array) => { controller.enqueue(chunk); }); // inject the router manifest rewriter.on("head", { element(el) { if (router.routes.length > 0) { const json = JSON.stringify({ routes: router.routes.map(([_, meta]) => meta), prefix: router.prefix, }); el.append(`<script id="router-manifest" type="application/json">${json}</script>`, { html: true, }); } }, }); try { rewriter.write(indexHtml); rewriter.end(); } finally { rewriter.free(); } controller.close(); }, }); return new Response(stream, { headers: { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "public, max-age=", }, }); }
// check if the `out` directory exists const outDir = await globalIt("__ALEPH_OUT_DIR", async () => { if (!isDev && !buildMode) { const outDir = path.join(appDir, build?.outputDir ?? "output"); if (await existsDir(outDir)) { return outDir; } } return null; });
// use SSG output if exists if (!isDev && !buildMode && outDir) { const htmlFile = path.join(outDir, pathname === "/" ? "index.html" : pathname + ".html"); if (await existsFile(htmlFile)) { return createHtmlResponse(req, htmlFile); } }
// SSR try { return await renderer.fetch(req, ctx, { indexHtml, router, ssr, isDev }); } catch (err) { if (err instanceof Response) { return err; } let message: string; if (err instanceof Error) { message = err.stack as string; log.error("SSR", err); } else { message = err?.toString?.() || String(err); } return new Response(generateErrorHtml(message, "SSR"), { headers: { "Cache-Control": "public, max-age=0, must-revalidate", "Content-Type": "text/html; charset=utf-8", }, }); } };
// the deno http server handler return async (req: Request, connInfo: ConnInfo): Promise<Response> => { const res = await staticHandler(req); if (res) return res;
const ctx = createContext(() => Promise.resolve(new Response(null)), { req, connInfo, sessionOptions: config.session, }); const next = (i: number): Promise<Response> | Response => { if (Array.isArray(middlewares) && i < middlewares.length) { const mw = middlewares[i]; try { Reflect.set(ctx, NEXT, next.bind(null, i + 1)); return mw.fetch(req, ctx); } catch (err) { const res = onError?.(err, "middleware", req, ctx); if (res instanceof Response) { return res; } log.error(`[middleare${mw.name ? `(${mw.name})` : ""}]`, err); return new Response(generateErrorHtml(err.stack ?? err.message), { status: 500, headers: [["Content-Type", "text/html; charset=utf-8"]], }); } } return routeHandler(req, ctx); }; return next(0); };}