relay: pageInfo: fix hasNextPage and implement hasPreviousPage (#251)

* test: relay: add case `support pagination with where`

* relay: fix `hasPreviousPage`

Author: LoicMahieu

src/relay.js

@@ -268,10 +268,19 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
       if (model.sequelize.dialect.name === 'postgres' && (args.first || args.last)) {
         if (fullCount === null || fullCount === undefined) throw new Error('No fullcount available');
       }
-      let hasMorePages = false;
+      let hasNextPage = false;
+      let hasPreviousPage = false;
       if (args.first || args.last) {
+        const count = parseInt(args.first || args.last, 10);
         let index = cursor ? Number(cursor.index) : 0;
-        hasMorePages = index + 1 + parseInt(args.first || args.last, 10) < fullCount;
+        if (index !== 0) index++;
+
+        hasNextPage = index + 1 + count <= fullCount;
+        hasPreviousPage = index - count >= 0;
+
+        if (args.last) {
+          [hasNextPage, hasPreviousPage] = [hasPreviousPage, hasNextPage];
+        }
       }
 
       return {
@@ -282,8 +291,8 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
         pageInfo: {
           startCursor: firstEdge ? firstEdge.cursor : null,
           endCursor: lastEdge ? lastEdge.cursor : null,
-          hasPreviousPage: hasMorePages,
-          hasNextPage: hasMorePages
+          hasNextPage: hasNextPage,
+          hasPreviousPage: hasPreviousPage
         }
       };
     }

test/integration/relay/connection.test.js

@@ -463,6 +463,7 @@ if (helper.sequelize.dialect.name === 'postgres') {
                   }
                   pageInfo {
                     hasNextPage
+                    hasPreviousPage
                     endCursor
                   }
                 }
@@ -474,14 +475,17 @@ if (helper.sequelize.dialect.name === 'postgres') {
         let firstResult = await query();
         verify(firstResult, firstThree);
         expect(firstResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
+        expect(firstResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(false);
 
         let nextResult = await query(firstResult.data.user.tasks.pageInfo.endCursor);
         verify(nextResult, nextThree);
         expect(nextResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
+        expect(nextResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
 
         let lastResult = await query(nextResult.data.user.tasks.edges[2].cursor);
         verify(lastResult, lastThree);
         expect(lastResult.data.user.tasks.pageInfo.hasNextPage).to.equal(false);
+        expect(lastResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
       });
 
       it('should support in-query slicing and pagination with first and CUSTOM orderBy', async function () {
@@ -553,6 +557,7 @@ if (helper.sequelize.dialect.name === 'postgres') {
                   }
                   pageInfo {
                     hasNextPage
+                    hasPreviousPage
                     endCursor
                   }
                 }
@@ -564,14 +569,82 @@ if (helper.sequelize.dialect.name === 'postgres') {
         let firstResult = await query();
         verify(firstResult, firstThree);
         expect(firstResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
+        expect(firstResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(false);
 
         let nextResult = await query(firstResult.data.user.tasks.pageInfo.endCursor);
         verify(nextResult, nextThree);
         expect(nextResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
+        expect(nextResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
 
         let lastResult = await query(nextResult.data.user.tasks.edges[2].cursor);
         verify(lastResult, lastThree);
         expect(lastResult.data.user.tasks.pageInfo.hasNextPage).to.equal(false);
+        expect(lastResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
+      });
+
+      it('should support pagination with where', async function () {
+        const completedTasks = this.userA.tasks.filter(task => task.completed)
+
+        expect(completedTasks.length).to.equal(4);
+
+        let firstThree = completedTasks.slice(0, 3);
+        let nextThree = completedTasks.slice(3, 6);
+
+        expect(firstThree.length).to.equal(3);
+        expect(nextThree.length).to.equal(1);
+
+        let verify = function (result, expectedTasks) {
+          if (result.errors) throw new Error(result.errors[0].stack);
+
+          var resultTasks = result.data.user.tasks.edges.map(function (edge) {
+            return edge.node;
+          });
+
+          let resultIds = resultTasks.map((task) => {
+            return parseInt(fromGlobalId(task.id).id, 10);
+          }).sort();
+
+          let expectedIds = expectedTasks.map(function (task) {
+            return task.get('id');
+          }).sort();
+
+          expect(resultTasks.length).to.equal(expectedTasks.length);
+          expect(resultIds).to.deep.equal(expectedIds);
+        };
+
+        let query = (after) => {
+          return graphql(this.schema, `
+            {
+              user(id: ${this.userA.id}) {
+                tasks(first: 3, ${after ? 'after: "' + after + '", ' : ''} completed: true) {
+                  edges {
+                    cursor
+                    node {
+                      id
+                      name
+                    }
+                  }
+                  pageInfo {
+                    hasNextPage
+                    hasPreviousPage
+                    endCursor
+                  }
+                }
+              }
+            }
+          `, null, {});
+        };
+
+
+        let firstResult = await query();
+        verify(firstResult, firstThree);
+        expect(firstResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
+        expect(firstResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(false);
+
+        let nextResult = await query(firstResult.data.user.tasks.pageInfo.endCursor);
+        verify(nextResult, nextThree);
+        expect(nextResult.data.user.tasks.pageInfo.hasNextPage).to.equal(false);
+        expect(nextResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
       });
 
       it('should support in-query slicing with user provided args/where', async function () {
@@ -663,6 +736,7 @@ if (helper.sequelize.dialect.name === 'postgres') {
                     }
                   }
                   pageInfo {
+                    hasNextPage
                     hasPreviousPage
                     endCursor
                   }
@@ -674,14 +748,17 @@ if (helper.sequelize.dialect.name === 'postgres') {
 
         let firstResult = await query();
         verify(firstResult, firstThree);
+        expect(firstResult.data.user.tasks.pageInfo.hasNextPage).to.equal(false);
         expect(firstResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
 
         let nextResult = await query(firstResult.data.user.tasks.pageInfo.endCursor);
         verify(nextResult, nextThree);
+        expect(nextResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
         expect(nextResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(true);
 
         let lastResult = await query(nextResult.data.user.tasks.edges[2].cursor);
         verify(lastResult, lastThree);
+        expect(lastResult.data.user.tasks.pageInfo.hasNextPage).to.equal(true);
         expect(lastResult.data.user.tasks.pageInfo.hasPreviousPage).to.equal(false);
       });