Correctly type arguments to callback function, based on first argument array types

I have an issue in TypeScript.

Effectively I'm trying to achieve what useSWR do, in which you can pass an array of arguments as the first argument in a function, and in the second argument you send in a callback function where the array items become the arguments in the second callback.

Here is an example:

const fetcher = async(arg1: string, arg2: string): Promise<string | boolean> => {
    try {
        return arg1 + ' - ' + arg2
    } catch(e) {
        return false
    }
}

type Fetcher<T, A extends any[]> = (...args: A) => Promise<T>

const useAdminEndpoint = <T, A extends any[]>(key: A, fetcher: Fetcher<T, A>) => {
    const run = async() => {
        try {
            return await fetcher.apply(null,key)
        } catch(e) {
            return false
        }
    }
    return result
}

const result = useAdminEndpoint(['hello',2],(h,g) => fetcher(h,g))

The type on the parameters is just the type of the items in the array as a tuple, instead of say arg0 = array[0], arg1 = array[1] etc.

I'm not really sure on the terminology around what I'm trying to achieve here so it's hard to find what to search. Is it possible even to have the order of arguments infer their type from the items in the array in order?

The problem is that type of passed array of arguments is widened to some type. For example:

const arr = ['hello', 1];
// (string | number)[]
type Arr = typeof arr;

The same thing happens in your function. This can be fixed by doing const assertion, which prevents the compiler from widening the type, since with const assertion we define that the array won't change and it is readonly:

const arr = ['hello', 1] as const;
// readonly ["hello", 1]
type Arr = typeof arr;

In terms of the function using the const assertion is not that nice and it can be done elegantly since typescript 5.0, where const type parameters were added, which are doing basically const assertion. This allows to achieve the same result as with adding annoying as const on every function call:

type Fetcher<T, A extends readonly any[]> = (...args: A) => Promise<T>;

const useAdminEndpoint = <T,const A extends readonly any[]>(
  key: A,
  fetcher: Fetcher<T, A>,
) => {
  const run = async () => {
    try {
      return await fetcher(...key);
    } catch (e) {
      return false;
    }
  };
  return run();
};

Since const assertion and const type parameters would turn the array to readonly, we are updating the conditions as well (any[] -> readonly any[])

Testing:

const result = useAdminEndpoint(['hello', 'world'], (h, g) => fetcher(h, g));
const result2 = useAdminEndpoint(['hello', 2], (h, g) => fetcher(h, g)); // expected error. arg 2 should be a string

playground