drf-paginator/cjs/query-handlers/limit-offset-query-handler.js

Module for consuming paginated Django REST framework endpoints.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.LimitOffsetQueryHandler = exports.errors = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _actions = require('../actions');

var actions = _interopRequireWildcard(_actions);

var _paginatorError = require('../paginator-error');

var _paginatorError2 = _interopRequireDefault(_paginatorError);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var errors = exports.errors = Object.freeze({
  calculateOffsetNoLimit: 'Can\'t calculate offsets without a limit',
  calculatePageNoLimit: 'Can\'t calculate pages without a limit'
});

var defaultOptions = {
  limitQueryParam: 'limit',
  offsetQueryParam: 'offset'
};

var LimitOffsetQueryHandler = exports.LimitOffsetQueryHandler = function () {
  function LimitOffsetQueryHandler(options) {
    _classCallCheck(this, LimitOffsetQueryHandler);

    this._excessParams = null;
    this._limit = null;
    this.setOptions(options);
  }

  _createClass(LimitOffsetQueryHandler, [{
    key: 'makeParams',
    value: function makeParams(page) {
      var opts = this._options;
      var queryParams = _lodash2.default.assign({}, this._excessParams);

      queryParams[opts.limitQueryParam] = this._limit;
      queryParams[opts.offsetQueryParam] = this._calculateOffset(page);

      return queryParams;
    }
  }, {
    key: 'resolvePage',
    value: function resolvePage(queryParams) {
      var _parse2 = this._parse(queryParams),
          offset = _parse2.offset,
          limit = _parse2.limit;

      if (offset === 0) {
        return 1;
      }

      if (!limit) {
        throw new _paginatorError2.default(errors.calculatePageNoLimit);
      }

      return (offset + limit) / limit;
    }
  }, {
    key: 'setParams',
    value: function setParams(queryParams) {
      var result = this._parse(queryParams);
      this._excessParams = result.excess;
      this._limit = result.limit;

      return this;
    }
  }, {
    key: 'onResponse',
    value: function onResponse(response, page) {
      if (page === 1 && !this._limit) {
        this._limit = actions.inferLimit(response);
      }
    }
  }, {
    key: 'setOptions',
    value: function setOptions(options) {
      this._options = _lodash2.default.assign({}, defaultOptions, options);

      return this;
    }
  }, {
    key: '_parse',
    value: function _parse(queryParams) {
      var _options = this._options,
          limitQueryParam = _options.limitQueryParam,
          offsetQueryParam = _options.offsetQueryParam;

      var defaults = {
        limit: null,
        offset: 0
      };
      var result = _lodash2.default.assign({}, defaults);

      if (queryParams.hasOwnProperty(limitQueryParam)) {
        result.limit = queryParams[limitQueryParam];
      }
      if (queryParams.hasOwnProperty(offsetQueryParam)) {
        result.offset = queryParams[offsetQueryParam];
      }

      result.excess = this._getExcess(queryParams);

      return result;
    }
  }, {
    key: '_getExcess',
    value: function _getExcess(queryParams) {
      var opts = this._options;
      var paginationProperties = [opts.limitQueryParam, opts.offsetQueryParam];

      return _lodash2.default.omit(queryParams, paginationProperties);
    }
  }, {
    key: '_calculateOffset',
    value: function _calculateOffset(page) {
      var limit = this._limit;

      if (page === 1) {
        return 0;
      }
      if (!limit) {
        throw new _paginatorError2.default(errors.calculateOffsetNoLimit);
      }

      return limit * page - limit;
    }
  }]);

  return LimitOffsetQueryHandler;
}();

exports.default = LimitOffsetQueryHandler;