Async.js

seq.js

  1. import reduce from './reduce.js'
  2. import wrapAsync from './internal/wrapAsync.js'
  3. import { promiseCallback, PROMISE_SYMBOL } from './internal/promiseCallback.js'
  5. /**
  6.  * Version of the compose function that is more natural to read. Each function
  7.  * consumes the return value of the previous function. It is the equivalent of
  8.  * [compose]{@link module:ControlFlow.compose} with the arguments reversed.
  9.  *
  10.  * Each function is executed with the `this` binding of the composed function.
  11.  *
  12.  * @name seq
  13.  * @static
  14.  * @memberOf module:ControlFlow
  15.  * @method
  16.  * @see [async.compose]{@link module:ControlFlow.compose}
  17.  * @category Control Flow
  18.  * @param {...AsyncFunction} functions - the asynchronous functions to compose
  19.  * @returns {Function} a function that composes the `functions` in order
  20.  * @example
  21.  *
  22.  * // Requires lodash (or underscore), express3 and dresende's orm2.
  23.  * // Part of an app, that fetches cats of the logged user.
  24.  * // This example uses `seq` function to avoid overnesting and error
  25.  * // handling clutter.
  26.  * app.get('/cats', function(request, response) {
  27.  *     var User = request.models.User;
  28.  *     async.seq(
  29.  *         User.get.bind(User),  // 'User.get' has signature (id, callback(err, data))
  30.  *         function(user, fn) {
  31.  *             user.getCats(fn);      // 'getCats' has signature (callback(err, data))
  32.  *         }
  33.  *     )(req.session.user_id, function (err, cats) {
  34.  *         if (err) {
  35.  *             console.error(err);
  36.  *             response.json({ status: 'error', message: err.message });
  37.  *         } else {
  38.  *             response.json({ status: 'ok', message: 'Cats found', data: cats });
  39.  *         }
  40.  *     });
  41.  * });
  42.  */
  43. export default function seq(...functions) {
  44.     var _functions = functions.map(wrapAsync);
  45.     return function (...args) {
  46.         var that = this;
  48.         var cb = args[args.length - 1];
  49.         if (typeof cb == 'function') {
  50.             args.pop();
  51.         } else {
  52.             cb = promiseCallback();
  53.         }
  55.         reduce(_functions, args, (newargs, fn, iterCb) => {
  56.             fn.apply(that, newargs.concat((err, ...nextargs) => {
  57.                 iterCb(err, nextargs);
  58.             }));
  59.         },
  60.         (err, results) => cb(err, ...results));
  62.         return cb[PROMISE_SYMBOL]
  63.     };
  64. }