Improve server context

Author: ije

framework/core/router.ts

@@ -70,8 +70,8 @@ export function matchRoutes(url: URL, router: Router): RouteMatch[] {
         }
       }
     }
+    // find index route if no direct match
     if (matches.length === 0) {
-      // find index route
       for (const [p, m] of routes) {
         if (m.pattern.pathname.endsWith("/index")) {
           const ret = p.exec({ host: url.host, pathname: pathname + "/index" });

server/context.ts

@@ -2,28 +2,29 @@ import { computeHash, hmacSign, splitBy } from "../shared/util.ts";
 import { SessionImpl } from "./session.ts";
 import type { ConnInfo, Context, HTMLRewriterHandlers, Session, SessionOptions } from "./types.ts";
 
-type ContextOptions = {
-  connInfo?: ConnInfo;
-  session?: SessionOptions;
+export const NEXT = Symbol();
+export const CUSTOM_HTML_REWRITER = Symbol();
+
+export type ContextInit = {
+  req: Request;
+  connInfo: ConnInfo;
+  sessionOptions?: SessionOptions;
 };
 
 /** create a context object */
-export function createContext(
-  req: Request,
-  next: () => Promise<Response> | Response,
-  options?: ContextOptions,
-): Context {
+export function createContext(next: () => Promise<Response> | Response, init: ContextInit): Context {
   let cookies: Map<string, string> | null = null;
   let session: Session<Record<string, unknown>> | null = null;
+  const customHtmlRewriter: [string, HTMLRewriterHandlers][] = [];
+  const extension = {};
   const ctx: Context = {
-    connInfo: options?.connInfo,
+    connInfo: init.connInfo,
     params: {},
-    headers: new Headers(),
     cookies: {
       get(name: string) {
-        if (cookies === null) {
+        if (!cookies) {
           cookies = new Map<string, string>();
-          const cookieHeader = req.headers.get("Cookie");
+          const cookieHeader = init.req.headers.get("Cookie");
           if (cookieHeader) {
             for (const cookie of cookieHeader.split(";")) {
               const [key, value] = splitBy(cookie, "=");
@@ -37,12 +38,13 @@ export function createContext(
     // deno-lint-ignore ban-ts-comment
     // @ts-ignore
     async getSession(): Promise<Session<Record<string, unknown>>> {
-      if (session !== null) {
+      if (session) {
         return session;
       }
 
-      const cookieName = options?.session?.cookie?.name ?? "session";
-      const secret = options?.session?.secret ?? "-";
+      const { sessionOptions } = init;
+      const cookieName = sessionOptions?.cookie?.name ?? "session";
+      const secret = sessionOptions?.secret ?? "-";
       let sid = ctx.cookies.get(cookieName);
       let skipInit = false;
       if (sid) {
@@ -57,23 +59,44 @@ export function createContext(
         skipInit = true;
       }
 
-      const sessionImpl = new SessionImpl<Record<string, unknown>>(
-        sid,
-        options?.session,
-      );
+      const sessionImpl = new SessionImpl<Record<string, unknown>>(sid, sessionOptions);
       session = sessionImpl;
       if (!skipInit) {
         await sessionImpl.init();
       }
       return session;
     },
-    __htmlRewriterHandlers: [],
     htmlRewriter: {
       on: (selector: string, handlers: HTMLRewriterHandlers) => {
-        (ctx.__htmlRewriterHandlers as unknown[]).push([selector, handlers]);
+        customHtmlRewriter.push([selector, handlers]);
       },
     },
     next,
   };
-  return ctx;
+  return new Proxy(Object.create({}), {
+    get(_target, prop) {
+      if (prop === CUSTOM_HTML_REWRITER) {
+        return customHtmlRewriter;
+      }
+      if (Reflect.has(ctx, prop)) {
+        return Reflect.get(ctx, prop);
+      }
+      return Reflect.get(extension, prop);
+    },
+    set(_target, prop, value) {
+      if (prop === NEXT) {
+        Reflect.set(ctx, "next", value);
+      }
+      if (!Reflect.has(ctx, prop)) {
+        return Reflect.set(extension, prop, value);
+      }
+      return false;
+    },
+    deleteProperty(_target, prop) {
+      if (!Reflect.has(ctx, prop)) {
+        return Reflect.deleteProperty(extension, prop);
+      }
+      return false;
+    },
+  });
 }

server/handler.ts

@@ -1,7 +1,7 @@
 import { generateErrorHtml, TransformError } from "../framework/core/error.ts";
 import type { Router } from "../framework/core/router.ts";
 import { isPlainObject, trimSuffix } from "../shared/util.ts";
-import { createContext } from "./context.ts";
+import { createContext, NEXT } from "./context.ts";
 import { handleHMR } from "./dev.ts";
 import { HTMLRewriter, path } from "./deps.ts";
 import {
@@ -25,10 +25,10 @@ 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, ModuleLoader } from "./types.ts";
+import type { AlephConfig, ConnInfo, Context, ModuleLoader } from "./types.ts";
 
 export function createHandler(config: AlephConfig) {
-  const { loaders, middlewares, onError, build, router: routerConfig, session, ssr } = config;
+  const { loaders, middlewares, onError, build, router: routerConfig, ssr } = config;
   const buildMode = Deno.args.includes("--build");
   const isDev = Deno.args.includes("--dev");
   const appDir = getAppDir();
@@ -72,7 +72,7 @@ export function createHandler(config: AlephConfig) {
     // 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");
+        const outDir = path.join(appDir, build?.outputDir ?? "output");
         if (await existsDir(outDir)) {
           return outDir;
         }
@@ -352,11 +352,16 @@ export function createHandler(config: AlephConfig) {
 
   // the deno http server handler
   return (req: Request, connInfo: ConnInfo): Promise<Response> | Response => {
+    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];
-        const ctx = createContext(req, next.bind(null, i + 1), { connInfo, session });
         try {
+          Reflect.set(ctx, NEXT, next.bind(null, i + 1));
           return mw.fetch(req, ctx);
         } catch (err) {
           const res = onError?.(err, "middleware", req, ctx);
@@ -370,7 +375,6 @@ export function createHandler(config: AlephConfig) {
           });
         }
       }
-      const ctx = createContext(req, () => Promise.resolve(new Response(null)), { connInfo, session });
       return handler(req, ctx);
     };
     return next(0);

server/renderer.ts

@@ -1,6 +1,7 @@
 import { FetchError } from "../framework/core/error.ts";
 import { matchRoutes, type RouteModule, type Router } from "../framework/core/router.ts";
 import { cleanPath, isFilledString, isPlainObject, utf8Enc } from "../shared/util.ts";
+import { CUSTOM_HTML_REWRITER } from "./context.ts";
 import { HTMLRewriter, path } from "./deps.ts";
 import depGraph from "./graph.ts";
 import { getAlephConfig, getAppDir, getDeploymentId, getFiles, regJsxFile, toLocalPath } from "./helpers.ts";
@@ -18,13 +19,13 @@ export type RenderOptions = {
 export default {
   async fetch(req: Request, ctx: Record<string, unknown>, options: RenderOptions): Promise<Response> {
     const { indexHtml, router, ssr, isDev } = options;
-    const headers = new Headers(ctx.headers as Headers);
+    const headers = new Headers();
     const isFn = typeof ssr === "function";
     const CSP = isFn ? undefined : ssr.CSP;
     const render = isFn ? ssr : ssr.render;
     const [url, modules, deferedData] = await initSSR(req, ctx, router);
     const headCollection: string[] = [];
-    const customHTMLRewriter = ctx.__htmlRewriterHandlers as [string, HTMLRewriterHandlers][];
+    const customHTMLRewriter = Reflect.get(ctx, CUSTOM_HTML_REWRITER) as [string, HTMLRewriterHandlers][];
 
     let status = 200;
     let suspenseMarker: SuspenseMarker | undefined;