This is the result of some prototyping with zeit/micro and creating type-safe handlers that progressively enhance the `req` variable via function composition

app.ts

import * as http from "http";

interface Handler<T extends http.IncomingMessage> {
  (req: T, res: http.ServerResponse): any;
}

type WithDB = {db: number};
function withPg<T extends http.IncomingMessage>(handler: Handler<T & WithDB>): Handler<T> {
  return (req, res) => {
    const newReq = req as T & WithDB;
    newReq.db = 5;
    return handler(newReq, res);
  };
}

type WithUser = {user: string};
function withUser<T extends http.IncomingMessage & WithDB>(
  handler: Handler<T & WithUser>
): Handler<T> {
  return (req, res) => {
    const newReq = req as T & WithUser;
    newReq.user = "Daniel " + req.db;
    return handler(newReq, res);
  };
}

function withLogger<T extends http.IncomingMessage>(
  handler: Handler<T & {log: (a: any) => void}>
): Handler<T> {
  return (req, res) => {
    const newReq = req as T & {log: (a: any) => void};
    newReq.log = a => console.log("[logger]", a);
    return handler(newReq, res);
  };
}

// note ts' type inference does not enforce "withUser" to be within "withPg" :(
const withLogHandler: Handler<http.IncomingMessage> = withPg(
  withUser(
    withLogger((req, res) => {
      req.log("bla");
      console.log("req.db", req.db);
      return {ok: true};
    })
  )
);

export default withLogHandler;