Overload function return type with typescript

I am trying to build a generic "req" function that takes an URL path (string), and object (GET/POST params) as arguments, and returns the results with the appropriate type inferred.

This would be the interface from where my functions gets its type defs:

interface ValidQueries{
    books: (q: {
        limit?: number;
        category?: string;
    }) => Book[];

    authors: (q: {
        name?: string;
    }) => Author[];
}

And an attempt to write the function:

const req = <K extends keyof ValidQueries>(path: string, params: (Parameters<ValidQueries[K]>[0])) => {
    return useQuery([path, params], ({ queryKey }) => {
        const [, params] = queryKey;
        return httpRequest(path, params) as Promise<ReturnType<ValidQueries[K]>>;
    });
};

Example:

req("books", { limit: 10 }); -> return type should appear as Book[], and 2nd arg should appear as type of "q" from the matching function in the interface.

the params type definition does not appear to be correct. I wanted to take the type of the first param from the functions in my interface (q).

And the return type Promise<ValidQueries[K]> sort of works, but its not ideal because I see all possible types, like Book[] | Author[], instead of just Book[] if I pass "books" as first arg, or just Author[] if I pass "authors" as the first arg...

Most importantly, when you use generics you need to have some anchor, that TypeScript may infer from. In this function, you use path: string (so any string), and the only argument using generic K is params.

Because of that, when you call req("books", { limit: 10 }), to compute the generic K it will do something like Extract<ValidQueries[keyof ValidQueries], { limit: 10 }>. To fix that, you may use K for the path argument - path: K. That will help to find the proper method from ValidQueries.

It should also solve the problem with Book[] | Author[], unless the useQuery has incorrect types (then you may push your as … clause to the end, or type the function return type directly).

Additionally, you may use rest parameters like ...params: Parameters<…>, so it will allow passing any number of ValidQueries[K] arguments down. It will also add the q: name to the parameter in the IDE, that you expected.

Summing up, you have something like this:

interface ValidQueries {
  books: (q: { limit?: number, category?: string }) => Book[];
  authors: (q: { name?: string }) => Author[];
}

const req = <K extends keyof ValidQueries, T extends ValidQueries[K]>(path: K, ...params: Parameters<T>) => {
  return useQuery([ path, params ], ({ queryKey }) => {
    const [ , params ] = queryKey;
    return httpRequest(path, params) as Promise<ReturnType<T>>;
  });
};

It has a small adjustment though, that the T type is created here automatically, as an alias. You could use the full Parameters<ValidQueries[K]> form (and similarly for the return type).