WIP

Author: marvinhagemeister

src/middlewares/mod.ts

@@ -83,21 +83,22 @@ export type Middleware<State> = MiddlewareFn<State> | MiddlewareFn<State>[];
 
 export function compileMiddlewares<State>(
   middlewares: MiddlewareFn<State>[],
-  init: MiddlewareFn<State>,
 ): MiddlewareFn<State> {
-  let fn: MiddlewareFn<State> = init;
+  if (middlewares.length === 0) return (ctx) => ctx.next();
 
-  for (let i = middlewares.length - 1; i >= 0; i--) {
-    const local = middlewares[i];
-    const next = fn;
+  let fn: MiddlewareFn<State>;
+  let last: MiddlewareFn<State>;
 
+  for (let i = middlewares.length - 1; i >= 0; i--) {
     fn = async (ctx) => {
       const internals = getInternals(ctx);
       const { app: prevApp, layouts: prevLayouts } = internals;
 
-      ctx.next = async () => await next(ctx);
+      ctx.next = i < middlewares.length - 1
+        ? async () => await middlewares[i + 1](ctx)
+        : async () => await last(ctx);
       try {
-        return await local(ctx);
+        return await middlewares[i](ctx);
       } catch (err) {
         ctx.error = err;
         throw err;
@@ -108,5 +109,8 @@ export function compileMiddlewares<State>(
     };
   }
 
-  return fn;
+  return (ctx) => {
+    last = ctx.next;
+    return fn(ctx);
+  };
 }

src/middlewares/mod_test.ts

@@ -3,10 +3,6 @@ import { expect } from "@std/expect";
 import { serveMiddleware } from "../test_utils.ts";
 import type { MiddlewareFn } from "./mod.ts";
 
-const THROWER = () => {
-  throw new Error("fail");
-};
-
 Deno.test("compileMiddlewares", async () => {
   const middlewares: MiddlewareFn<{ text: string }>[] = [
     (ctx) => {
@@ -28,7 +24,7 @@ Deno.test("compileMiddlewares", async () => {
   ];
 
   const server = serveMiddleware<{ text: string }>(
-    compileMiddlewares(middlewares, THROWER),
+    compileMiddlewares(middlewares),
   );
 
   const res = await server.get("/");
@@ -50,7 +46,7 @@ Deno.test("compileMiddlewares - middlewares should only be called once", async (
     new Response(String(ctx.state.count));
 
   const server = serveMiddleware<{ count: number }>(
-    compileMiddlewares([A], final),
+    compileMiddlewares([A, final]),
   );
 
   const res = await server.get("/");
@@ -80,8 +76,7 @@ Deno.test("runMiddleware - runs multiple stacks", async () => {
     new Response(String(ctx.state.text));
 
   const server = serveMiddleware<State>(compileMiddlewares(
-    [A, B, C, D],
-    final,
+    [A, B, C, D, final],
   ));
 
   const res = await server.get("/");
@@ -118,14 +113,13 @@ Deno.test("runMiddleware - throws errors", async () => {
         throw err;
       }
     },
+    () => {
+      throw new Error("fail");
+    },
   ];
 
-  const final = () => {
-    throw new Error("fail");
-  };
-
   const server = serveMiddleware<{ text: string }>(
-    compileMiddlewares(middlewares, final),
+    compileMiddlewares(middlewares),
   );
 
   try {
@@ -137,3 +131,19 @@ Deno.test("runMiddleware - throws errors", async () => {
   expect(thrownB).toBeInstanceOf(Error);
   expect(thrownC).toBeInstanceOf(Error);
 });
+
+Deno.test("compileMiddlewares - calls last next", async () => {
+  const middlewares: MiddlewareFn<{ text: string }>[] = [
+    (ctx) => ctx.next(),
+  ];
+
+  const next = () => Promise.resolve(new Response("next"));
+
+  const server = serveMiddleware<{ text: string }>(
+    compileMiddlewares(middlewares),
+    { next },
+  );
+
+  const res = await server.get("/");
+  expect(await res.text()).toEqual("next");
+});

tests/partials_test.tsx

@@ -2593,6 +2593,7 @@ Deno.test({
 });
 
 Deno.test({
+  only: true,
   name: "partials - render 404 partial",
   fn: async () => {
     const app = testApp()

tests/test_utils.tsx

@@ -35,7 +35,7 @@ const browser = await launch({
       ? ["--no-sandbox"]
       : []),
   ],
-  headless: true,
+  headless: false,
 });
 
 export function getIsland(pathname: string) {