客户端Meteor.call调用含内部调用的方法时未等待返回问题

Got it, let's break down why this is happening and how to fix it.

The core issue here is that your server-side stuff.someMethod isn't properly waiting for the asynchronous Meteor.call('otherstuff.someOtherMethod') to finish. Meteor methods run synchronously by default, but when you use the callback-style Meteor.call, it fires off the request and continues executing the rest of the method (or even exits entirely) before the callback runs. This means your client gets an early, incomplete response (or no response at all) instead of waiting for the nested method to resolve.

Here are two straightforward fixes to get the proper wait behavior:

Fix 1: Use Async/Await (Recommended for Clean Code) #

Meteor 2.0+ includes Meteor.callAsync, which returns a Promise that plays nicely with async/await. This makes your code readable and ensures the method waits for the nested call to finish. Update your server code like this:

// 服务端/api/stuff.js
Meteor.methods({
  async 'stuff.someMethod'(param1) {
    try {
      // Wait for the nested method to resolve before proceeding
      const res = await Meteor.callAsync('otherstuff.someOtherMethod', param1);
      
      // Add your post-response logic here
      return res; // Send the final result back to the client
    } catch (err) {
      // Catch errors from the nested method and rethrow as a Meteor Error
      throw new Meteor.Error(400, 'wrong things');
    }
  }
});

If you're on an older Meteor version (pre-2.0), you can manually wrap Meteor.call into a Promise:

// 服务端/api/stuff.js
const meteorCallPromise = (methodName, ...args) => {
  return new Promise((resolve, reject) => {
    Meteor.call(methodName, ...args, (err, res) => {
      err ? reject(err) : resolve(res);
    });
  });
};

Meteor.methods({
  async 'stuff.someMethod'(param1) {
    try {
      const res = await meteorCallPromise('otherstuff.someOtherMethod', param1);
      return res;
    } catch (err) {
      throw new Meteor.Error(400, 'wrong things');
    }
  }
});

Fix 2: Use Meteor.wrapAsync (Callback-Style Alternative) #

If you prefer sticking with callbacks, Meteor.wrapAsync converts async functions into synchronous ones, forcing the method to wait for the nested call:

// 服务端/api/stuff.js
Meteor.methods({
  'stuff.someMethod'(param1) {
    // Wrap Meteor.call into a synchronous function
    const syncNestedCall = Meteor.wrapAsync(Meteor.call);
    
    try {
      const res = syncNestedCall('otherstuff.someOtherMethod', param1);
      return res;
    } catch (err) {
      throw new Meteor.Error(400, 'wrong things');
    }
  }
});

Note on Your Client Code #

Your client-side code is already set up correctly! The callback you passed to Meteor.call('stuff.someMethod') will now receive the proper error or result once the server-side method finishes waiting for the nested call.

内容的提问来源于stack exchange，提问作者T. Rossi