Guide on creating proxy functions with parameter tuples for complex functions in TypeScript

Question

Guide on creating proxy functions with parameter tuples for complex functions in TypeScript

I am currently in the process of converting a JavaScript library to TypeScript and need to define proxy functions. These functions should be able to accept any type and number of parameters and pass them to the original function like so:

async function any(table: string, columns?: string[], conditions?: object): Promise<object[]>
async function any(table: string, conditions?: object): Promise<object[]>
async function any(queryFunction: object): Promise<object[]>

async function any(...params: any[]): Promise<object[]> {
    return Promise.resolve([])
}


async function one(table: string, columns?: string[], conditions?: object): Promise<object>
async function one(table: string, conditions?: object): Promise<object>
async function one(queryFunction: object): Promise<object>

async function one(...params: any[]): Promise<object> {
    return (await any(...params))[0]
}

However, when I try to compile using tsc, I get the error

A spread argument must either have a tuple type or be passed to a rest parameter.

.

The solutions I have come across for this issue do not quite fit my specific use case. I do not want to deal with all possible parameter variations within the body of the proxy function, as it would create significant overhead. I also do not want to use a ...param: any[] overloading definition in the first function, as I want the parameter variations to be strict.

Does anyone have a good idea on how to effectively solve this issue?

Thank you and best regards.

typescript

Answer 1

Answer №1

Function Overloads in TypeScript have limited functionality:

When using an overloaded function, you are restricted to calling it with a single known call signature. For example, you can call any("abc", ["def"]), any("abc", {c: 0}), or any({q: 1}), but you cannot call it with a union of possible parameters. Although this limitation has been acknowledged in microsoft/TypeScript#14107, it has not yet been addressed.
Implementing an overloaded function often involves widening the function parameters for simplicity, but this leads to the compiler losing track of the specific ways the function can be called. The compiler treats the parameters as type any[] within the function, making it impossible to call any(...params) since any() does not accept an argument list of type any[]. There is a suggestion to address this issue by tracking call signatures within the implementation on microsoft/TypeScript#22609, but this has not been implemented yet.

These limitations make it challenging to work with overloads the traditional way. If you still wish to use overloads, a type assertion can be used to suppress errors, although this does not enhance compilation safety:

async function one(...params: any[]): Promise<object> {
  return (await any(...params as [string]))[0]; // no error now
}

In scenarios where different call signatures may have different return types, a unified approach can be taken by using a single call signature that accepts a rest parameter of a union of tuples. This can be achieved as follows:

type MyParams =
  [table: string, columns?: string[], conditions?: object] |
  [table: string, conditions?: object] |
  [queryFunction: object]

async function any(...params: MyParams): Promise<object[]> {
  return Promise.resolve([])
}

async function one(...params: MyParams): Promise<object> {
  return (await any(...params))[0]
}

By defining the MyParams type to encompass the possible ways of calling any() and one(), the compiler can properly infer the type of params and allow error-free calls to the functions. This approach mimics the behavior of overloads but with improved type safety.

Playground link to code

Answer 2

Function Overloads in TypeScript have limited functionality:

When using an overloaded function, you are restricted to calling it with a single known call signature. For example, you can call any("abc", ["def"]), any("abc", {c: 0}), or any({q: 1}), but you cannot call it with a union of possible parameters. Although this limitation has been acknowledged in microsoft/TypeScript#14107, it has not yet been addressed.
Implementing an overloaded function often involves widening the function parameters for simplicity, but this leads to the compiler losing track of the specific ways the function can be called. The compiler treats the parameters as type any[] within the function, making it impossible to call any(...params) since any() does not accept an argument list of type any[]. There is a suggestion to address this issue by tracking call signatures within the implementation on microsoft/TypeScript#22609, but this has not been implemented yet.

These limitations make it challenging to work with overloads the traditional way. If you still wish to use overloads, a type assertion can be used to suppress errors, although this does not enhance compilation safety:

async function one(...params: any[]): Promise<object> {
  return (await any(...params as [string]))[0]; // no error now
}

In scenarios where different call signatures may have different return types, a unified approach can be taken by using a single call signature that accepts a rest parameter of a union of tuples. This can be achieved as follows:

type MyParams =
  [table: string, columns?: string[], conditions?: object] |
  [table: string, conditions?: object] |
  [queryFunction: object]

async function any(...params: MyParams): Promise<object[]> {
  return Promise.resolve([])
}

async function one(...params: MyParams): Promise<object> {
  return (await any(...params))[0]
}

By defining the MyParams type to encompass the possible ways of calling any() and one(), the compiler can properly infer the type of params and allow error-free calls to the functions. This approach mimics the behavior of overloads but with improved type safety.

Playground link to code

Guide on creating proxy functions with parameter tuples for complex functions in TypeScript

Answer №1

Similar questions

How to manually resolve a type by its string or name in Angular 2

Obtain precise measurements of a modified image using the Sharp library

Transform Dictionary JSON into Typescript model

What is the method for filtering out specific fields in a template string?

Using TypeScript to import npm modules that are scoped but do not have the scope name included

Using Angular 6 to Share Data Among Components through Services

Leverage the power of forkJoin in JavaScript by utilizing objects or sourcesObject

Is it possible for prettier to substitute var with let?

Guide on transforming a Unix timestamp into either "2000-01-01" or "2000-05-24 20:00:00" format, or the opposite way, using Deno

Request with missing authentication header in Swagger OpenAPI 3.0

What is the best way to display a loading screen while simultaneously making calls to multiple APIs?

Here are some steps to turn off browser autocomplete for a p-inputMask field

Guide to removing selected value from a combobox in Angular

TypeScript encounters difficulty in locating the namespace within a Node.js dependency

How to efficiently store and manage a many-to-many relationship in PostgreSQL with TypeORM

In React TS, the function Window.webkitRequestAnimationFrame is not supported

In order to make Angular function properly, it is crucial that I include app.get("*", [...]); in my server.js file

Fetching data from different interfaces with the same name in Angular

Stop the interval once the route is altered in Angular 2

Tips for toggling visibility in Angular 2