123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
import { URLPatternCompat, type URLPatternInput } from "../framework/core/url_pattern.ts";import type { RouteMatch, RouteMeta, RoutePattern, Router } from "../framework/core/router.ts";import {  cleanPath,  isFilledString,  isPlainObject,  splitBy,  splitPath,  trimPrefix,  trimSuffix,  unique,} from "../shared/util.ts";import { path } from "./deps.ts";import depGraph from "./graph.ts";import log from "./log.ts";import { builtinModuleExts, getAlephConfig, getAppDir, getFiles, toResponse } from "./helpers.ts";import type { Context, RouterInit } from "./types.ts";
/** import the route module. */export async function importRouteModule({ filename, pattern }: RouteMeta, appDir?: string) {  const config = getAlephConfig();  const modules = config?.router?.modules;  if (modules && pattern.pathname in modules) {    return modules[pattern.pathname];  }
  const version = depGraph.get(filename)?.version;  const origin = Reflect.get(globalThis, "__ALEPH_SERVER_ORIGIN");
  let url: string;  if (origin) {    url = `${origin}${cleanPath(filename)}?ssr&v=${(version ?? depGraph.globalVersion).toString(36)}`;  } else {    const root = appDir ? path.resolve(appDir) : getAppDir();    url = `file://${path.join(root, filename)}${version ? "#" + version.toString(36) : ""}`;  }
  return await import(url);}
/** fetch the route. */export async function fetchRoute(req: Request, ctx: Context, router: Router): Promise<Response | void> {  const { pathname, host, searchParams } = new URL(req.url);  const hasDataParam = searchParams.has("_data_");  if (router.routes.length > 0) {    let pathnameInput = pathname;    if (pathnameInput !== "/") {      pathnameInput = trimSuffix(pathname, "/");    }    let matched: RouteMatch | null = null;    // find the direct match    for (const [pattern, meta] of router.routes) {      const ret = pattern.exec({ host, pathname: pathnameInput });      if (ret) {        matched = [ret, meta];        break;      }    }    if (!matched) {      // find index route      for (const [pattern, meta] of router.routes) {        if (meta.pattern.pathname.endsWith("/index")) {          const ret = pattern.exec({ host, pathname: pathnameInput + "/index" });          if (ret) {            matched = [ret, meta];            break;          }        }      }    }    if (matched) {      const { method } = req;      const [ret, meta] = matched;      const mod = await importRouteModule(meta, router.appDir);      if (method !== "GET" || (hasDataParam || typeof mod.GET === "function")) {        let fetcher: unknown;        let cacheTtl: number | undefined;        if (method === "GET") {          if (hasDataParam) {            if (typeof mod.data === "function") {              fetcher = mod.data;            } else if (isPlainObject(mod.data)) {              fetcher = mod.data.fetch;              cacheTtl = mod.data.cacheTtl;            } else {              fetcher = () => null; // empty data            }          } else {            fetcher = mod.GET;          }        } else {          if (typeof mod.mutation === "function") {            fetcher = mod.mutation;          } else if (isPlainObject(mod.mutation)) {            fetcher = mod.mutation[method] ?? mod.mutation[method.toLowerCase()];          }          if (typeof fetcher !== "function") {            fetcher = mod[method];          }        }        if (typeof fetcher === "function") {          Object.assign(ctx.params as Record<string, string>, ret.pathname.groups);          const res = await fetcher(req, ctx);          const headers = new Headers({            "Cache-Control": cacheTtl ? `public, max-age=${cacheTtl}` : "no-cache, no-store, must-revalidate",          });          if (res instanceof Response) {            return res;          }          return toResponse(res, { headers });        }        return new Response("Method Not Allowed", { status: 405 });      }    }  }}
/** initialize router from routes config */export async function initRouter(appDir: string, init: RouterInit = {}): Promise<Router> {  const reg = toRouterRegExp(init);  const files = await getFiles(appDir);  const routes: RoutePattern[] = [];  let _app: RoutePattern | undefined = undefined;  let _404: RoutePattern | undefined = undefined;  files.forEach((filename) => {    const pattern = reg.exec(filename);    if (pattern && pattern.pathname !== "/_export" && !pattern.pathname.endsWith("_test")) {      const route: RoutePattern = [        new URLPatternCompat(pattern),        { pattern, filename },      ];      routes.push(route);      if (pattern.pathname === "/_app") {        _app = route;      } else if (pattern.pathname === "/_404") {        _404 = route;      }    }  });  if (routes.length > 0) {    // sort routes by length of pathname    routes.sort((a, b) => getRouteOrder(a) - getRouteOrder(b));    // check nesting routes    routes.forEach(([_, meta]) => {      const { pattern: { pathname } } = meta;      const nesting = pathname === "/_app" || (pathname !== "/" && !pathname.endsWith("/index") &&        routes.findIndex(([_, { pattern: { pathname: p } }]) => p !== pathname && p.startsWith(pathname + "/")) !==          -1);      if (nesting) {        meta.nesting = true;      }    });  }
  log.debug(`${routes.length} routes found`);  return {    appDir,    routes,    prefix: reg.prefix,    _404,    _app,  };}
/* check if the filename is a route */export function isRouteModule(filename: string): boolean {  const router: Router | undefined = Reflect.get(globalThis, "__ALEPH_ROUTER");  const index = router?.routes?.findIndex(([_, meta]) => meta.filename === filename);  if (index !== undefined && index !== -1) {    return true;  }  const config = getAlephConfig();  if (config?.router) {    const reg = toRouterRegExp(config.router);    return reg.test(filename);  }  return false;}
/** convert route config to likely `RegExp` */export function toRouterRegExp(init: RouterInit = {}) {  let glob = init.glob;  if (!isFilledString(glob)) {    const exts = unique([...builtinModuleExts, ...(init.exts ?? [])].map((s) => trimPrefix(s, ".")));    glob = `.${cleanPath(init.dir ?? "routes")}/**/*.{${exts.join(",")}}`;  }  const prefix = splitBy(glob, "/*")[0];  const reg = path.globToRegExp("./" + trimPrefix(glob, "./"), { caseInsensitive: true });  return {    prefix,    test: (s: string) => s !== prefix + "/_export.ts" && reg.test(s),    exec: (filename: string): URLPatternInput | null => {      if (reg.test(filename)) {        const parts = splitPath(trimPrefix(filename, prefix)).map((part) => {          // replace `/blog/[...path]` to `/blog/:path+`          if (part.startsWith("[...") && part.includes("]") && part.length > 5) {            return ":" + part.slice(4).replace("]", "+");          }          // replace `/blog/[id]` to `/blog/:id`          if (part.startsWith("[") && part.includes("]") && part.length > 2) {            return ":" + part.slice(1).replace("]", "");          }          // replace `/blog/$id` to `/blog/:id`          if (part.startsWith("$") && part.length > 1) {            return ":" + part.slice(1);          }          return part;        });        let host: string | undefined = undefined;        if (parts.length > 1 && /^@[a-z0-9\.\-]+\.[a-z0-9]+$/.test(parts[0])) {          host = parts.shift()!.slice(1);        }        const basename = parts.pop()!;        const pathname = "/" + [...parts, trimSuffix(basename, path.extname(basename))].join("/");        return { host, pathname: pathname === "/index" ? "/" : pathname };      }      return null;    },  };}
/** get route order by pathname length */function getRouteOrder([_, meta]: RoutePattern): number {  const { pattern, filename } = meta;  switch (pattern.pathname) {    case "/_404":    case "/_app":      return 0;    default:      return filename.split("/").length + (pattern.pathname.split("/:").length - 1) * 0.01;  }}