已发布集合的流星反应过滤

Question

I have two collections Issues & Simulations:

// Issues
{
  issueId: 1000, 
  appears: '2014-01-01',
  ...
}
// Simulations
{
  history: [50,200,30], 
  date: '2014-01-01',
  ..
}

How to re-actively publish issues that are not in single simulation.

Meteor.publish('issues', function () {
    var simulation = Simulations.findOne({}),
        history = lodash.pluck(simulation.history, 'issueId');
    return Issues.find({
        issueId: {$nin: history},
        appears: {$lte: simulation.date}
    }, {limit: 12});
});

When I make changes to simulation either date or push issueIds into Simulation history I want published data to change. I found some package publish with relations but I have trouble understanding how to use it and is it what I really need. https://atmospherejs.com/cottz/publish-with-relations

Answer 1

Your publish function will not run reactively with respect to parameters. What I mean by that is that once the cursor has been return by the publish function, changes to the record set returned by that query will be synchronised with the client, but changes to the query will not have any effect. So if you were to add another document to the Issues collection that matches the original query {issueId: {$nin: originalHistory}, appears: {$lte: originalSimulation.date}} it will be sent to the client, but if you make a change to the Simulations collection it will have no effect as the cursor has already been returned by the publish function.

One way of achieving what you are aiming for would be to subscribe to the publication within an autorun block, and pass reactive parameters which you can update as required. Keeping the subscription within an autorun block will not only make it rerun reactively, but it will automatically cancel old subscriptions so that you don't continually increase server load. Something like this:

server:

Meteor.publish('issues', function (simulation, history) {
    return Issues.find({
        issueId: {$nin: history},
        appears: {$lte: simulation.date}
    }, {limit: 12});
});

client:

Tracker.autorun(function() {
    var simulation = Simulations.findOne({}),
        history = lodash.pluck(simulation.history, 'issueId');
    Meteor.subscribe('issues', simulation, history);
});

Note that there ARE ways you can achieve this solely on the server, by observing changes and utilising the low-level publications API. More about how you could do this here . It's almost certainly more complicated to do things that way, but there could be a performance benefit depending on how much computational capacity you have available on client and server,

Answer 2

I've tried @richsilv approach but in the end I've ended up using https://atmospherejs.com/mrt/reactive-publish I don't know is it the right approach but since it automagically works it will do for now.

Meteor.reactivePublish('issues', function () {
    var simulation = Simulations.findOne({}, {reactive: true}),
        history = lodash.pluck(simulation.history, 'issueId');
    return Issues.find({
        issueId: {$nin: history},
        appears: {$lte: simulation.date}
    }, {limit: 12});
});

Answer 3

You can use the reactive-publish package (I am one of authors). It is a rewrite of the package mentioned by @slobodan.blazeski:

Meteor.publish('issues', function () {
    this.autorun(function (computation) {
        var simulation = Simulations.findOne({}, {fields: {history: 1, date: 1}}),
            history = lodash.pluck(simulation.history, 'issueId');
        return Issues.find({
            issueId: {$nin: history},
            appears: {$lte: simulation.date}
        }, {limit: 12});
    });
});

The important thing is that you limit the fields you are interested in the simulation document so that autorun does not unnecessarily rerun when some other fields change.