CODEWITHSUNDEEP
meteor
Cereal Killer
Cereal Killer

Reputation: 3414

right way to use subscriptions in meteor

In my meteor app I have all pages that needs to load one or more documents from elements collection and a couple of pages that loads documents from items collection;

I have the two publish functions for the two collections, but now I'm trying to understand the best way to subscribe them; currently I'm subscribing elements in a file in the /client directory:

Meteor.subscribe("elements");

This will make the subscription on application start;

in the other case, since the items to be loaded are a little more, I've decided to use the subscription option in iron router:

subscriptions: function() {
    return Meteor.subscribe("items");
}

The first difference I can see is that it seems that elements, once started the application, will not take time anymore to load (navigating through pages takes no time for loading); on the other hand, every time I open the page that loads items, (event without a refresh) takes the loading time again;

Would be probably not the best solution to subscribe also items on application start, since they are only needed if you visit their specific route (elements otherwise are needed everywhere); but there is a way to avoid reloading them from the server every time I ask the route again?

Also thinking about elements, they are not needed all in all pages: avery page need just one or two of them; so it would be probably more corret to load just the one or two that are really needed...

How subscriptions should be managed in your opinion?

Upvotes: 1

Views: 376

Answers (3)

B. Clay Shannon-B. Crow Raven
B. Clay Shannon-B. Crow Raven

Reputation: 10267

First, install IronRouter enter; at the command prompt, enter "meteor add iron:router"; doing so will add that routing package.

So that your "raw" or base URL doesn't throw a routing exception, add this to the top of your .js file (above/outside the "isClient" and "isService" blocks):

Router.route('/');

Add a template or two (or more) to your project's .html file (you can use Notepad or Notepad++ for this, but I recommend the free (and "hackable") Atom editor, from Github, with the Meteor helper packages added. The project will be in a subfolder of whatever folder you were in when you entered the "meteor create" command. To download the Atom Editor, click this.

BTW, the video of the futuristic/pastistic coding family on the Atom Editor site is a gas, man!

Getting back to adding templates; as an example, here are a couple of templates I added:

<template name="garrapatabeach"><p>Here&#39;s a picture of Garrapata Beach; early morning; 
    long exposure.</p>
<p class="location">Garrapata Beach.Garrapata State Park.Big Sur.Monterey County.California</p>
  <img height="600" src="/images/garrapataBeach.jpg" width="900" />
</template>

<template name="garrapataturnout"><p>Here&#39;s a picture from the first Garrapata turnout; 
    long exposure</p>
<p class="location">First Turnout.Garrapata State Park.Big Sur.Monterey County.California</p>
  <img height="600" src="/images/GarrapataTurnout1.jpg" width="900" />
</template>

Now, add routes for those templates in the same part of the project's .js file where you added the "home" ("/") route in the .js file, so that it looks like this (the routes match the template names):

Router.route('/');
Router.route('/garrapatabeach');
Router.route('/garrapataturnout');

Note: This supposes you have added a "public" folder to your project, and an "images" folder beneath that, and that you have images with the names indicated in that images folder. If you want to "play along," you can download those images from dplatypus.meteor.com/garrapatabeach and dplatypus.meteor.com/garrapataturnout; otherwise, simply change the names of the jpgs and use your own images.

You will now be able to view your templates by navigating to the links given above (to run it, simply enter "meteor" at the command prompt while in the project's folder, and navigate to localhost:3000). However, to make it "more better" (so that the main page is not naked as a jaybird), we'll put some anchor tags/links in the main template, like so:

<body>
  {{> main}}
</body>

<template name="main">
  <a href="garrapatabeach" target="_blank">Garrapata Beach</a>
  <a href="garrapataturnout" target="_blank">Garrapata Turnout</a>
</template>

Now the links will display when you navigate to localhost:3000, and clicking on them will route you to the appropriate page/template. To continue, just add another template, along with its corresponding routing entry and anchor tag/link.

Upvotes: 0

David Weldon
David Weldon

Reputation: 64312

I cover some of the trade-offs in my answer to this question. Here's how we use do this at Edthena using the subscriptions manager package:

// Allow the subman to cache a lot of subscriptions for a very long time
var subman = new SubsManager({cacheLimit: 100, expireIn: 864000});

// This is a global subscription that we may need to wait on later
subman.subscribe('sub1');

// This is a global subscription that we don't need to wait on
Meteor.subscribe('sub2');

Tracker.autorun(function() {
  if (Meteor.userId()) {
    // Add subscriptions which should be loaded globally but only
    // after the user logs in.
    Meteor.subscribe('sub3');
  }
});

var PostController = RouteController.extend({
  waitOn: function() {
    // Use subman only if we want to cache the subscription between routes.
    // Note that in the case of sub1, the previous handle will be reused
    return [
      subman.subscribe('sub1'),
      subman.subscribe('sub4'),
      Meteor.subscribe('sub5')
    ];
  }
});

Upvotes: 1

richsilv
richsilv

Reputation: 8013

It's a matter of preference, but I think the simplest answer is that you can still use Iron Router's subscriptions option whilst centrally subscribing:

Subscription file:

Subscriptions = {
    elements: Meteor.subscribe('elements'),
    ...
};

Router:

subscriptions: function() {
    return Subscriptions.elements;
}

All the router needs is the handle which is returned by Meteor.subscribe, it doesn't actually have to do the subscribing. If you store these handles in a (sensibly named) global object, you can then pass them to the relevant router function when you need them.

Upvotes: 0

Related Questions