Pagination Cursors on Connections (Relay Specification)

packages/graphql/package.json

@@ -68,6 +68,7 @@
         "dot-prop": "^6.0.1",
         "graphql-compose": "^7.25.1",
         "graphql-parse-resolve-info": "^4.11.0",
+        "graphql-relay": "^0.7.0",
         "jsonwebtoken": "^8.5.1",
         "pluralize": "^8.0.0"
     },

packages/graphql/src/schema/make-augmented-schema.ts

@@ -45,7 +45,7 @@ import pluralize from "pluralize";
 import { Integer, isInt } from "neo4j-driver";
 import { Node, Exclude } from "../classes";
 import getAuth from "./get-auth";
-import { PrimitiveField, Auth, CustomEnumField } from "../types";
+import { PrimitiveField, Auth, CustomEnumField, ConnectionQueryArgs } from "../types";
 import { findResolver, createResolver, deleteResolver, cypherResolver, updateResolver } from "./resolvers";
 import checkNodeImplementsInterfaces from "./check-node-implements-interfaces";
 import * as Scalars from "./scalars";
@@ -59,6 +59,7 @@ import getFieldTypeMeta from "./get-field-type-meta";
 import Relationship, { RelationshipField } from "../classes/Relationship";
 import getRelationshipFieldMeta from "./get-relationship-field-meta";
 import getWhereFields from "./get-where-fields";
+import { createConnectionWithEdgeProperties } from "./pagination";
 // import validateTypeDefs from "./validation";
 
 function makeAugmentedSchema(
@@ -115,6 +116,17 @@ function makeAugmentedSchema(
         },
     });
 
+    composer.createObjectTC({
+        name: "PageInfo",
+        description: "Pagination information (Relay)",
+        fields: {
+            hasNextPage: "Boolean!",
+            hasPreviousPage: "Boolean!",
+            startCursor: "String!",
+            endCursor: "String!",
+        },
+    });
+
     const customResolvers = getCustomResolvers(document);
 
     const scalars = document.definitions.filter((x) => x.kind === "ScalarTypeDefinition") as ScalarTypeDefinitionNode[];
@@ -841,11 +853,7 @@ function makeAugmentedSchema(
                     name: nodeFieldDeleteInputName,
                     fields: {
                         where: `${node.name}${upperFirst(rel.fieldName)}ConnectionWhere`,
-                        ...(n.relationFields.length
-                            ? {
-                                  delete: `${n.name}DeleteInput`,
-                              }
-                            : {}),
+                        ...(n.relationFields.length ? { delete: `${n.name}DeleteInput` } : {}),
                     },
                 });
             }
@@ -855,11 +863,7 @@ function makeAugmentedSchema(
                     name: nodeFieldDisconnectInputName,
                     fields: {
                         where: `${node.name}${upperFirst(rel.fieldName)}ConnectionWhere`,
-                        ...(n.relationFields.length
-                            ? {
-                                  disconnect: `${n.name}DisconnectInput`,
-                              }
-                            : {}),
+                        ...(n.relationFields.length ? { disconnect: `${n.name}DisconnectInput` } : {}),
                     },
                 });
             }
@@ -895,6 +899,7 @@ function makeAugmentedSchema(
             const relationship = composer.createObjectTC({
                 name: connectionField.relationshipTypeName,
                 fields: {
+                    cursor: "String!",
                     node: `${connectionField.relationship.typeMeta.name}!`,
                 },
             });
@@ -913,6 +918,8 @@ function makeAugmentedSchema(
                 name: connectionField.typeMeta.name,
                 fields: {
                     edges: relationship.NonNull.List.NonNull,
+                    totalCount: "Int!",
+                    pageInfo: "PageInfo!",
                 },
             });
 
@@ -929,7 +936,9 @@ function makeAugmentedSchema(
 
             let composeNodeArgs: {
                 where: any;
-                options?: any;
+                sort?: any;
+                first?: any;
+                after?: any;
             } = {
                 where: connectionWhere,
             };
@@ -962,20 +971,32 @@ function makeAugmentedSchema(
                     });
                 }
 
-                const connectionOptions = composer.createInputTC({
-                    name: `${connectionField.typeMeta.name}Options`,
-                    fields: {
-                        sort: connectionSort.NonNull.List,
+                composeNodeArgs = {
+                    ...composeNodeArgs,
+                    sort: connectionSort.NonNull.List,
+                    first: {
+                        type: "Int",
                     },
-                });
-
-                composeNodeArgs = { ...composeNodeArgs, options: connectionOptions };
+                    after: {
+                        type: "String",
+                    },
+                };
             }
 
             composeNode.addFields({
                 [connectionField.fieldName]: {
                     type: connection.NonNull,
                     args: composeNodeArgs,
+                    resolve: (source, args: ConnectionQueryArgs) => {
+                        const { totalCount: count, edges } = source[connectionField.fieldName];
+
+                        const totalCount = isInt(count) ? count.toNumber() : count;
+
+                        return {
+                            totalCount,
+                            ...createConnectionWithEdgeProperties(edges, args, totalCount),
+                        };
+                    },
                 },
             });
 
@@ -1064,6 +1085,7 @@ function makeAugmentedSchema(
 
         composer.createInterfaceTC({
             name: inter.name.value,
+            description: inter.description?.value,
             fields: objectComposeFields,
             extensions: {
                 directives: graphqlDirectivesToCompose((inter.directives || []).filter((x) => x.name.value !== "auth")),
@@ -1074,7 +1096,6 @@ function makeAugmentedSchema(
     if (!Object.values(composer.Mutation.getFields()).length) {
         composer.delete("Mutation");
     }
-
     const generatedTypeDefs = composer.toSDL();
     let generatedResolvers: any = {
         ...composer.getResolveMethods(),
@@ -1096,6 +1117,7 @@ function makeAugmentedSchema(
 
     unions.forEach((union) => {
         if (!generatedResolvers[union.name.value]) {
+            // eslint-disable-next-line no-underscore-dangle
             generatedResolvers[union.name.value] = { __resolveType: (root) => root.__resolveType };
         }
     });

packages/graphql/src/schema/pagination.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getOffsetWithDefault, offsetToCursor } from "graphql-relay/connection/arrayConnection";
+import { Integer, isInt } from "neo4j-driver";
+
+/**
+ * Adapted from graphql-relay-js ConnectionFromArraySlice
+ */
+export function createConnectionWithEdgeProperties(
+    arraySlice: { node: Record<string, any>; [key: string]: any }[],
+    args: { after?: string; first?: number } = {},
+    totalCount: number
+) {
+    const { after, first } = args;
+
+    if ((first as number) < 0) {
+        throw new Error('Argument "first" must be a non-negative integer');
+    }
+
+    // after returns the last cursor in the previous set or -1 if invalid
+    const lastEdgeCursor = getOffsetWithDefault(after, -1);
+
+    // increment the last cursor position by one for the sliceStart
+    const sliceStart = lastEdgeCursor + 1;
+
+    const sliceEnd = sliceStart + ((first as number) || arraySlice.length);
+
+    const edges = arraySlice.map((value, index) => {
+        return {
+            ...value,
+            cursor: offsetToCursor(sliceStart + index),
+        };
+    });
+
+    const firstEdge = edges[0];
+    const lastEdge = edges[edges.length - 1];
+    return {
+        edges,
+        pageInfo: {
+            startCursor: firstEdge.cursor,
+            endCursor: lastEdge.cursor,
+            hasPreviousPage: lastEdgeCursor > 0,
+            hasNextPage: typeof first === "number" ? sliceEnd < totalCount : false,
+        },
+    };
+}
+
+export function createSkipLimitStr({ skip, limit }: { skip?: number | Integer; limit?: number | Integer }): string {
+    const hasSkip = typeof skip !== "undefined" && skip !== 0;
+    const hasLimit = typeof limit !== "undefined" && limit !== 0;
+    let skipLimitStr = "";
+
+    if (hasSkip && !hasLimit) {
+        skipLimitStr = `[${skip}..]`;
+    }
+
+    if (hasLimit && !hasSkip) {
+        skipLimitStr = `[..${limit}]`;
+    }
+
+    if (hasLimit && hasSkip) {
+        const sliceStart = isInt(skip as Integer) ? (skip as Integer).toNumber() : skip;
+        const itemsToGrab = isInt(limit as Integer) ? (limit as Integer).toNumber() : limit;
+        const sliceEnd = (sliceStart as number) + (itemsToGrab as number);
+        skipLimitStr = `[${skip}..${sliceEnd}]`;
+    }
+
+    return skipLimitStr;
+}

packages/graphql/src/translate/connection/create-connection-and-params.test.ts

@@ -18,6 +18,7 @@
  */
 
 import { ResolveTree } from "graphql-parse-resolve-info";
+import { offsetToCursor } from "graphql-relay";
 import dedent from "dedent";
 import { mocked } from "ts-jest/utils";
 import { ConnectionField, Context } from "../../types";
@@ -117,7 +118,7 @@ describe("createConnectionAndParams", () => {
         WITH this
         MATCH (this)<-[this_acted_in:ACTED_IN]-(this_actor:Actor)
         WITH collect({ screenTime: this_acted_in.screenTime }) AS edges
-        RETURN { edges: edges } AS actorsConnection
+        RETURN { edges: edges, totalCount: size(edges) } AS actorsConnection
         }`);
     });
 
@@ -144,18 +145,16 @@ describe("createConnectionAndParams", () => {
             alias: "actorsConnection",
             name: "actorsConnection",
             args: {
-                options: {
-                    sort: [
-                        {
-                            node: {
-                                name: "ASC",
-                            },
-                            relationship: {
-                                screenTime: "DESC",
-                            },
+                sort: [
+                    {
+                        node: {
+                            name: "ASC",
                         },
-                    ],
-                },
+                        relationship: {
+                            screenTime: "DESC",
+                        },
+                    },
+                ],
             },
             fieldsByTypeName: {
                 MovieActorsConnection: {
@@ -226,7 +225,89 @@ describe("createConnectionAndParams", () => {
             WITH this_acted_in, this_actor
             ORDER BY this_acted_in.screenTime DESC, this_actor.name ASC
             WITH collect({ screenTime: this_acted_in.screenTime }) AS edges
-            RETURN { edges: edges } AS actorsConnection
+            RETURN { edges: edges, totalCount: size(edges) } AS actorsConnection
+            }`);
+    });
+
+    test("Returns an entry with skip and limit args", () => {
+        // @ts-ignore
+        const mockedNeo4jGraphQL = mocked(new Neo4jGraphQL(), true);
+        // @ts-ignore
+        mockedNeo4jGraphQL.nodes = [
+            // @ts-ignore
+            {
+                name: "Actor",
+            },
+        ];
+        // @ts-ignore
+        mockedNeo4jGraphQL.relationships = [
+            // @ts-ignore
+            {
+                name: "MovieActorsRelationship",
+                fields: [],
+            },
+        ];
+
+        const resolveTree: ResolveTree = {
+            alias: "actorsConnection",
+            name: "actorsConnection",
+            args: {
+                first: 10,
+                after: offsetToCursor(10),
+            },
+            fieldsByTypeName: {
+                MovieActorsConnection: {
+                    edges: {
+                        alias: "edges",
+                        name: "edges",
+                        args: {},
+                        fieldsByTypeName: {
+                            MovieActorsRelationship: {
+                                screenTime: {
+                                    alias: "screenTime",
+                                    name: "screenTime",
+                                    args: {},
+                                    fieldsByTypeName: {},
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        const field: ConnectionField = {
+            fieldName: "actorsConnection",
+            relationshipTypeName: "MovieActorsRelationship",
+            // @ts-ignore
+            typeMeta: {
+                name: "MovieActorsConnection",
+                required: true,
+            },
+            otherDirectives: [],
+            // @ts-ignore
+            relationship: {
+                fieldName: "actors",
+                type: "ACTED_IN",
+                direction: "IN",
+                // @ts-ignore
+                typeMeta: {
+                    name: "Actor",
+                },
+            },
+        };
+
+        // @ts-ignore
+        const context: Context = { neoSchema: mockedNeo4jGraphQL };
+
+        const entry = createConnectionAndParams({ resolveTree, field, context, nodeVariable: "this" });
+
+        expect(dedent(entry[0])).toEqual(dedent`CALL {
+            WITH this
+            MATCH (this)<-[this_acted_in:ACTED_IN]-(this_actor:Actor)
+            WITH collect({ screenTime: this_acted_in.screenTime }) AS edges
+            WITH edges, size(edges) AS totalCount, edges[11..21] AS limitedSelection
+            RETURN { edges: limitedSelection, totalCount: totalCount } AS actorsConnection
             }`);
     });
 });