CODEWITHSUNDEEP
meteorasync-await
T. Rossi
T. Rossi

Reputation: 483

Meteor.call in client doesn't wait when the called method has another call inside

I am following what I've read around being the standard way to use Meteor.call but it's behaving strangely in this scenario:

Client:

Template.sometemplate.events({
    'submit .somebutton'(event){
         ...
         Meteor.call('stuff.someMethod', param1, function (err, res){
              console.log(err);
              console.log(res);
         };
    }
})

Server /api/stuff.js:

Meteor.methods({
    'stuff.someMethod'(param1){
         ...
         Meteor.call('otherstuff.someOtherMethod', param1, function(err, res){
                  if(err){ throw new Meteor.Error(400,'wrong things');}
                  if(res) { return 'ok';}
             }
         );
    }
})

Server /api/otherstuff.js:

Meteor.methods({
    'otherstuff.someOtherMethod'(param1){
         ...
         return OtherStuff.findOne(query);
    }
})

On the client side I click and immediately see the console.log for both err and res as undefined. Whereas in other parts of the application when the client calls a server method, which is not calling another method, the client waits for the answer before executing the asynch callback.

There must be something wrong in how I use the Meteor.call inside a server method calling another server method. The scenario is that for instance I want to insert a document and while doing so I want to check some values in order to link it to other documents from other collections.

Thank you very much, T.

Upvotes: 0

Views: 1480

Answers (1)

Jankapunkt
Jankapunkt

Reputation: 8423

Sync call on the server

Using Meteor.call on the server does not require a callback, unless you really want to work async on the server side.

If you do not pass a callback on the server, the method invocation will block until the method is complete. It will eventually return the return value of the method, or it will throw an exception if the method threw an exception. (Possibly mapped to 500 Server Error if the exception happened remotely and it was not a Meteor.Error exception.)

Instead of passing a callback you would either return the result

return Meteor.call(...)

or assign it to a variable that is used for further processing.

const retVal = Meteor.call(...)


Better way: Externalize shared code

If two meteor methods rely on the same code (e.g. one is calling the other) you should extract this code into a shared function. This makes testing and tracing errors also easier.

server/api/common.js

export const sharedFunction = function(param1) {
    // ... do somethin
    return OtherStuff.findOne(query); 
}

server/api/stuff.js:

import { sharedFunction } from './common.js';

Meteor.methods({
    'stuff.someMethod'(param1){
         // ...
         const temp = sharedFunction(param1);
         // ...
         return result; // or temp if this should be returned to client
    }
})

server/api/otherstuff.js

import { sharedFunction } from './common.js';

Meteor.methods({
    'otherstuff.someOtherMethod'(param1){
         return sharedFunction(param1);
    }
});

Using the sharedFunction follows the concepts of DRY and Single Point of Failure.

Upvotes: 3

Related Questions