ts-promisify

TypeScript module to program sequentially in node.js

In javaScript/TypeScrip long running functions does not return the result directly but via a callback function.

The problem with that is we end up having a callback in a callback in a callback...

To deal with this problems latest ECMAScript specification define async/await, feature supported by typeScript, but you can only 'await' functions that return a Promise.

This module 'promisify' your async function so they can be called as if they where synchronous ( as if the result was directly returned ).

#Usage:

1
2import * as promisify from "promisify";
3
4/*
5Here is a asyncFunction that take a number in input 
6and return a string after 100ms
7*/
8
9let myAsync = function (input: number, 
10callback: (error: Error, output1: string, output2: string) => void): void {
11
12    setTimeout(() => {
13
14        if( input === 2 ){
15
16            callback( new Error("expected error"), null, null);
17
18        }else{
19
20            callback(null, "=>" + input.toString() + "<=", "useless");
21
22        }
23
24    }, 100);
25
26};
27
28
29/*
30Your have to be in an async function to use await
31Just wrap the part of your code where you want to program
32sequentially in an async closure
33*/
34(async () => {
35
36    for (let i of [1, 2, 3]) {
37
38
39        let [error, output] = await promisify.typed(myAsync)(i);
40
41        if (error) {
42
43            console.log(error.message);
44
45            continue;
46
47        }
48
49        console.log(output);
50
51    }
52
53})();

The output will be:

1=>1<=
2expected error
3=>3<=

The equivalent in a the traditional asynchronous paradigm would be:

1myAsync(1, function (error, output) {
2    if (error) {
3        console.log(error.message);
4    } else {
5        console.log(output);
6    }
7    myAsync(2, function (error, output) {
8        if (error) {
9            console.log(error.message);
10        } else {
11            console.log(output);
12        }
13        myAsync(3, function (error, output) {
14            if (error) {
15                console.log(error.message);
16            } else {
17                console.log(output);
18            }
19        });
20    });
21});

You can bound your async function to a specifics object. If your function is overloaded or not typed precisely enough use promisify.generic instead of promisify.typed.

See ./src/test/example.ts for detailed exemples.