async functions not being transpiled correctly with ts-node

[ORESoftware]

I filed this issue with TypeStrong

TypeStrong/ts-node#494

there's a video demonstrating the problem

here is the offending code:

const async = require('async');

async.series({
    one: async function(){
      let x = await 1;
      return x;
    },
    two: async function(){
      let x = await 2;
      return x;
    }
  },
  function(err, results){

    if(err){
      throw err;
    }

    console.log('results =>', results);
  });

who/what is to blame? thanks

[ORESoftware]

seems to be a TypeScript problem

[hargasinski]

Hi @ORESoftware, thanks for the question!

This is a transpilation issue, as we can only detect native async functions. If you're transpiling your code, you need to wrap your async functions with asyncify. See the AsyncFunction docs for more info.

[ORESoftware]

@hargasinski this is a problem - yes I see that it gets transpiled to this:

#!/usr/bin/env node
'use strict';
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [0, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var suman = require('suman');
var Test = suman.init(module, {
    forceParallel: true
}).Test;
var async = require('async');
var count = 0;
async.series({
    a: function XXXXX() {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4, 300];
                    case 1:
                        _a.sent();
                        return [2, 5];
                }
            });
        });
    }
}, function (err, results) {
    if (err) {
        throw err;
    }
    console.log('results => ', results);
});

can you please use Function.length? a.k.a XXXXX.length

if the length is

0 => assume async/await, or promises
1 => it's a callback, pass a callback
2 => throw an error

[aearly]

See last paragraph: http://caolan.github.io/async/global.html

This is a transpiler issue. If the generated function had fn[Symbol.toStringTag] = 'AsyncFunction' it would work, but that assumes non-transpiled Symbols. Most transpilers don't leave Symbols as-is.

You'll have to wrap the async functions in asyncify() if you're transpiling.