Adapt scroll to new Request refactor

Author: dbengsch

.eslintignore

@@ -20,7 +20,7 @@
   "scripts": {
     "test": "npm run --silent lint && npm run unit-testing",
     "unit-testing": "istanbul cover _mocha  -- --recursive",
-    "lint": "eslint --max-warnings=0 ./lib ./test",
+    "lint": "eslint --max-warnings=0 ./src ./test",
     "build": "node build.js"
   },
   "browser": "src/kuzzle.js",
@@ -38,14 +38,8 @@
     "webpack": "^1.13.1",
     "eslint": "^3.7.1",
     "eslint-friendly-formatter": "^2.0.6",
-    "eslint-loader": "^1.5.0",
     "browserify": "13.1.0",
     "codecov": "^1.0.1",
-    "grunt": "1.0.1",
-    "grunt-browserify": "^5.0.0",
-    "grunt-contrib-uglify": "2.0.0",
-    "grunt-webpack": "^1.0.14",
-    "gruntify-eslint": "^3.0.0",
     "istanbul": "0.4.5",
     "istanbul-middleware": "0.2.2",
     "mocha": "3.1.0",

.jshintrc

@@ -23,7 +23,7 @@ var
  * @param {responseCallback} [cb] - Handles connection response
  * @constructor
  */
-module.exports = Kuzzle = function (host, options, cb) {
+function Kuzzle (host, options, cb) {
   var self = this;
 
   if (!(this instanceof Kuzzle)) {
@@ -309,7 +309,7 @@ module.exports = Kuzzle = function (host, options, cb) {
       }
     });
   }
-};
+}
 
 /**
  * Connects to a Kuzzle instance using the provided host name.
@@ -1283,6 +1283,14 @@ Kuzzle.prototype.query = function (queryArgs, query, options, cb) {
       object.refresh = options.refresh;
     }
 
+    if (options.from) {
+      object.from = options.from;
+    }
+
+    if (options.size) {
+      object.size = options.size;
+    }
+
     if (options.metadata) {
       Object.keys(options.metadata).forEach(function (meta) {
         object.metadata[meta] = options.metadata[meta];
@@ -1477,3 +1485,5 @@ Kuzzle.prototype.stopQueuing = function () {
 
   return this;
 };
+
+module.exports = Kuzzle;

package.json

@@ -16,6 +16,11 @@ var
 /**
  * A data collection is a set of data managed by Kuzzle. It acts like a data table for persistent documents,
  * or like a room for pub/sub messages.
+ *
+ * @property {string} collection
+ * @property {string} index
+ * @property {Kuzzle} kuzzle
+ * @property {Array.<string>} collection
  * @param {object} kuzzle - Kuzzle instance to inherit from
  * @param {string} collection - name of the data collection to handle
  * @param {string} index - Index containing the data collection
@@ -289,25 +294,16 @@ KuzzleDataCollection.prototype.fetchAllDocuments = function (options, cb) {
   }
 
   // copying pagination options to the search filter
-  if (options && options.scroll) {
-    filters.scroll = options.scroll;
-    delete options.scroll;
+  if (!options) {
+    options = {};
   }
 
-  if (options && options.from) {
-    filters.from = options.from;
-    delete options.from;
-  }
-  else {
-    filters.from = 0;
+  if (!options.from) {
+    options.from = 0;
   }
 
-  if (options && options.size) {
-    filters.size = options.size;
-    delete options.size;
-  }
-  else {
-    filters.size = 1000;
+  if (!options.size) {
+    options.size = 1000;
   }
 
   this.kuzzle.callbackRequired('KuzzleDataCollection.fetchAllDocuments', cb);
@@ -320,7 +316,7 @@ KuzzleDataCollection.prototype.fetchAllDocuments = function (options, cb) {
     if (searchResult instanceof KuzzleSearchResult) {
       if (searchResult.total > 10000 && !warnEmitted) {
         warnEmitted = true;
-        console.warn('Usage of KuzzleDataCollection.fetchAllDocuments will fetch more than 10 000 document. To avoid performance issues, please use KuzzleDataCollection.search and KuzzleDataCollection.scroll requests')
+        console.warn('Usage of KuzzleDataCollection.fetchAllDocuments will fetch more than 10 000 document. To avoid performance issues, please use KuzzleDataCollection.search and KuzzleDataCollection.scroll requests'); // eslint-disable-line no-console
       }
 
       searchResult.documents.forEach(document => {
@@ -505,18 +501,18 @@ KuzzleDataCollection.prototype.scroll = function (scrollId, options, filters, cb
 
   if (!cb && typeof options === 'function') {
     cb = options;
-    options = null;
+    options = {};
   }
 
-  request.body.scrollId = scrollId;
-
-  if (options && options.scroll) {
-    request.body.scroll = options.scroll;
+  if (!options) {
+    options = {};
   }
 
+  options.scrollId = scrollId;
+
   this.kuzzle.callbackRequired('KuzzleDataCollection.scroll', cb);
 
-  this.kuzzle.query({controller: 'read', action: 'scroll'}, request, options, function (error, result) {
+  this.kuzzle.query({controller: 'document', action: 'scroll'}, request, options, function (error, result) {
     var documents = [];
 
     if (error) {
@@ -532,7 +528,7 @@ KuzzleDataCollection.prototype.scroll = function (scrollId, options, filters, cb
     });
 
     if (result.result._scroll_id) {
-      filters.scrollId = result.result._scroll_id;
+      options.scrollId = result.result._scroll_id;
     }
 
     cb(null, new KuzzleSearchResult(

src/kuzzle.js

@@ -1,5 +1,3 @@
-var KuzzleDocument = require('./kuzzleDocument.js');
-
 /**
  *
  * @param {KuzzleDataCollection} dataCollection
@@ -83,18 +81,14 @@ KuzzleSearchResult.prototype.previous = function (cb) {
  * @param {function} cb
  */
 KuzzleSearchResult.prototype.next = function (cb) {
-  var self = this;
+  var
+    filters,
+    options = Object.assign({}, this.searchArgs.options),
+    self = this;
 
   if (!this._next) {
     // retrieve next results with scroll if original search use it
-    if (this.searchArgs.options.scrollId) {
-      var
-        options = Object.assign({}, this.searchArgs.options);
-
-      if (this.searchArgs.filters.scroll) {
-        options.scroll = this.searchArgs.filters.scroll;
-      }
-
+    if (options.scrollId) {
       if (this.fetchedDocument >= this.total) {
         cb(null, null);
         return;
@@ -105,31 +99,30 @@ KuzzleSearchResult.prototype.next = function (cb) {
         options,
         this.searchArgs.filters || {},
         function(error, newSearchResults) {
-          handleNextSearchResults(error, self, newSearchResults, cb)
+          handleNextSearchResults(error, self, newSearchResults, cb);
         }
       );
 
       return;
     }
-    // retrieve next results with  from/size if original search use it
-    else if (this.searchArgs.filters.from !== undefined && this.searchArgs.filters.size !== undefined) {
-      var
-        filters = Object.assign({}, this.searchArgs.filters);
+    // retrieve next results with from/size if original search use it
+    else if (options.from !== undefined && options.size !== undefined) {
+      filters = Object.assign({}, this.searchArgs.filters);
 
       // check if we need to do next request to fetch all matching documents
-      filters.from += filters.size;
+      options.from += options.size;
 
-      if (filters.from >= this.total) {
+      if (options.from >= this.total) {
         cb(null, null);
 
         return;
       }
 
       this.dataCollection.search(
         filters,
-        this.searchArgs.options,
+        options,
         function(error, newSearchResults) {
-          handleNextSearchResults(error, self, newSearchResults, cb)
+          handleNextSearchResults(error, self, newSearchResults, cb);
         }
       );
 

src/kuzzleDataCollection.js

@@ -345,12 +345,12 @@ describe('Kuzzle methods', function () {
     });
 
     it('should handle from option correctly', function (done) {
-      expectedQuery.body.from = 'foobar';
+      expectedQuery.from = 'foobar';
       kuzzle.listCollections('foo', {from: 'foobar'}, () => done());
     });
 
     it('should handle size option correctly', function (done) {
-      expectedQuery.body.size = 'foobar';
+      expectedQuery.size = 'foobar';
       kuzzle.listCollections('foo', {size: 'foobar'}, () => done());
     });
 

src/kuzzleSearchResult.js

@@ -172,6 +172,22 @@ describe('Query management', function () {
       should(requestObject.refresh).match(refresh);
     });
 
+    it('should handle option size properly', function () {
+      var
+        size = 'foo';
+
+      kuzzle.query(queryArgs, { body: { some: 'query'}}, {size: size});
+      should(requestObject.size).match(size);
+    });
+
+    it('should handle option from properly', function () {
+      var
+        from = 'foo';
+
+      kuzzle.query(queryArgs, { body: { some: 'query'}}, {from: from});
+      should(requestObject.from).match(from);
+    });
+
     it('should exit early if the query is not queuable and the SDK is offline', function () {
       kuzzle.state = 'offline';
       kuzzle.query(queryArgs, { body: { some: 'query'}}, {queuable: false});

test/kuzzle/methods.test.js

@@ -139,7 +139,7 @@ describe('KuzzleDataCollection methods', function () {
         index: 'bar',
         collection: 'foo',
         action: 'scroll',
-        controller: 'read',
+        controller: 'document',
         body: {}
       };
     });
@@ -166,11 +166,10 @@ describe('KuzzleDataCollection methods', function () {
         };
 
       queryScrollStub = function (args, query, opts, callback) {
-        should(args.controller).be.exactly('read');
+        should(args.controller).be.exactly('document');
         should(args.action).be.exactly('scroll');
-        should(query.body.scroll).be.exactly(options.scroll);
-        should(query.body.scrollId).be.exactly(scrollId);
-        should(opts).be.exactly(options);
+        should(opts.scroll).be.exactly(options.scroll);
+        should(opts.scrollId).be.exactly(scrollId);
 
         callback(null, {
           result: {
@@ -201,10 +200,9 @@ describe('KuzzleDataCollection methods', function () {
         };
 
       queryScrollStub = function (args, query, opts, callback) {
-        should(args.controller).be.exactly('read');
+        should(args.controller).be.exactly('document');
         should(args.action).be.exactly('scroll');
-        should(query.body.scrollId).be.exactly(scrollId);
-        should(opts).be.null();
+        should(opts.scrollId).be.exactly(scrollId);
 
         callback(null, {
           result: {
@@ -601,6 +599,13 @@ describe('KuzzleDataCollection methods', function () {
     beforeEach(function () {
       kuzzle = new Kuzzle('foo', {defaultIndex: 'bar'});
       emitted = false;
+      expectedQuery = {
+        index: 'bar',
+        collection: 'foo',
+        action: 'get',
+        controller: 'document',
+        body: {}
+      };
     });
 
     it('should forward the query to the search method', function () {
@@ -652,7 +657,7 @@ describe('KuzzleDataCollection methods', function () {
 
       collection.fetchAllDocuments({from: 123, size: 456}, function () {});
       should(stub.calledOnce).be.true();
-      should(stub.calledWithMatch({from: 123, size: 456})).be.true();
+      should(stub.calledWithMatch({}, {from: 123, size: 456})).be.true();
       stub.restore();
     });
 
@@ -663,7 +668,7 @@ describe('KuzzleDataCollection methods', function () {
 
       collection.fetchAllDocuments({scroll: '30s'}, function () {});
       should(stub.calledOnce).be.true();
-      should(stub.calledWithMatch({from: 0, size: 1000, scroll: '30s'})).be.true();
+      should(stub.calledWithMatch({}, {from: 0, size: 1000, scroll: '30s'})).be.true();
       stub.restore();
     });
 

test/kuzzle/query.test.js

@@ -20,7 +20,7 @@ describe('KuzzleSearchResult methods', function () {
 
   beforeEach(function () {
     kuzzle = new Kuzzle('foo', {defaultIndex: 'bar'});
-    searchArgs = {options: {}, filters: {from:0, size: 1}};
+    searchArgs = {options: {from:0, size: 1}, filters: {}};
     dataCollection = kuzzle.dataCollectionFactory('foo');
     firstDocument = new KuzzleDocument(dataCollection, 'banana', {foo: 'bar'});
     secondDocument = new KuzzleDocument(dataCollection, 'papagayo', {foo: 'bar'});
@@ -47,7 +47,7 @@ describe('KuzzleSearchResult methods', function () {
           1,
           [new KuzzleDocument(dataCollection, 'papagayo', {foo: 'bar'})],
           {},
-          {options: {scrollId: 'papagayo'}, filters: {from: 0, size: 1}}
+          {options: {scrollId: 'papagayo', from: 0, size: 1}}
         ),
         firstSearchResult;
 
@@ -101,7 +101,7 @@ describe('KuzzleSearchResult methods', function () {
         should(result).be.an.instanceOf(KuzzleSearchResult);
         should(result.documents).be.an.Array();
         should(result.documents.length).be.exactly(1);
-        should(result.searchArgs.filters.from).be.exactly(1);
+        should(result.searchArgs.options.from).be.exactly(1);
         done();
       });
     });
@@ -151,7 +151,7 @@ describe('KuzzleSearchResult methods', function () {
       var
         firstSearchResult;
 
-      searchArgs.filters = {};
+      searchArgs.options = {};
 
       firstSearchResult = new KuzzleSearchResult(dataCollection, 1, [firstDocument], {}, searchArgs);