feat: speed up middleware matching

This increases raw server performance on fresh.deno.dev by 20%

Author: marvinhagemeister

src/app.ts

@@ -4,7 +4,7 @@ import { trace } from "@opentelemetry/api";
 
 import { DENO_DEPLOYMENT_ID } from "./runtime/build_id.ts";
 import * as colors from "@std/fmt/colors";
-import { type MiddlewareFn, runMiddlewares } from "./middlewares/mod.ts";
+import { compileMiddlewares, type MiddlewareFn } from "./middlewares/mod.ts";
 import { Context, type ServerIslandRegistry } from "./context.ts";
 import {
   mergePath,
@@ -46,6 +46,10 @@ const DEFAULT_RENDER = <State>(): Promise<PageResponse<State>> =>
   // deno-lint-ignore no-explicit-any
   Promise.resolve({ data: {} as any });
 
+// deno-lint-ignore no-explicit-any
+const PASS_THROUGH: MiddlewareFn<any> = (ctx) => {
+  return ctx.next();
+};
 const DEFAULT_NOT_FOUND = (): Promise<Response> => {
   throw new HttpError(404);
 };
@@ -418,10 +422,25 @@ export class App<State> {
 
     for (let i = 0; i < this.#routeDefs.length; i++) {
       const route = this.#routeDefs[i];
-      this.#router.add(route.method, route.pattern, route.fns, route.unshift);
+
+      const compiled = compileMiddlewares(route.fns, DEFAULT_NOT_FOUND);
+      if (route.method === "ALL") {
+        this.#router.add("GET", route.pattern, compiled);
+        this.#router.add("DELETE", route.pattern, compiled);
+        this.#router.add("HEAD", route.pattern, compiled);
+        this.#router.add("OPTIONS", route.pattern, compiled);
+        this.#router.add("PATCH", route.pattern, compiled);
+        this.#router.add("POST", route.pattern, compiled);
+        this.#router.add("PUT", route.pattern, compiled);
+      } else {
+        this.#router.add(route.method, route.pattern, compiled);
+      }
     }
 
-    const rootMiddlewares = this.#root.middlewares;
+    const rootHandler = compileMiddlewares(
+      this.#root.middlewares,
+      PASS_THROUGH,
+    );
 
     return async (
       req: Request,
@@ -433,7 +452,7 @@ export class App<State> {
 
       const method = req.method.toUpperCase() as Method;
       const matched = this.#router.match(method, url);
-      let { params, pattern, handlers, methodMatch } = matched;
+      let { params, pattern, item: handlers, methodMatch } = matched;
 
       const span = trace.getActiveSpan();
       if (span && pattern) {
@@ -444,12 +463,12 @@ export class App<State> {
       let next: () => Promise<Response>;
 
       if (pattern === null || !methodMatch) {
-        handlers = rootMiddlewares;
+        handlers = rootHandler;
       }
 
-      if (matched.pattern !== null && !methodMatch) {
+      if (pattern !== null && !methodMatch) {
         if (method === "OPTIONS") {
-          const allowed = this.#router.getAllowedMethods(matched.pattern);
+          const allowed = this.#router.getAllowedMethods(pattern);
           next = defaultOptionsHandler(allowed);
         } else {
           next = DEFAULT_NOT_ALLOWED_METHOD;
@@ -458,6 +477,10 @@ export class App<State> {
         next = DEFAULT_NOT_FOUND;
       }
 
+      if (handlers === null) {
+        handlers = next;
+      }
+
       const ctx = new Context<State>(
         req,
         url,
@@ -470,9 +493,7 @@ export class App<State> {
       );
 
       try {
-        if (handlers.length === 0) return await next();
-
-        const result = await runMiddlewares(handlers, ctx);
+        const result = await handlers(ctx);
         if (!(result instanceof Response)) {
           throw new Error(
             `Expected a "Response" instance to be returned, but got: ${result}`,

src/middlewares/mod.ts

@@ -81,22 +81,23 @@ export type MiddlewareFn<State> = (
  */
 export type Middleware<State> = MiddlewareFn<State> | MiddlewareFn<State>[];
 
-export function runMiddlewares<State>(
+export function compileMiddlewares<State>(
   middlewares: MiddlewareFn<State>[],
-  ctx: Context<State>,
-): Promise<Response> {
-  let fn = ctx.next;
-  let i = middlewares.length;
-  while (i--) {
-    const local = fn;
-    const next = middlewares[i];
-    fn = async () => {
+  init: MiddlewareFn<State>,
+): MiddlewareFn<State> {
+  let fn: MiddlewareFn<State> = init;
+
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    const local = middlewares[i];
+    const next = fn;
+
+    fn = async (ctx) => {
       const internals = getInternals(ctx);
       const { app: prevApp, layouts: prevLayouts } = internals;
 
-      ctx.next = local;
+      ctx.next = async () => await next(ctx);
       try {
-        return await next(ctx);
+        return await local(ctx);
       } catch (err) {
         ctx.error = err;
         throw err;
@@ -106,5 +107,6 @@ export function runMiddlewares<State>(
       }
     };
   }
-  return fn();
+
+  return fn;
 }

src/middlewares/mod_test.ts

@@ -1,9 +1,13 @@
-import { runMiddlewares } from "./mod.ts";
+import { compileMiddlewares } from "./mod.ts";
 import { expect } from "@std/expect";
 import { serveMiddleware } from "../test_utils.ts";
 import type { MiddlewareFn } from "./mod.ts";
 
-Deno.test("runMiddleware", async () => {
+const THROWER = () => {
+  throw new Error("fail");
+};
+
+Deno.test("compileMiddlewares", async () => {
   const middlewares: MiddlewareFn<{ text: string }>[] = [
     (ctx) => {
       ctx.state.text = "A";
@@ -23,16 +27,17 @@ Deno.test("runMiddleware", async () => {
     },
   ];
 
-  const server = serveMiddleware<{ text: string }>((ctx) =>
-    runMiddlewares(middlewares, ctx)
+  const server = serveMiddleware<{ text: string }>(
+    compileMiddlewares(middlewares, THROWER),
   );
 
   const res = await server.get("/");
   expect(await res.text()).toEqual("AB");
 });
 
-Deno.test("runMiddleware - middlewares should only be called once", async () => {
-  const A: MiddlewareFn<{ count: number }> = (ctx) => {
+Deno.test("compileMiddlewares - middlewares should only be called once", async () => {
+  type State = { count: number };
+  const A: MiddlewareFn<State> = (ctx) => {
     if (ctx.state.count === undefined) {
       ctx.state.count = 0;
     } else {
@@ -41,11 +46,11 @@ Deno.test("runMiddleware - middlewares should only be called once", async () =>
     return ctx.next();
   };
 
-  const server = serveMiddleware<{ count: number }>((ctx) =>
-    runMiddlewares(
-      [A, (ctx) => new Response(String(ctx.state.count))],
-      ctx,
-    )
+  const final: MiddlewareFn<State> = (ctx) =>
+    new Response(String(ctx.state.count));
+
+  const server = serveMiddleware<{ count: number }>(
+    compileMiddlewares([A], final),
   );
 
   const res = await server.get("/");
@@ -55,7 +60,7 @@ Deno.test("runMiddleware - middlewares should only be called once", async () =>
 Deno.test("runMiddleware - runs multiple stacks", async () => {
   type State = { text: string };
   const A: MiddlewareFn<State> = (ctx) => {
-    ctx.state.text += "A";
+    ctx.state.text = "A";
     return ctx.next();
   };
   const B: MiddlewareFn<State> = (ctx) => {
@@ -71,19 +76,13 @@ Deno.test("runMiddleware - runs multiple stacks", async () => {
     return ctx.next();
   };
 
-  const server = serveMiddleware<State>((ctx) => {
-    ctx.state.text = "";
-    return runMiddlewares(
-      [
-        A,
-        B,
-        C,
-        D,
-        (ctx) => new Response(String(ctx.state.text)),
-      ],
-      ctx,
-    );
-  });
+  const final: MiddlewareFn<State> = (ctx) =>
+    new Response(String(ctx.state.text));
+
+  const server = serveMiddleware<State>(compileMiddlewares(
+    [A, B, C, D],
+    final,
+  ));
 
   const res = await server.get("/");
   expect(await res.text()).toEqual("ABCD");
@@ -119,13 +118,14 @@ Deno.test("runMiddleware - throws errors", async () => {
         throw err;
       }
     },
-    () => {
-      throw new Error("fail");
-    },
   ];
 
-  const server = serveMiddleware<{ text: string }>((ctx) =>
-    runMiddlewares(middlewares, ctx)
+  const final = () => {
+    throw new Error("fail");
+  };
+
+  const server = serveMiddleware<{ text: string }>(
+    compileMiddlewares(middlewares, final),
   );
 
   try {