Transform all fulfilled functions in Typescript into promises with the correct parameter types

Question

Transform all fulfilled functions in Typescript into promises with the correct parameter types

Currently, I am diving into a codebase packed with numerous asynchronous API calls that include success options in their parameters. Here is a snippet:

declare function foo(_: { 
  success?: (_: string) => void, 
  fail?: () => void, 
}): void

declare function bar(_: { 
  success?: (_: string) => void, 
  fail?: () => void, 
  src?: string
}): void

declare function baz(_: {
 success?: (_: string) => void, 
 fail?: () => void, 
 expired: number 
}): void

declare function foobar(_: { 
  success?: (_: string) => void, 
  fail?: () => void, 
  token: string, 
  state: boolean 
}): void

My aim is to convert all these functions into promises using the following code:

interface Cont<R> {
  fail?: () => void
  success?: (_: R) => void
}

interface Suspendable<O> {
  (option: O): void
}

function suspend<R, O extends Cont<R>>(fn: Suspendable<O>) { 
  return async (opt: Omit<Omit<O, "success">, "fail">) => await new Promise<R>((resolve, _) => fn({
    ...opt,
    success: it => resolve(it),
    fail: ()=> resolve(undefined)
  }  as O )) // if any chance, I'd like to omit the `as O` but forgive it for now
}


(async () => {
  let _foo = await suspend(foo)({}) // good 
  let _bar = await suspend(bar)({}) // good
  let _baz = await suspend(baz)/* compile error here */ ({ expired: 100})
})()

Is there anything in TypeScript that I might have overlooked to assist me in capturing the true type of the O in the fn parameter? This way, I can properly constrain the parameters and eliminate compiler errors.

typescript promise generic-programming type-constraints

Answer 1

Answer №1

There are two possible approaches to consider here. The first option is to simplify by dropping one of the type parameters and inferring O to compute

R</code from it:</p>

<pre><code>function suspend<O extends Cont<any>>(fn: Suspendable<O>) {
  return async (opt: Omit<O, "success" | "fail">) =>
    await new Promise<Parameters<Exclude<O["success"], undefined>>[0]>(
      (resolve, _) => fn({
        ...opt,
        success: it => resolve(it),
        fail: () => resolve(undefined)
      } as O));
}

The calculation for R may appear complicated with

Parameters<Exclude<O["success"], undefined>>[0]

. However, this modification allows compilation without any errors:

(async () => {
  let _foo = await suspend(foo)({})
  let _bar = await suspend(bar)({})
  let _baz = await suspend(baz)({ expired: 2 })
})()

If you do not assert as O, an error related to O will arise due to potential mismatch in the properties success or fail:

declare function hmm(opt: {
  success?: (_: unknown) => void,
  fail?: () => string // narrower than specified in Cont<any>
}): void;
suspend(hmm);

This occurs because passing custom success and fail methods makes it uncertain that fn() behaves as intended. Therefore, asserting types is necessary.

The alternative is to preserve both type parameters and rely on the optional nature of success and fail methods:

function suspend2<O, R>(fn: Suspendable<O & Cont<R>>) {
  return async (opt: O) =>
    await new Promise<R>(
      (resolve, _) => fn({
        ...opt,
        success: (it: R) => resolve(it),
        fail: () => resolve(undefined)
      }));
}

Here, we deduce both `O` and `R` from the argument `fn` of type `Suspendable<O & Cont<R>>`. While the correct `R` is derived automatically, the full object type including `success` and `fail` remains for `O`.

Although no assertions like as O are needed, since the value passed conforms to O & Cont<R>.

The following still functions as expected:

(async () => {
  let _foo = await suspend2(foo)({})
  let _bar = await suspend2(bar)({})
  let _baz = await suspend2(baz)({ expired: 2 })
})()

However, only due to the absence of a necessity for fail or success properties in O.

Hopefully, one of these alternatives proves helpful to your situation; best of luck!

Playground Link to code

Answer 2

There are two possible approaches to consider here. The first option is to simplify by dropping one of the type parameters and inferring O to compute

R</code from it:</p>

<pre><code>function suspend<O extends Cont<any>>(fn: Suspendable<O>) {
  return async (opt: Omit<O, "success" | "fail">) =>
    await new Promise<Parameters<Exclude<O["success"], undefined>>[0]>(
      (resolve, _) => fn({
        ...opt,
        success: it => resolve(it),
        fail: () => resolve(undefined)
      } as O));
}

The calculation for R may appear complicated with

Parameters<Exclude<O["success"], undefined>>[0]

. However, this modification allows compilation without any errors:

(async () => {
  let _foo = await suspend(foo)({})
  let _bar = await suspend(bar)({})
  let _baz = await suspend(baz)({ expired: 2 })
})()

If you do not assert as O, an error related to O will arise due to potential mismatch in the properties success or fail:

declare function hmm(opt: {
  success?: (_: unknown) => void,
  fail?: () => string // narrower than specified in Cont<any>
}): void;
suspend(hmm);

This occurs because passing custom success and fail methods makes it uncertain that fn() behaves as intended. Therefore, asserting types is necessary.

The alternative is to preserve both type parameters and rely on the optional nature of success and fail methods:

function suspend2<O, R>(fn: Suspendable<O & Cont<R>>) {
  return async (opt: O) =>
    await new Promise<R>(
      (resolve, _) => fn({
        ...opt,
        success: (it: R) => resolve(it),
        fail: () => resolve(undefined)
      }));
}

Here, we deduce both `O` and `R` from the argument `fn` of type `Suspendable<O & Cont<R>>`. While the correct `R` is derived automatically, the full object type including `success` and `fail` remains for `O`.

Although no assertions like as O are needed, since the value passed conforms to O & Cont<R>.

The following still functions as expected:

(async () => {
  let _foo = await suspend2(foo)({})
  let _bar = await suspend2(bar)({})
  let _baz = await suspend2(baz)({ expired: 2 })
})()

However, only due to the absence of a necessity for fail or success properties in O.

Hopefully, one of these alternatives proves helpful to your situation; best of luck!

Playground Link to code

Transform all fulfilled functions in Typescript into promises with the correct parameter types

Answer №1

Similar questions

The Google Maps feature encountered an error (ReferenceError: google is not defined)

The Angular filter fails to remove elements from the list

Setting properties of objects using call signatures nested within other objects

Error message "The process is not defined during the Cypress in Angular with Cucumber process."

Is it Beneficial to Combine jQuery with TypeScript in Angular 7?

Unlocking the power of React using TypeScript for optimal event typing

Utilizing Foundation and jQuery in a Next.js web development project

The data type returned by a method is determined by the optional parameter specified in the

Exploring the differences: Async await, Promises, and Mapping

Intellisense capabilities within the Gruntfile.js

What is the method for dynamically selecting generics from a function in a union type using Typescript?

Does the JavaScript Amazon Cognito Identity SDK offer support for the Authorization Code Grant flow?

Exploring the benefits of thrift integration in Angular 2

Tips for altering promises within nested for loops?

Missing data list entries for next js server actions

Error encountered in Nest.js tests due to dependency injection issues between modules. The module 'src/foo/foo.module' cannot be located from 'bar/bar.service.spec.ts'

Using ts-loader with Webpack 2 will result in compatibility issues

Node.js: Crafting appropriate responses for errors in asynchronous operations or promises

Is there a way to specify object keys in alignment with a specific pattern that allows for a variety of different combinations

Refresh Ionic 2 Platform