Redirecting

Since a route's beforeModel() executes before the model() hook, it's a good place to do a redirect if you don't need any information that is contained in the model.

Router.map(function() {
  this.route('posts');
});

import Route from '@ember/routing/route';

export default class IndexRoute extends Route {
  beforeModel(/* transition */) {
    this.transitionTo('posts'); // Implicitly aborts the on-going transition.
  }
}

beforeModel() receives the current transition as an argument, which we can store and retry later. This allows us to return the user back to the original route. For example, we might redirect a user to the login page when they try to edit their profile, and immediately redirect them back to the edit page once they have successfully logged in. See Storing and Retrying a Transition for how to do that.

If you need to examine some application state to figure out where to redirect, you might use a service.

If you need information about the current model in order to decide about redirection, you can use the afterModel() hook. It receives the resolved model as the first parameter and the transition as the second one. For example:

Router.map(function() {
  this.route('posts');
  this.route('post', { path: '/post/:post_id' });
});

import Route from '@ember/routing/route';

export default class PostsRoute extends Route {
  afterModel(model, transition) {
    if (model.get('length') === 1) {
      this.transitionTo('post', model.get('firstObject'));
    }
  }
}

When transitioning to the posts route if it turns out that there is only one post, the current transition will be aborted in favor of redirecting to the PostRoute with the single post object being its model.

Zoey says...

If you attempt to redirect with the `queryParams` option, make sure that the query params are defined on the controller!

Let's change the router above to use a nested route, like this:

Router.map(function() {
  this.route('posts', function() {
    this.route('post', { path: '/:post_id' });
  });
});

If we redirect to posts.post in the afterModel hook, afterModel essentially invalidates the current attempt to enter this route. So the posts route's beforeModel, model, and afterModel hooks will fire again within the new, redirected transition. This is inefficient, since they just fired before the redirect.

Instead, we can use the redirect() method, which will leave the original transition validated, and not cause the parent route's hooks to fire again:

import Route from '@ember/routing/route';

export default class PostsRoute extends Route {
  redirect(model, transition) {
    if (model.get('length') === 1) {
      this.transitionTo('posts.post', model.get('firstObject'));
    }
  }
}