feat(http): middleware

http/middleware.ts

@@ -0,0 +1,54 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+/**
+ * Middleware handler based on {@linkcode Deno.ServeHandlerInfo} but an added
+ * `next()` function which calls the next middleware handler in the middleware
+ * chain.
+ */
+export type MiddlewareHandler = (
+  request: Request,
+  info: Deno.ServeHandlerInfo,
+  next: () => Response | Promise<Response>,
+) => Response | Promise<Response>;
+
+/**
+ * Creates a {@linkcode Deno.ServeHandler} from the given middleware chain,
+ * which can then be passed to {@linkcode Deno.serve}.
+ *
+ * @param middlewares Middleware chain
+ *
+ * @example
+ * ```ts
+ * import {
+ *   type MiddlewareHandler,
+ *   createHandler,
+ * } from "https://deno.land/std@$STD_VERSION/http/middleware.ts";
+ *
+ * const middleware1: MiddlewareHandler = async (_request, _info, next) => {
+ *   const start = performance.now();
+ *   const response = await next();
+ *   const duration = performance.now() - start;
+ *   response.headers.set("x-request-time", duration.toString());
+ *   return response;
+ * };
+ *
+ * const middleware2: MiddlewareHandler = (request, info) => {
+ *   return Response.json({ request, info });
+ * };
+ *
+ * const handler = createHandler([middleware1, middleware2])
+ * ```
+ */
+export function createHandler(
+  middlewares: MiddlewareHandler[],
+): Deno.ServeHandler {
+  return (request, info) => {
+    function compose(index: number): Response | Promise<Response> {
+      if (index >= middlewares.length) {
+        throw new RangeError("Middleware chain exhausted");
+      }
+      return middlewares[index](request, info, () => compose(index + 1));
+    }
+    return compose(0);
+  };
+}

http/middleware_test.ts

@@ -0,0 +1,55 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import { assertEquals, assertRejects } from "../assert/mod.ts";
+import { createHandler, type MiddlewareHandler } from "./middleware.ts";
+
+const info: Deno.ServeHandlerInfo = {
+  remoteAddr: { transport: "tcp", hostname: "foo", port: 200 },
+};
+
+Deno.test("createHandler() chains middlewares in order", async () => {
+  const order: number[] = [];
+
+  const middleware1: MiddlewareHandler = async (_request, _info, next) => {
+    const response = await next();
+    response.headers.set("X-Foo-1", "Bar-1");
+    order.push(1);
+    return response;
+  };
+
+  const middleware2: MiddlewareHandler = async (_request, _info, next) => {
+    const response = await next();
+    response.headers.set("X-Foo-2", "Bar-2");
+    order.push(2);
+    return response;
+  };
+
+  const finalMiddleware: MiddlewareHandler = () => {
+    order.push(3);
+    return new Response();
+  };
+
+  const handler = createHandler([middleware1, middleware2, finalMiddleware]);
+  const request = new Request("http://localhost");
+  const response = await handler(request, info);
+
+  assertEquals(response.status, 200);
+  assertEquals(response.headers.get("X-Foo-1"), "Bar-1");
+  assertEquals(response.headers.get("X-Foo-2"), "Bar-2");
+  assertEquals(order, [3, 2, 1]);
+});
+
+Deno.test("createHandler() throws when next() is called incorrectly", async () => {
+  const finalMiddleware: MiddlewareHandler = async (_request, _info, next) => {
+    await next();
+    return new Response();
+  };
+
+  const handler = createHandler([finalMiddleware]);
+  const request = new Request("http://localhost");
+  await assertRejects(
+    async () => await handler(request, info),
+    RangeError,
+    "Middleware chain exhausted",
+  );
+});

http/mod.ts

@@ -68,6 +68,7 @@ export * from "./etag.ts";
 export * from "./http_errors.ts";
 export * from "./http_status.ts";
 export * from "./method.ts";
+export * from "./middleware.ts";
 export * from "./negotiation.ts";
 export * from "./server.ts";
 export * from "./server_sent_event.ts";