返回dict键的Typescript类型推断基于提供的参数

Question

I have the following files:

types.ts

import * as Promise from 'bluebird';

export interface ApiSpec {
    [apiReq: string]: (...args: any[]) => {
        url: string;
        contentType?: string;
        query?: {
            [key: string]: any;
        };
        method?: string;
    };
}

export type ApiRequest = {
    [T in keyof ApiSpec]: (...args: any[]) => Promise<any>;
};

Api.ts

import {ApiSpec, ApiRequest} from './types';
import * as _ from 'lodash';

export default function createApi(apiSpec: ApiSpec, concurrent: boolean = false): ApiRequest {
    return _.mapValues(apiSpec, (fn, name) => {
        return function(...args) {
            const requestSpec = fn.apply(null, args);
            requestSpec.which = name;
            requestSpec.url = `http://localhost:8989/api${requestSpec.url}`;
            // request is a function doing the API request and returning a bluebird promise
            return request(requestSpec, concurrent);
        }
    });
}

main.ts

import createApi from './Api';

// usually defined in a separate file
const ApiSpec = {
    fetchData: (start: Date, end: Date) => {
        return {
            url: `/fetchData?start=${start}&end=${end}`
        };
    }
};
const Api = createApi(ApiSpec);

Api.fetchData(new Date(), new Date()).then(res => {
    // do something with result
})

Is it possible in typescript to have type completion for my Api variable? I would like to be able to know which functions are available in my API and most importantly the parameters of each API call without having to look at the file where the API spec is defined. However, just using [T in keyof ApiSpec] in the types cannot infer the exact keys of the API spec I'm passing to createApi . Is this somehow possible in typescript?

Note: I'm using version 2.3.4 and cannot update to the latest typescript version at the moment

Answer 1

You need to use a generic type parameter to capture the actual type passed in to createApi and map that in ApiRequest instead of the generic ApiSpec . ApiSpec can be used as the type constraint for the type parameter.

export interface ApiSpec {
    [apiReq: string]: (...args: any[]) => {
        url: string;
        contentType?: string;
        query?: {
            [key: string]: any;
        };
        method?: string;
    };
}

export type ApiRequest<T extends ApiSpec> = {
    [P in keyof T]: (...args: Parameters<T[P]>) => Promise<any>;
};



export default function createApi<T extends ApiSpec>(apiSpec: T, concurrent: boolean = false): ApiRequest<T> {
    return null!; // implementation 
}
// usually defined in a separate file
const ApiSpec = {
    fetchData: (start: Date, end: Date) => {
        return {
            url: `/fetchData?start=${start}&end=${end}`
        };
    }
};
const Api = createApi(ApiSpec);

Api.fetchData(new Date(), new Date()).then(res => {
    // do something with result
})

Note I also added the Parameters<T[P]> in order to preserve argument types in the resulting object.

Edit For the version of typescript you are using (2.3), we don't have conditional types or tuples in rest parameters, so there is no way to map the function parameters in a type safe way unfortunately. The best we can do is :

export type ApiRequest<T extends ApiSpec> = {
    [P in keyof T]: (...args: any[]) => Promise<any>;
};