feat: add ability to add fields to edges (related discussion #50)

* Add ability to add fields to edges

* Add connectionResolver with edgeFields to tests

Author: michaelbeaumont

src/__mocks__/userTC.js

@@ -29,7 +29,26 @@ export const UserType = new GraphQLObjectType({
   },
 });
 
+export const UserLinkType = new GraphQLObjectType({
+  name: 'UserLink',
+  fields: {
+    id: {
+      type: GraphQLInt,
+    },
+    type: {
+      type: GraphQLString,
+    },
+    userId: {
+      type: GraphQLInt,
+    },
+    otherUserId: {
+      type: GraphQLInt,
+    },
+  },
+});
+
 export const userTC = schemaComposer.createObjectTC(UserType);
+export const userLinkTC = schemaComposer.createObjectTC(UserLinkType);
 
 export const userList = [
   { id: 1, name: 'user01', age: 11, gender: 'm' },
@@ -49,6 +68,11 @@ export const userList = [
   { id: 13, name: 'user13', age: 45, gender: 'f' },
 ];
 
+export const userLinkList = [
+  { id: 1, type: 'likes', userId: 1, otherUserId: 2 },
+  { id: 2, type: 'dislikes', userId: 2, otherUserId: 1 },
+];
+
 const filterArgConfig = {
   name: 'filter',
   type: new GraphQLInputObjectType({
@@ -64,30 +88,71 @@ const filterArgConfig = {
   }),
 };
 
-function filteredUserList(list, filter = {}) {
-  let result = list.slice();
+const filterEdgeArgConfig = {
+  name: 'filter',
+  type: new GraphQLInputObjectType({
+    name: 'FilterNodeEdgeUserInput',
+    fields: {
+      edge: {
+        type: new GraphQLInputObjectType({
+          name: 'FilterNodeEdgeEdgeUserInput',
+          fields: {
+            type: {
+              type: GraphQLString,
+            },
+          },
+        }),
+      },
+      node: {
+        type: new GraphQLInputObjectType({
+          name: 'FilterNodeNodeEdgeUserInput',
+          fields: {
+            gender: {
+              type: GraphQLString,
+            },
+            age: {
+              type: GraphQLInt,
+            },
+          },
+        }),
+      },
+    },
+  }),
+};
+
+function filterUserLink(link, filter = {}) {
+  let pred = true;
+  if (filter.type) {
+    pred = pred && link.type === filter.type;
+  }
+  return pred;
+}
+function filterUser(user, filter = {}) {
+  let pred = true;
   if (filter.gender) {
-    result = result.filter((o) => o.gender === filter.gender);
+    pred = pred && user.gender === filter.gender;
   }
 
   if (filter.id) {
     if (filter.id.$lt) {
-      result = result.filter((o) => o.id < filter.id.$lt);
+      pred = pred && user.id < filter.id.$lt;
     }
     if (filter.id.$gt) {
-      result = result.filter((o) => o.id > filter.id.$gt);
+      pred = pred && user.id > filter.id.$gt;
     }
   }
   if (filter.age) {
     if (filter.age.$lt) {
-      result = result.filter((o) => o.age < filter.age.$lt);
+      pred = pred && user.age < filter.age.$lt;
     }
     if (filter.age.$gt) {
-      result = result.filter((o) => o.age > filter.age.$gt);
+      pred = pred && user.age > filter.age.$gt;
     }
   }
-
-  return result;
+  return pred;
+}
+function filteredUserList(list, filter = {}) {
+  return list.slice().filter((o) => filterUser(o, filter));
 }
 
 function sortUserList(list, sortValue = {}) {
@@ -171,6 +236,56 @@ export const countResolver = schemaComposer.createResolver({
 });
 userTC.setResolver('count', countResolver);
 
+function getThroughLinkResolver(list, filter) {
+  const nodeFilter = filter ? filter.node : {};
+  const edgeFilter = filter ? filter.edge : {};
+  return list
+    .map((link) => ({
+      ...link,
+      node: userList.find((u) => u.id === link.otherUserId && filterUser(u, nodeFilter)),
+    }))
+    .filter((l) => !!l.node && filterUserLink(l, edgeFilter));
+}
+export const findManyThroughLinkResolver = schemaComposer.createResolver({
+  name: 'findManyThroughLink',
+  kind: 'query',
+  type: UserType,
+  args: {
+    filter: filterEdgeArgConfig,
+    limit: GraphQLInt,
+    skip: GraphQLInt,
+  },
+  resolve: async (resolveParams) => {
+    const args = resolveParams.args || {};
+    const { limit, skip } = args;
+
+    let list = userLinkList.slice();
+
+    if (skip) {
+      list = list.slice(skip);
+    }
+
+    if (limit) {
+      list = list.slice(0, limit);
+    }
+    return getThroughLinkResolver(list, args.filter);
+  },
+});
+userTC.setResolver('findManyThroughLink', findManyThroughLinkResolver);
+export const countThroughLinkResolver = schemaComposer.createResolver({
+  name: 'count',
+  kind: 'query',
+  type: GraphQLInt,
+  args: {
+    filter: filterEdgeArgConfig,
+  },
+  resolve: async (resolveParams) => {
+    const args = resolveParams.args || {};
+    return getThroughLinkResolver(userLinkList.slice(), args.filter).length;
+  },
+});
+userTC.setResolver('countThroughLink', countThroughLinkResolver);
+
 export const sortOptions: ConnectionSortMapOpts = {
   ID_ASC: {
     value: { id: 1 },

src/__tests__/__snapshots__/connectionResolver-test.js.snap

@@ -4,6 +4,73 @@ exports[`connectionResolver "Relay Cursor Connections Specification (Pagination
 
 exports[`connectionResolver "Relay Cursor Connections Specification (Pagination algorithm)": ApplyCursorsToEdges(allEdges, before, after): should throw error if \`last\` is less than 0 1`] = `[Error: Argument \`last\` should be non-negative number.]`;
 
+exports[`connectionResolver edges with data correctly handles filtering 1`] = `
+Object {
+  "count": 1,
+  "edges": Array [
+    Object {
+      "cursor": "MA==",
+      "id": 1,
+      "node": Object {
+        "age": 12,
+        "gender": "m",
+        "id": 2,
+        "name": "user02",
+      },
+      "otherUserId": 2,
+      "type": "likes",
+      "userId": 1,
+    },
+  ],
+  "pageInfo": Object {
+    "endCursor": "MA==",
+    "hasNextPage": false,
+    "hasPreviousPage": false,
+    "startCursor": "MA==",
+  },
+}
+`;
+
+exports[`connectionResolver edges with data correctly resolves with edges 1`] = `
+Object {
+  "count": 2,
+  "edges": Array [
+    Object {
+      "cursor": "MA==",
+      "id": 1,
+      "node": Object {
+        "age": 12,
+        "gender": "m",
+        "id": 2,
+        "name": "user02",
+      },
+      "otherUserId": 2,
+      "type": "likes",
+      "userId": 1,
+    },
+    Object {
+      "cursor": "MQ==",
+      "id": 2,
+      "node": Object {
+        "age": 11,
+        "gender": "m",
+        "id": 1,
+        "name": "user01",
+      },
+      "otherUserId": 1,
+      "type": "dislikes",
+      "userId": 2,
+    },
+  ],
+  "pageInfo": Object {
+    "endCursor": "MQ==",
+    "hasNextPage": false,
+    "hasPreviousPage": false,
+    "startCursor": "MA==",
+  },
+}
+`;
+
 exports[`connectionResolver fallback logic (offset in cursor) should throw error if \`first\` is less than 0 1`] = `[Error: Argument \`first\` should be non-negative number.]`;
 
 exports[`connectionResolver fallback logic (offset in cursor) should throw error if \`last\` is less than 0 1`] = `[Error: Argument \`last\` should be non-negative number.]`;

src/__tests__/connectionResolver-test.js

@@ -3,7 +3,7 @@
 
 import { Resolver } from 'graphql-compose';
 import { GraphQLInt, GraphQLString } from 'graphql-compose/lib/graphql';
-import { userTC, userList, sortOptions } from '../__mocks__/userTC';
+import { userTC, userLinkTC, userList, sortOptions } from '../__mocks__/userTC';
 import { dataToCursor } from '../cursor';
 import { prepareConnectionResolver, prepareRawQuery, preparePageInfo } from '../connectionResolver';
 
@@ -829,4 +829,30 @@ describe('connectionResolver', () => {
       expect(data.pageInfo.hasPreviousPage).toBe(true);
     });
   });
+
+  describe('edges with data', () => {
+    const edgeDataResolver = prepareConnectionResolver(userTC, {
+      countResolverName: 'countThroughLink',
+      findResolverName: 'findManyThroughLink',
+      sort: sortOptions,
+      defaultLimit: 5,
+      edgeFields: userLinkTC.getFields(),
+    });
+    it('correctly resolves with edges', async () => {
+      const data = await edgeDataResolver.resolve({
+        args: {},
+        projection: { count: true, edges: true },
+      });
+      expect(data.edges.length).toBe(2);
+      expect(data).toMatchSnapshot();
+    });
+    it('correctly handles filtering', async () => {
+      const data = await edgeDataResolver.resolve({
+        args: { filter: { edge: { type: 'likes' } } },
+        projection: { count: true, edges: true },
+      });
+      expect(data.edges.length).toBe(1);
+      expect(data).toMatchSnapshot();
+    });
+  });
 });

src/composeWithConnection.js

@@ -6,7 +6,7 @@ import type { ComposeWithConnectionOpts } from './connectionResolver';
 
 export function composeWithConnection<TSource, TContext>(
   typeComposer: ObjectTypeComposer<TSource, TContext>,
-  opts: ComposeWithConnectionOpts
+  opts: ComposeWithConnectionOpts<TContext>
 ): ObjectTypeComposer<TSource, TContext> {
   if (!(typeComposer instanceof ObjectTypeComposer)) {
     throw new Error('You should provide ObjectTypeComposer instance to composeWithRelay method');