new-route.js

//using version 1.0.0-beta.1
import { computed } from '@ember/object';
import { inject as service } from '@ember/service';
import Route from '@ember/routing/route';
import InfinityRoute from 'ember-infinity/mixins/route';
import InfinityModel from 'ember-infinity/lib/infinity-model';
import DS from 'ember-data';
import { get } from '@ember/object';

const { UnauthorizedError, ForbiddenError, ServerError } = DS;
const ExtendedInfinityModel = InfinityModel.extend({
  buildParams() {
    let params = this._super(...arguments);
    let offset = computed('currentPage', 'perPage', function() {
      return get(this, 'currentPage') * get(this, 'perPage');
    });
    let serializedQuery = computed('query', function() {
    return this.get('equipmentColumns.serializeQuery')(this.get('query'));
    });
    params['page[offset]'] = offset;
    params.query = serializedQuery;
    params.sort = 'name';
    return params;
  }
});

export default Route.extend(InfinityRoute, {
  equipmentColumns: service(),
  session: service(),
  queryParams: {
    query: {
      refreshModel: true
    },
    sort: {
      refreshModel: true
    }
  },

  beforeModel({ queryParams: { query, sort = 'name' } }) {
    this.setProperties({ sort, query });
  },

  model() {
    let equipmentColumns = get(this, 'equipmentColumns');
    this.infinityModel('equipment', {
      perPage: 25,
      startingPage: 0,
      perPageParam: 'page[limit]',
      pageParam: 'page[offset]',
      totalPagesParam: 'total_count'
    }, ExtendedInfinityModel.extend({ equipmentColumns })
    ).catch((reason) => {
      this.controllerFor('new-route').set('isLoading', false);
      return reason;
    });
  },

  afterInfinityModel(equipment) {
    let totalCount = equipment.meta.total_count;
    let offset = this.get('offset');
    let limit = this.get('_perPage');
    let canLoadMore = offset + limit < totalCount;
    this.set('_canLoadMore', canLoadMore);
    this.set('modelIsLoaded', true);
  },

  setupController(controller) {
    this._super(...arguments);
    let sort = this.get('sort');
    let defaultSort = (this._isDescending(sort) ? `${sort.substr(1)}:desc` : sort);
    controller.set('isLoading', true);
    controller.set('sort', this.get('sort'));
    controller.set('defaultSort', defaultSort);
  },

  actions: {
    loading(transition) {
      this.controllerFor('new-route').set('transition', transition);
      return !this.get('modelIsLoaded');
    }
  },

  _isDescending(sort) {
    return sort.indexOf('-') !== -1;
  },

  _loadNextPage() {
    return this._super(...arguments)
      .catch((error) => {
        if (error instanceof UnauthorizedError) {
          this.send('error', error);
        } else if (error instanceof ForbiddenError) {
          this.send('error', error);
        } else if (error instanceof ServerError) {
          this.send('error', error);
        }
        return error;
      });
  }
});

old-route.js

// using version 0.2.8
import { computed } from '@ember/object';
import { inject as service } from '@ember/service';
import Route from '@ember/routing/route';
import InfinityRoute from 'ember-infinity/mixins/route';
import DS from 'ember-data';

const { UnauthorizedError, ForbiddenError, ServerError } = DS;

export default Route.extend(InfinityRoute, {
  equipmentColumns: service(),
  perPageParam: 'page[limit]',
  pageParam: 'page[offset]',
  session: service(),
  queryParams: {
    query: {
      refreshModel: true
    },
    sort: {
      refreshModel: true
    }
  },

  offset: computed('currentPage', '_perPage', function() {
    return this.get('currentPage') * this.get('_perPage');
  }),

  serializedQuery: computed('query', function() {
    return this.get('equipmentColumns.serializeQuery')(this.get('query'));
  }),

  beforeModel({ queryParams: { query, sort = 'name' } }) {
    this.setProperties({
      sort,
      query
    });
  },

  model() {
    return this.infinityModel('equipment', {
      startingPage: 0,
      perPage: 25
    }, {
      'page[offset]': 'offset',
      query: 'serializedQuery',
      sort: 'sort'
    }).catch((reason) => {
      this.controllerFor('old-route').set('isLoading', false);
      return reason;
    });
  },

  afterInfinityModel(equipment) {
    let totalCount = equipment.meta.total_count;
    let offset = this.get('offset');
    let limit = this.get('_perPage');
    let canLoadMore = offset + limit < totalCount;
    this.set('_canLoadMore', canLoadMore);
    this.set('modelIsLoaded', true);
  },

  setupController(controller) {
    this._super(...arguments);
    let sort = this.get('sort');
    let defaultSort = (this._isDescending(sort) ? `${sort.substr(1)}:desc` : sort);
    controller.set('isLoading', true);
    controller.set('sort', this.get('sort'));
    controller.set('defaultSort', defaultSort);
  },

  actions: {
    loading(transition) {
      this.controllerFor('old-route').set('transition', transition);
      return !this.get('modelIsLoaded');
    }
  },

  _isDescending(sort) {
    return sort.indexOf('-') !== -1;
  },

  _loadNextPage() {
    return this._super(...arguments)
      .catch((error) => {
        if (error instanceof UnauthorizedError) {
          this.send('error', error);
        } else if (error instanceof ForbiddenError) {
          this.send('error', error);
        } else if (error instanceof ServerError) {
          this.send('error', error);
        }
        return error;
      });
  }
});