Sto trasformando la mia collezione Meteor in una classe che ho creato:

People = new Mongo.Collection('people', {
  transform: function(doc) {
    return new Person(doc);
  }
});

La persona ha molti metodi, alcuni dei quali controllano il recupero dei dati:

var john = People.findOne({ name: 'John' });
john.getFullName();

Ho anche alcuni dati che non sono necessari più spesso:

john.getAddress();

Per evitare di iscriverti ai dati che non sono necessari, ho l'abbonamento people che restituisce solo i dati di riepilogo:

Meteor.publish('people', function() {
  return People.find({}, { fields: { firstName: 1, lastName: 1, email: 1 } });
});

Mentre i dati dell'indirizzo vengono sottoscritti tramite la pubblicazione people_addresses .

La mia domanda riguardante gli abbonamenti granulari in questo formato è: dove dovrebbe essere gestita la sottoscrizione?

Opzione 1: callback

Imposta il metodo getAddress per iscriverti ai dati se non lo abbiamo già:

People.prototype.getAddress = function(callback, fail) {
  var that = this;

  if (this._address) {
    callback(this._address);
  } else {
    Meteor.subscribe('people_addresses', this.getName(), function() {
      /*
       * Need to either update the current object to reflect the data
       * or make the class reactive somehow... any ideas?
       */ 

      callback(that._address);
    });
  }
};

Utilizza il metodo con un callback per accedere ai dati:

john.getAddress(function(address) {
  /* Use Johns address data. */ 
});

Opzione 2: Preparazione dei dati

Qui ci troveremmo in un posto dove sappiamo che avremo bisogno dei dati dell'indirizzo.

Meteor.subscribe('people_addresses', 'john' function() {
  var john = People.findOne({ name: 'john' }), 
    address;

  address = john.getAddress();

  /* Use John's address */
});

L'opzione n. 1 nasconde la complessità, ma avrebbe bisogno di una soluzione elegante per aggiornare l'oggetto con i dati diaddress appena ricevuti.

Richiede anche callback (o promesse se seguiamo quella rotta) dove Opzione # 2 richiede solo il wrapping del codice nel subscribe.

Quali sono i tuoi pensieri sulla gestione delle sottoscrizioni di dati granulari? Una di queste opzioni è valida?