В серии Meteor.call() внутри друг друга первоначальный вызов возвращается рано

Question

Я создал Meteor.Method (назовем его fullFlow), который сам вызывает несколько методов Meteor. Моя цель состоит в том, чтобы последующие методы вызывались асинхронно, поскольку последующий метод требует, чтобы остаток предыдущего метода выполнял свою работу.

Проблема в том, что обратный вызов из fullFlow возвращается после первого метода в серии, которую он запускает, поскольку первый метод получает возвращаемое значение (а затем передает его следующему методу и т. Д.).

Это моя проблема: я хочу, чтобы метод fullFlow ожидал завершения последнего метода в серии и возвращал его значение для обратного вызова fullFlow.

Я предполагаю, что моя структура все неправильно, и именно поэтому это происходит. Я был бы признателен, если бы кто-нибудь мог мне помочь и либо исправить мой поток, либо объяснить, что мне не хватает, чтобы я мог это исправить!

Вот код:

Meteor.methods({
  step1(params) {
    // work with params
    return stuff
  },

  step2(params) {
    // work with params
    return stuff
  },

  step3(params3) {
    // work with params
    return stuff
  },

  fullFlow(params) {
    Meteor.call('step1', params, function (err, res) {
      if (err) {
        throw new Meteor.Error(err);
      } else {
        Meteor.call('step2', res, function (err, res) {
          if (err) {
            throw new Meteor.Error(err);
          } else {
            Meteor.call('step3', res, function (err, res) {
              if (err) {
                throw new Meteor.Error(err);
              } else {
                return res;
              }
            })
          }
        })
      }
    })
  }
})

function fullFlow() {
  Meteor.call('fullFlow', params, function (err, res) {
    if (err) {
      console.log(err)
    } else {
      console.log(res)
    }
  })
}

fullFlow();

Теперь происходит то, что когда обратный вызов step1 вызывается с res, он также вызывает основной обратный вызов fullFlow. Странная часть заключается в том, что оставшаяся часть метода fullFlow все еще продолжает выполняться и функционирует, как и ожидалось (т.е. он ожидает остатки предыдущего метода, прежде чем перейти к следующему, и передает его должным образом), но общий обратный вызов был запущен.

Моя проблема в том, что мне нужно, чтобы эта функция fullFlow работала постоянно. Моя цель состояла в том, чтобы подождать, пока не будет вызван обратный вызов функции, а затем внутри этого обратного вызова вызвать саму функцию, чтобы начать сначала. Это не будет работать должным образом, если обратный вызов вызывается до завершения полной серии методов. Также мне нужно, чтобы res из последнего метода, вызванного в серии, был возвращен в обратный вызов fullFlow!

Есть идеи?

Answer 1

И вот так я понял это.

Я обернул все в методе fullFlow в будущем. Итак, новый синтаксис:

var Future = Npm.require( 'fibers/future' );

fullFlow(params) {
  var future = new Future();

  Meteor.call('step1', params, function (err, res) {
    if (err) {
      throw new Meteor.Error(err);
    } else {
      Meteor.call('step2', res, function (err, res) {
        if (err) {
          throw new Meteor.Error(err);
        } else {
          Meteor.call('step3', res, function (err, res) {
            if (err) {
              throw new Meteor.Error(err);
            } else {
              return future.return(res);
            }
          })
        }
      })
    }
  })

  return future.wait();
}

Теперь все это не вызывает обратный вызов до тех пор, пока не будет выполнен последний метод, и он успешно возвращает последнее разрешение для обратного вызова fullFlow.

Это работает, но я все еще не уверен, является ли это хакерским способом решения плохой структуры. Я бы предпочел иметь правильную структуру. Если кто-то может исправить общую структуру, пожалуйста, скажите мне!