Thanks for this package, but the one don't working with ReactJS (ReactMeteorData mixin).
For example:

React.createClass({
  mixins: [ReactMeteorData],
  getMeteorData() {
    return {
      count: ReactiveMethod.call('count')
    };
  },
  render() {
    return <div>{this.data.count}</div>;
  }
});

When we will try use this we will have an infinity loop. Fix it, please!

First, let's note that each return from the ReactiveMethod.call causes the function to be rerun.

i=1; Tracker.autorun( function(){ 
   console.log('run', i++);
   var c = ReactiveMethod.call("createCustomer", 2);
   if(c){
     console.log('c has value', c);
     var c2 = ReactiveMethod.call("createCustomerThing", c, {foo:'bar'});
     console.log(c2);
   }
})

This will print "run 1", "run 2", and "run 3", in general running a first time, then once for every method call. But it gets worse.. Because ReactiveMethod finds which value to return based on argument equality, if you run the following (note the new Date() in the args list for createCustomer)

i=1; Tracker.autorun( function(){ 
   console.log('run', i++);
   var c = ReactiveMethod.call("createCustomer", new Date());
   if(c){
     console.log('c has value', c);
     var c2 = ReactiveMethod.call("createCustomerThing", c, {foo:'bar'});
     console.log(c2);
   }
})

It will keep pinging the server forever, calling createCustomer with different arguments and never continuing on.
If there's a solution for this, I'd be interested.
If not, it would probably suffice to put a few caveats in the Readme to describe exactly what is going on with respect to rerunning the functions, because side-effecting calls and changing argument lists are definitely something to be avoided.

It would be useful to trigger ReactiveMethod to invalidate previously returned results and rerun.

Proposed API

Template.myTemplate.helpers({
  helperName: function (){
    return ReactiveMethod.call('methodName', 'a', 'b');
  }
})

//elsewhere
ReactiveMethod.invalidate('methodName', 'a', 'b');
//helperName reruns method and returns new result

Implementation

reactive-method.js

  ReactiveMethod = {
    call: ...
    apply: ...
    invalidate: function (/* arguments */){
      var cc = Tracker.currentComputation;
      //ensure computation existence, serialize args, etc...
      delete cc._reactiveMethodData[serializedArgs];
      cc.invalidate();
    }
  }

I am more than willing to implement this and create a PR. I believe this method could be called "invalidate" or "changed" or "rerun", did't know if you'd have any preferences or any other thoughts on implementing this API @stubailo

I implemented this library. It is working but the data only updates on template with browser refresh.

How I can make the data automatically update on client template without browser reload...

The only way the data updates on the template is with a full browser refresh. I was under the impression that when you use the word "reactive" it means that the helper will continue to stream a connection to the server side and keep any new data changes up to date on my template.

What am I doing wrong? Any help greatly appreciated.

I have like this

   // In router
    this.render('myTemplate', {
        data: function () {
            return ReactiveMethod.call("myMethod", "a", "b");;
    });

I've found myself making loads of template helpers that simply return the result of a reactive method. I was thinking of creating a global helper to accomplish this which could easily be added to the package itself.

Implementation

Template.registerHelper('ReactiveMethodCall', function (methodName){
    return ReactiveMethod.apply(methodName, _.rest(_.toArray(arguments)));
});

Template.registerHelper('ReactiveMethodApply', function (methodName, args){
    return ReactiveMethod.apply(methodName, args);
});

Use

<template name="mySuperCoolTemplate">
  {{ReactiveMethodCall 'mySuperCoolMethod' 'arg1' 'arg2'}}
</template>

I want to check ready or not, if server run for along time:

Template.foo.helpers({
   methodResult: function () {
           var result = ReactiveMethod.call("myMethod", "a", "b");
           if(result.ready()){
              return result; // this doesn't work!!!
           }else{
               return 'Loading...';
           }
       });
   } 
});

I find this package very useful. Thank you for it. Do you have an idea, how to fix running a helper multiple (four) times at every change of a Session variable, which stands in place of the argument of the ReactiveMethod?

For some reason my meteor methods are being called even if I dont update the params.

Look at this for example

HTML

 <tr>
        <td>
          Assets : {{money totalBalance.assets}}
        </td>
        <td>
          Liabilities : {{money totalBalance.liabilities}} =
        </td>
        <td>

        </td>
      </tr>

JS

totalBalance : function () {
    var result = ReactiveMethod.call("getBalance", 'a');
    return result || { assets : 0, liabilities : 0 };
  }

on the server I am seeing the following happen

I20150806-13:46:47.886(-4)? a <- Param
I20150806-13:46:48.233(-4)? test <- random consolelog
I20150806-13:46:48.233(-4)? a <-Param
I20150806-13:46:48.554(-4)? test <- random consolelog

Any Ideas?

My call to reactive method works reactively but it's returning the same result it returned the first time (right after undefined) even though the server returns changed value.

If I invalidate (ReactiveMethod.invalidateCall()) the call right after the main call (ReactiveMethod.call()), it ends up in infinite loop unless I check for returned value being not undefined, but the final result is the same - no updated value returned.

Not certain exactly why this is the case, but once a call is invalidated it removes the computation and is not able to be invalidated again.

Reproduction: https://github.com/ecwyne/reactive-method-issue-10

I have

// --------------Server
Meteor.methods({
   getData: function(){
      var data = Collection.Customer.find().fetch();
      return data;
   }
})

// ----------------Client
// Template
{{#each data}}
...............
{{/each}}

// Helper
data: function(){
   var data = ReativeMethod.calle('getData');
   return data;
}

Don't auto update, when I update collection.
Please help me.

On line 28, quoted below:

if (cc._reactiveMethodData && cc._reactiveMethodData[serializedArgs]) {

cc._reactiveMethodData[serializedArgs] should be _.has(cc._reactiveMethodData, serializedArgs) as in:

if (cc._reactiveMethodData && _.has(cc._reactiveMethodData, serializedArgs)) {

since the former is the value of the key, while the latter is checking for the presence of the key ... which is the condition I believe you were looking for. ;-)

Without this correction, I was getting infinite runs because the method I was calling returns booleans, and the if clause was not entered when the return value was false. Once I made the correction ... no more infinite runs.

Thanks for this package! It's just what I needed.

Could you show an example if you had to feed the output of one Meteor.call into another ?

I might be convinced to retire a different package I'm using you could support this.

@stubailo, The work I did earlier has been put into https://github.com/deanius/meteor-promise.
It has pretty full test coverage and as we discussed, is robust enough to handle the use cases of reactive method. If you've got any tasks to do let me know, otherwise, any time you want to deprecate this, let me know.

Hi I tried to call reactive-method with the new way of defining methods using mdg:validated-method however it returns undefined. How can I use this with the new way of defining methods?

Template.foo.helpers({
methodResult: function () {
return ReactiveMethod.call("myMethod", "a", "b"); // returns undefined but with reactiveMethod.call returns well
}
});

I get this in the browser console when trying to invoke a ReactiveMethod call. Any ideas?