Mapped Types Not Inferring From Promise Correctly

export const UploadThingServerHelper = <TValidRoutes>(
    input: {
        readonly [K in keyof TValidRoutes]: UploadableInputParams<TValidRoutes[K]>;
    },
    config?: { callbackUrl?: string },
) => {    
};

export const UploadThingServerHelper = <TValidRoutes>(
    input: {
        readonly [K in keyof TValidRoutes]: UploadableInputParams<TValidRoutes[K]>;
    },
    config?: { callbackUrl?: string },
) => {    
};

input: {
        readonly [K in keyof TValidRoutes]: UploadableInputParams<TValidRoutes[K]['middleware']>;
    },

input: {
        readonly [K in keyof TValidRoutes]: UploadableInputParams<TValidRoutes[K]['middleware']>;
    },

export const FileRouter = UploadThingServerHelper({
  someKey: {
    middleware: async (req) => {
      const user = await auth(req);

      if (!user.userId) throw new Error("someProperty is required");

      return { userIds: user.userId };
    },
    onUpload: async (request) => {
      console.log("uploaded with the following metadata:", request.metadata); // INFERENCE IS BROKEN HERE THAT IS ALL I CARE ABOUT
    },
  },
});

export const FileRouter = UploadThingServerHelper({
  someKey: {
    middleware: async (req) => {
      const user = await auth(req);

      if (!user.userId) throw new Error("someProperty is required");

      return { userIds: user.userId };
    },
    onUpload: async (request) => {
      console.log("uploaded with the following metadata:", request.metadata); // INFERENCE IS BROKEN HERE THAT IS ALL I CARE ABOUT
    },
  },
});

// some/route/route.ts
import FileRouter from "./filerouter"
export const { POST } = FileRouter;

// some/route/route.ts
import FileRouter from "./filerouter"
export const { POST } = FileRouter;

export const UploadThingServerHelper = <TValidRoutes, TMiddlewareResponse>(
    input: {
        readonly [K in keyof TValidRoutes]: {
            middleware: (request: Request) => Promise<TMiddlewareResponse>
            onUpload: (response: { metadata: TMiddlewareResponse }) => void
        }
    },
    config?: { callbackUrl?: string }
) => {...businessLogic}

export const UploadThingServerHelper = <TValidRoutes, TMiddlewareResponse>(
    input: {
        readonly [K in keyof TValidRoutes]: {
            middleware: (request: Request) => Promise<TMiddlewareResponse>
            onUpload: (response: { metadata: TMiddlewareResponse }) => void
        }
    },
    config?: { callbackUrl?: string }
) => {...businessLogic}

    middleware: async (req) => {
            return { some: 'metadata' };
        },
        onUpload: async (request) => {
            request.
        },

    middleware: async (req) => {
            return { some: 'metadata' };
        },
        onUpload: async (request) => {
            request.
        },

function createUploadableInputParams<TMiddlewareResponse>(
  middleware: (request: Request) => Promise<TMiddlewareResponse>,
  onUpload: (response: { metadata: TMiddlewareResponse }) => void
): UploadableInputParams<TMiddlewareResponse> {
  return { middleware, onUpload };
}

function createUploadableInputParams<TMiddlewareResponse>(
  middleware: (request: Request) => Promise<TMiddlewareResponse>,
  onUpload: (response: { metadata: TMiddlewareResponse }) => void
): UploadableInputParams<TMiddlewareResponse> {
  return { middleware, onUpload };
}

export const FileRouter = UploadThingServerHelper({
  someKey: f
    .middleware(async (req) => {
      const user = await auth(req);

      if (!user.userId) throw new Error("someProperty is required");

      return { userIds: user.userId };
    })
    .onUpload(async (request) => {
      console.log("uploaded with the following metadata:", request.metadata); // THIS SHOULD INFER THE TYPE FROM THE RETURN
    })
  },
});

export const FileRouter = UploadThingServerHelper({
  someKey: f
    .middleware(async (req) => {
      const user = await auth(req);

      if (!user.userId) throw new Error("someProperty is required");

      return { userIds: user.userId };
    })
    .onUpload(async (request) => {
      console.log("uploaded with the following metadata:", request.metadata); // THIS SHOULD INFER THE TYPE FROM THE RETURN
    })
  },
});

// Package

type UploadedFile = unknown;
type AnyUploadableInputParams<T = any> = {
  middleware(request: Request): T
  onUpload(response: {
    metadata: T;
    file: UploadedFile;
  }): void;
};

function identityFn<TMiddlewareResponse>(
  middleware: (request: Request) => Promise<TMiddlewareResponse>,
  onUpload: (response: { metadata: TMiddlewareResponse }) => void
): AnyUploadableInputParams {
  return { 
    middleware, 
    onUpload 
  };
}

export declare function UploadThingServerHelper<TValidRoutes extends Record<string, AnyUploadableInputParams>>(
  input: TValidRoutes,
  config?: { callbackUrl?: string }
): void;

// Example

declare function auth(request: Request): { userId: number };

export const FileRouter = UploadThingServerHelper({
  someKey: identityFn(
    async (request) => {
      const user = await auth(request);

      if (!user.userId) throw new Error("someProperty is required");

      return { userIds: user.userId };
    },
    async (request) => {
      console.log("uploaded with the following metadata:", request.metadata);
      //                                                            ^?
    },
  ),
});

// Package

type UploadedFile = unknown;
type AnyUploadableInputParams<T = any> = {
  middleware(request: Request): T
  onUpload(response: {
    metadata: T;
    file: UploadedFile;
  }): void;
};

function identityFn<TMiddlewareResponse>(
  middleware: (request: Request) => Promise<TMiddlewareResponse>,
  onUpload: (response: { metadata: TMiddlewareResponse }) => void
): AnyUploadableInputParams {
  return { 
    middleware, 
    onUpload 
  };
}

export declare function UploadThingServerHelper<TValidRoutes extends Record<string, AnyUploadableInputParams>>(
  input: TValidRoutes,
  config?: { callbackUrl?: string }
): void;

// Example

declare function auth(request: Request): { userId: number };

export const FileRouter = UploadThingServerHelper({
  someKey: identityFn(
    async (request) => {
      const user = await auth(request);

      if (!user.userId) throw new Error("someProperty is required");

      return { userIds: user.userId };
    },
    async (request) => {
      console.log("uploaded with the following metadata:", request.metadata);
      //                                                            ^?
    },
  ),
});

type AllowedFiles = "image" | "video" | "audio" | "blob";

type SizeUnit = "B" | "KB" | "MB" | "GB";
type FileSize = `${number}${SizeUnit}`;

type MiddlewareFn = (req: Request) => MaybePromise<unknown>;

export interface UploadBuilderDef<TParams extends AnyParams> {
  metadata: Record<string, any>;
  middleware: MiddlewareFn;
  fileTypes: AllowedFiles[];
  maxSize: FileSize;
}

export interface Uploader<TParams extends AnyParams> {
  _def: TParams & UploadBuilderDef<TParams>;
}

export type FileRouter = Record<string, Uploader<any>>;

export type CreateProcedureResult<
  TPrev extends AnyParams,
  TNext extends AnyParams
> = UploadBuilder<{
  _metadata: Overwrite<TPrev["_metadata"], TNext["_metadata"]>;
}>;

export interface UploadBuilder<TParams extends AnyParams> {
  mimeTypes: (mimes: string[]) => UploadBuilder<TParams>;
  maxSize: (size: FileSize) => UploadBuilder<TParams>;
  middleware: <TOutput extends object>(
    fn: (req: Request) => MaybePromise<TOutput>
  ) => CreateProcedureResult<TParams, { _metadata: TOutput }>;
  onUpload: (
    fn: (opts: { metadata: TParams["_metadata"]; file: UploadedFile }) => void
  ) => Uploader<TParams>;
}

type AllowedFiles = "image" | "video" | "audio" | "blob";

type SizeUnit = "B" | "KB" | "MB" | "GB";
type FileSize = `${number}${SizeUnit}`;

type MiddlewareFn = (req: Request) => MaybePromise<unknown>;

export interface UploadBuilderDef<TParams extends AnyParams> {
  metadata: Record<string, any>;
  middleware: MiddlewareFn;
  fileTypes: AllowedFiles[];
  maxSize: FileSize;
}

export interface Uploader<TParams extends AnyParams> {
  _def: TParams & UploadBuilderDef<TParams>;
}

export type FileRouter = Record<string, Uploader<any>>;

export type CreateProcedureResult<
  TPrev extends AnyParams,
  TNext extends AnyParams
> = UploadBuilder<{
  _metadata: Overwrite<TPrev["_metadata"], TNext["_metadata"]>;
}>;

export interface UploadBuilder<TParams extends AnyParams> {
  mimeTypes: (mimes: string[]) => UploadBuilder<TParams>;
  maxSize: (size: FileSize) => UploadBuilder<TParams>;
  middleware: <TOutput extends object>(
    fn: (req: Request) => MaybePromise<TOutput>
  ) => CreateProcedureResult<TParams, { _metadata: TOutput }>;
  onUpload: (
    fn: (opts: { metadata: TParams["_metadata"]; file: UploadedFile }) => void
  ) => Uploader<TParams>;
}

type SizeUnit = "B" | "KB" | "MB" | "GB";
type FileSize = `${number}${SizeUnit}`;

type SizeUnit = "B" | "KB" | "MB" | "GB";
type FileSize = `${number}${SizeUnit}`;

type FileSize = `${1 | 2}${SizeUnit}`;

type FileSize = `${1 | 2}${SizeUnit}`;

type OneThroughNine = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
type Limit = `${OneThroughNine}${OneThroughNine}`

const x: Limit = ``

type OneThroughNine = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
type Limit = `${OneThroughNine}${OneThroughNine}`

const x: Limit = ``

declare function auth(request: Request): { userId: number };

type Config<T> = {
  middleware(request: Request): Promise<T>
  onUpload(response: {
    metadata: T;
    file: any;
  }): void;
};

export declare function Helper<T extends Record<string, unknown>>(
  input: { [K in keyof T]: Config<T[K]> },
): void;

export const SomeFunc = Helper({
  someKey: {
    middleware: async (request: Request) => { // <------ YOU HAVE TO ANNOTATE REQUEST
      const user = await auth(request); 

      return { userIds: user.userId };
    },
    onUpload: async (response) => {
      console.log(response.metadata);
      //                  ^?

    },
  }
});

declare function auth(request: Request): { userId: number };

type Config<T> = {
  middleware(request: Request): Promise<T>
  onUpload(response: {
    metadata: T;
    file: any;
  }): void;
};

export declare function Helper<T extends Record<string, unknown>>(
  input: { [K in keyof T]: Config<T[K]> },
): void;

export const SomeFunc = Helper({
  someKey: {
    middleware: async (request: Request) => { // <------ YOU HAVE TO ANNOTATE REQUEST
      const user = await auth(request); 

      return { userIds: user.userId };
    },
    onUpload: async (response) => {
      console.log(response.metadata);
      //                  ^?

    },
  }
});