typed-middleware.ts

type Middleware<In, Out> = <T extends In>(req: Request, res: Response, state: T) => Promise<T & Out>;

export const fooMiddleware: Middleware<{}, { foo: string }> = async (req, res, state) => {
  return { ...state, foo: "foo" };
};

export const barMiddleware: Middleware<{}, { bar: string }> = async (req, res, state) => {
  return { ...state, bar: "bar" };
};

export const foobarMiddleware: Middleware<{ foo: string; bar: string }, {}> = async (req, res, state) => {
  res.send(`hello ${state.foo} ${state.bar}`);
  return state;
};

const pipe = (...middlewares: Middleware<any, any>[]) => async (req: Request, res: Response) => {
  middlewares.reduce(
    async (statePromise, middleware) => await middleware(req, res, await statePromise),
    Promise.resolve({})
  );
};

// This is typesafe
app.get("/", async (req: Request, res: Response) => {
  await foobarMiddleware(req, res, await barMiddleware(req, res, await fooMiddleware(req, res, {})));
});

// This is not :(
app.get("/", pipe(fooMiddleware, barMiddleware, foobarMiddleware));