How does a Meteor database mutator know if it's being called from a Meteor.method vs. normal code?

Question

If one does something on the client like

Foo.insert({blah : 1})

where Foo is a Meteor collection, this actually triggers a Meteor.method call as documented in the last paragraph of http://docs.meteor.com/#meteor_methods that executes code on both the client and the server.

However, let's say I define a method (on client and server) that does the same thing:

Meteor.methods({
  bar: function() { 
    Foo.insert({blah : 1}) 
  }
});

Now, I trigger this on the client with

Meteor.call("bar");

Foo.insert will now be called both on the client and the server as a result of the method. However, how does the client-side invocation of insert know not to call the server again, since it is itself a method?

Moreover, is there a way to call insert on the client side without automatically triggering the canonical server-side latency-compensation call and resulting synchronization? (For why I'd want to do this, see Loading a Meteor client app with fake fire-and-forget data)

Answer 1

The client side one becomes a 'stub'. It has this isSimulation property set that makes it appear as if the data is inserted for latency compensation.

I think if a .method is run on the client the latency compensation is always enabled and it shouldn't enter in the database. So anything running on a client side method would be a 'fake' type simulation

If you try setting this.isSimulation to false you'll get some weird error that shows you that the client side insert starts to throw errors with the insert.

I'm not too sure how to run it in a false simulation. I think you'd have to run it off in some other method var dothis = function() {...} type method.

To do this 'fake fire' & forget and have client side only data, which is what I presume (please correct if I'm wrong so I change the answer) modify the _collection property in your client side method.

e.g if you have

mydata = new Meteor.Collection("something");

function something() {
    mydata.insert({..});
}

Modify the method to do this instead

mydata._collection.insert({..});

This will make sure that the data isn't synchronized to the server, yet will have the local collection have this 'fake data'.

Hope this helps!