Designing a Minimal Middleware Pipeline for Task Handlers

type MiddlewareContext = Record<string, unknown>;
type NextFunction = () => Promise<void>;
type Middleware<C extends MiddlewareContext> = (ctx: C, next: NextFunction) => Promise<void>;
 
class MiddlewarePipeline<C extends MiddlewareContext> {
  private middlewares: Middleware<C>[] = [];
 
  use(middleware: Middleware<C>): void {
    this.middlewares.push(middleware);
  }
 
  async execute(context: C): Promise<void> {
    const run = async (index: number): Promise<void> => {
      if (index < this.middlewares.length) {
        const middleware = this.middlewares[index];
        await middleware(context, () => run(index + 1));
      }
    };
    await run(0);
  }
}
 
interface RequestContext extends MiddlewareContext {
  userId?: string;
  isAuthorized: boolean;
}
 
const pipeline = new MiddlewarePipeline<RequestContext>();
pipeline.use(async (ctx, next) => {
  ctx.userId = "user_42";
  await next();
});
pipeline.use(async (ctx, next) => {
  ctx.isAuthorized = ctx.userId !== undefined;
  await next();
});
await pipeline.execute({ isAuthorized: false });