Merge pull request #711 from kuzzleio/bugfix-search-next-with-from

Fix bug where calling next on search with a from always return the same results

Author: Shiranuit

src/core/searchResult/SearchResultBase.ts

@@ -164,14 +164,11 @@ export class SearchResultBase<T> implements SearchResult<T> {
       }
 
       return this._kuzzle
-        .query(
-          {
-            ...this._request,
-            action: this._searchAction,
-            from: this.fetched,
-          },
-          this._options
-        )
+        .query({
+          ...this._request,
+          action: this._searchAction,
+          from: this.fetched,
+        })
         .then(({ result }) => this._buildNextSearchResult(result));
     }
 

src/protocols/abstract/Realtime.ts

@@ -83,11 +83,12 @@ export abstract class BaseProtocolRealtime extends KuzzleAbstractProtocol {
       this.retrying = true;
 
       if (
+        window !== null &&
         typeof window === "object" &&
-        typeof window.navigator === "object" &&
-        window.navigator.onLine === false
+        typeof window!.navigator === "object" &&
+        window!.navigator.onLine === false
       ) {
-        window.addEventListener(
+        window!.addEventListener(
           "online",
           () => {
             this.retrying = false;

test/core/searchResult/document.test.js

@@ -332,18 +332,15 @@ describe("DocumentSearchResult", () => {
         return searchResult.next().then((nextSearchResult) => {
           should(kuzzle.query)
             .be.calledOnce()
-            .be.calledWith(
-              {
-                index: "index",
-                collection: "collection",
-                body: { query: { foo: "bar" } },
-                controller: "document",
-                action: "search",
-                size: 2,
-                from: 2,
-              },
-              options
-            );
+            .be.calledWith({
+              index: "index",
+              collection: "collection",
+              body: { query: { foo: "bar" } },
+              controller: "document",
+              action: "search",
+              size: 2,
+              from: 2,
+            });
           should(nextSearchResult).not.be.equal(searchResult);
           should(nextSearchResult).be.instanceOf(DocumentSearchResult);
         });

test/core/searchResult/profile.test.js

@@ -352,16 +352,13 @@ describe("ProfileSearchResult", () => {
         return searchResult.next().then((nextSearchResult) => {
           should(kuzzle.query)
             .be.calledOnce()
-            .be.calledWith(
-              {
-                body: { query: { foo: "bar" } },
-                controller: "security",
-                action: "searchProfiles",
-                size: 2,
-                from: 2,
-              },
-              options
-            );
+            .be.calledWith({
+              body: { query: { foo: "bar" } },
+              controller: "security",
+              action: "searchProfiles",
+              size: 2,
+              from: 2,
+            });
           should(nextSearchResult).not.be.equal(searchResult);
           should(nextSearchResult).be.instanceOf(ProfileSearchResult);
         });

test/core/searchResult/role.test.js

@@ -160,16 +160,13 @@ describe("RoleSearchResult", () => {
         return searchResult.next().then((nextSearchResult) => {
           should(kuzzle.query)
             .be.calledOnce()
-            .be.calledWith(
-              {
-                body: { foo: "bar" },
-                controller: "security",
-                action: "searchRoles",
-                size: 2,
-                from: 2,
-              },
-              options
-            );
+            .be.calledWith({
+              body: { foo: "bar" },
+              controller: "security",
+              action: "searchRoles",
+              size: 2,
+              from: 2,
+            });
           should(nextSearchResult).not.be.equal(searchResult);
           should(nextSearchResult).be.instanceOf(RoleSearchResult);
         });

test/core/searchResult/specifications.test.js

@@ -331,16 +331,13 @@ describe("SpecificationsSearchResult", () => {
         return searchResult.next().then((nextSearchResult) => {
           should(kuzzle.query)
             .be.calledOnce()
-            .be.calledWith(
-              {
-                body: { query: { foo: "bar" } },
-                controller: "collection",
-                action: "searchSpecifications",
-                size: 2,
-                from: 2,
-              },
-              options
-            );
+            .be.calledWith({
+              body: { query: { foo: "bar" } },
+              controller: "collection",
+              action: "searchSpecifications",
+              size: 2,
+              from: 2,
+            });
           should(nextSearchResult).not.be.equal(searchResult);
           should(nextSearchResult).be.instanceOf(SpecificationsSearchResult);
         });

test/core/searchResult/user.test.js

@@ -392,16 +392,13 @@ describe("UserSearchResult", () => {
         return searchResult.next().then((nextSearchResult) => {
           should(kuzzle.query)
             .be.calledOnce()
-            .be.calledWith(
-              {
-                body: { query: { foo: "bar" } },
-                controller: "security",
-                action: "searchUsers",
-                size: 2,
-                from: 2,
-              },
-              options
-            );
+            .be.calledWith({
+              body: { query: { foo: "bar" } },
+              controller: "security",
+              action: "searchUsers",
+              size: 2,
+              from: 2,
+            });
           should(nextSearchResult).not.be.equal(searchResult);
           should(nextSearchResult).be.instanceOf(UserSearchResult);
         });