Typescript - wrapping functions while preserving signatures

Question

I'm trying to figure out how to wrap defined functions so I can do additional work while preserving their signatures. Here's the desired effect:

Programmer defines interface:

const actions = {
    first: (id: number) => {/*...*/},
    second: (name: string) => {/*...*/}
}
let actionsInterface = wrap(actions)
export actionsInterface

actionsInterface should (i.e. that's the goal) have the following interface:

{
    first: (id: number) => void,
    second: (name: string) => void
}

It basically provides the same exact interface (i.e. same list of functions, with same parameters, not counting the return type) as it was first defined, but there is additional work that is being done, that was injected by the wrap().

My current implementation is something like:

type VarFn = (...args: any) => any

function wrap<T, K extends keyof T>
(funcList: Record<K, T[K] extends VarFn ? T[K] : never>) {

    // this maps a specific function to a function that does something extra
    function wrapOne<T extends (...args: any)=>any>(fn: T) {
        return (...args: Parameters<typeof fn>) => {
            someMagicThingyExtra(fn(args))
        }
    }

    // we iterate through the list and map each function to the one that's doing something extra
    type FuncMap = Record<K, (...args: Parameters<T[K] extends VarFn ? T[K] : never>)=>void>
    let map: FuncMap
    for (var Key in funcList) {
        let func = funcList[Key]
        map[Key] = wrapOne(func)
    }
    return map
}

However, I get a following error on wrap(actions):

Argument of type '{ first: (id: number) => void; second: (name: string) => void; }' is not assignable to parameter of type 'Record<"first" | "second", never>'.
  Types of property 'first' are incompatible.
    Type '(id: number) => void' is not assignable to type 'never'.

So, for some reason, it didn't match (id: number) => void with (...args: any) => any, so it infered never.

So I tried a bit different thing:

function wrap2<T, K extends keyof T, U extends VarFn>
(funcList: Record<K, U>) {

    function wrapOne<T extends (...args: any)=>any>(fn: T) {
        return (...args: Parameters<typeof fn>) => {
            someMagicThingyExtra(fn(args))
        }
    }

    type FuncMap = Record<K, (...args: Parameters<U>)=>void>
    let map: FuncMap
    for (var Key in funcList) {
        let func = funcList[Key]
        map[Key] = wrapOne(func)
    }
    return map
}

No errors, but my return type of wrap2(actions) is:

{
    first: (...args: any) => void
    second: (...args: any) => void
}

...and I lost types of parameters, which defeats the whole purpose of trying to wrap the functionality, but preserving signatures (i.e. parameters' types).

Any help or guidance is welcome. Thanks!

EDIT:

Dragomir provided answer that completely preserves signature (both parameters' types and return types). My use case further needed to alter the return type to void and this is how I achieved it:

function wrap<T extends Record<keyof T, (...args: any)=>any>>(funcList: T) {

    // this maps a specific function to a function that does something extra
    function wrapOne<T extends (...args: any) => any>(fn: T) {
        return ((...args: Parameters<typeof fn>): void => {
            someMagicThingyExtra(fn(args))
        })
    }

    // we iterate through the list and map each function to the one that's doing something extra
    type WrapMap = {
        [K in keyof T]: (...args: Parameters<T[K]>)=>void
    }
    let map: WrapMap
    for (var Key in map) {
        map[Key] = wrapOne(funcList[Key])
    }
    return map
}

Titian Cernicova-Dragomir · Accepted Answer · 2019-12-06 12:03:22Z

3

You generic type T should have a constraint that all it's members are of type VarFn which you can easily so using T extends Record<keyof T, VarFn>. Since the returned type is exactly the same as the input type map can just be of type T.

type VarFn = (...args: any) => any

function wrap<T extends Record<keyof T, VarFn>>(funcList: T) {

  // this maps a specific function to a function that does something extra
  function wrapOne<T extends (...args: any) => any>(fn: T): T {
    return ((...args: Parameters<typeof fn>) => {
      return someMagicThingyExtra(fn(args))
    }) as T
  }

  // we iterate through the list and map each function to the one that's doing something extra
  let map = {} as T
  for (var Key in funcList) {
    let func = funcList[Key]
    map[Key] = wrapOne(func)
  }
  return map
}

const actions = {
  first: (id: number) => {/*...*/ },
  second: (name: string) => {/*...*/ }
}
let actionsInterface = wrap(actions)

Playground Link

answered Dec 6, 2019 at 12:03

Titian Cernicova-Dragomir

253k37 gold badges466 silver badges396 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Dragan Okanovic Over a year ago

I am impressed that if manages to infer the correct type of functions instead of leaving them as VarFn. I guess extending entire Record instead of only its value part does the trick. This does manage to solve my problem. Once more thing, my returned functions should return void once wrapped. How that can be done? Thanks.

Dragan Okanovic Over a year ago

I've managed to succeed with changing the return type to void. Edited question to include it as well, and it was based on your answer. Thanks!

trusktr · Accepted Answer · 2022-03-04 02:37:17Z

1

This is the first thing I landed on. It keeps even the generics of the wrapped function:

const newFunction = ((one, two) => {
    const result = oldFunction(one, two)
    // ...
    return result
}) as typeof oldFunction

answered Mar 4, 2022 at 2:37

trusktr

46k58 gold badges215 silver badges289 bronze badges

Comments

phil294 · Accepted Answer · 2024-09-28 09:53:19Z

0

If you want to wrap a function preserving the individual param types, you can like so:

const wrap = <Args extends any[], ReturnType>(fun: (...args: Args) => ReturnType) =>
    (...args: Args) =>
        fun(...args)

// Example:
const expectsCallback = (cb: (arg1: string, arg2: number) => boolean) => 0
expectsCallback(
    wrap(
        // Correctly typed here
        (a1, a2) => true
    )
)

answered Sep 28, 2024 at 9:53

phil294

11.1k8 gold badges74 silver badges113 bronze badges

Collectives™ on Stack Overflow

Typescript - wrapping functions while preserving signatures

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related