middleware.ts

// basic middleware utility to wrap routes with middlewares
// inspired from https://github.com/oven-sh/bun/issues/17608

import type { BunRequest, Serve, Server } from "bun";

type Route<R extends string, Path extends R> = Serve.Routes<any, R>[Path];

export type RequestMiddleware<Path extends string> = (
	req: BunRequest<Path>,
	server: Server<any>,
	handler: Serve.Handler<BunRequest<Path>, any, any>,
) => Response | Promise<Response>;
export type ResponseMiddleware = (
	response: Response,
	request: Request,
	server: Server<any>,
) => Response | Promise<Response>;

export function withMiddlewares<R extends string, Path extends R>(
	routes: Serve.Routes<any, R>,
	middlewares: {
		beforeRequest: RequestMiddleware<Path>[];
		beforeResponse: ResponseMiddleware[];
	} = { beforeRequest: [], beforeResponse: [] },
	config: { corsEnabled?: boolean } = {},
): Serve.Routes<any, R> {
	function wrapRoute<R extends string, Path extends R>(
		value: Route<R, Path>,
		route: R,
	): Route<R, Path> {
		if (typeof value === "function") {
			return wrapRouteHandler(value) as Route<R, Path>;
		} else if (value instanceof Response) {
			return wrapRouteHandler(() => value) as Route<R, Path>;
		} else if (Object.getPrototypeOf(value) === Object.prototype) {
			// Value is an object with HTTP method properties
			const methods = Object.entries(value);
			if (config.corsEnabled) {
				methods.push(["OPTIONS", () => {}]); // declare the OPTIONS route. It will be processed by CORS middleware
			}
			return Object.fromEntries(
				methods.map(([method, val]) => [method, wrapRoute(val, method)]),
			) as Route<R, Path>;
		}
		throw new Error(
			`Unsupported route value type: ${typeof value} for route ${value}`,
		);
	}

	function wrapRouteHandler<Path extends string>(
		handler: Serve.Handler<BunRequest<Path>, any, any>,
	): Serve.Handler<BunRequest<Path>, any, any> {
		return async (req: BunRequest<Path>, server: Server<any>) => {
			for (const middleware of middlewares.beforeRequest) {
				const result = await middleware(
					req as BunRequest<any>,
					server,
					handler as Serve.Handler<BunRequest<any>, any, any>,
				);
				if (result instanceof Response) {
					return result;
				}
			}

			const response = await handler(req, server);

			let finalResponse = response;
			for (const middleware of middlewares.beforeResponse) {
				const result = await middleware(finalResponse, req, server);
				if (result instanceof Response) {
					finalResponse = result;
				}
			}
			return finalResponse;
		};
	}

	return Object.fromEntries(
		Object.entries(routes).map(([route, value]) => [
			route,
			wrapRoute(value, route as keyof R & string),
		]),
	) as Serve.Routes<any, R>;
}