Can Compose infer types correctly if the innermost function is generic

[michael-wolfenden]

I'm trying to develop a middleware layer for my lambda application. The idea is that I can compose all the middleware together and apply then to my final handler.

import { F } from "ts-toolbelt";
declare const compose: F.Compose;

interface APIGatewayProxyEventV2 {
  body: string;
}

interface Context {
  awsRequestId: string;
}

type APIGatewayProxyResultV2<T = never> = string | T;

type Lambda<TResult = any> = (
  event: APIGatewayProxyEventV2,
  context: Context
) => Promise<APIGatewayProxyResultV2<TResult>>;

const firstMiddleware =
  <TResult>() =>
  (handler: Lambda<TResult>): Lambda<TResult> =>
  async (event, context) => {
    console.log("firstMiddleware");
    return await handler(event, context);
  };

const secondMiddleware =
  <TResult>() =>
  (handler: Lambda<TResult>): Lambda<TResult> =>
  async (event, context) => {
    console.log("secondMiddleware");
    return await handler(event, context);
  };

const applyMiddleware = compose(firstMiddleware(), secondMiddleware());

The issue if when I apply the middleware to my handler which has closed over the TResult type, I lose the TResult type.

const handler: Lambda<string> = (event, context) => Promise.resolve("result");

// wrappedHandler is typed as: const wrappedHandler: Lambda<unknown>, not Lambda<string>
const wrappedHandler = applyMiddleware(handler);

Is what I'm trying to achieve possible, or is this a limitation of typescript