async functions not being transpiled correctly with ts-node

Created on 17 Dec 2017 · 4Comments · Source: caolan/async

I filed this issue with TypeStrong

https://github.com/TypeStrong/ts-node/issues/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

question

Source

ORESoftware

👍1

All 4 comments

seems to be a TypeScript problem

ORESoftware on 17 Dec 2017

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.

hargasinski on 17 Dec 2017

👍1

@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

ORESoftware on 17 Dec 2017

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.