refactor: get rid of TC.getResolver() method

BREAKING CHANGE: were changed config options. Get rid of `TC.getResolver()` method where were used resolver names as string. Now you need to pass Resolver `findMany` & `count` instances explicitly.

Author: nodkz

README.md

@@ -29,14 +29,15 @@ Modules `graphql` and `graphql-compose` are in `peerDependencies`, so should be
 
 ## Example
 
+Implementation details of `findManyResolver` and `countResolver` can be found in [this file](./src/__mocks__/User.ts).
+
 ```js
-import composeWithConnection from 'graphql-compose-connection';
-import userTC from './user.js';
+import { prepareConnectionResolver } from 'graphql-compose-connection';
+import { UserTC, findManyResolver, countResolver } from './user';
 
-composeWithConnection(userTC, {
-  connectionResolverName: 'connection', // Default
-  findResolverName: 'findMany',
-  countResolverName: 'count',
+prepareConnectionResolver(userTC, {
+  findManyResolver,
+  countResolver,
   sort: {
     // Sorting key, visible for users in GraphQL Schema
     _ID_ASC: {
@@ -108,13 +109,6 @@ composeWithConnection(userTC, {
 
 <img width="1249" alt="screen shot 2016-07-20 at 12 20 08" src="https://cloud.githubusercontent.com/assets/1946920/16976899/67a5e0f8-4e74-11e6-87e5-fc4574deaaab.png">
 
-## Requirements
-
-Types should have following resolvers:
-
-- `count` - for counting records
-- `findMany` - for filtering records. Also required that this resolver supports search with operators (lt, gt), which used in `directionFilter` option. Resolver `findMany` should have `filter` argument, which will be copied to connection. Also should have `limit` and `skip` args.
-
 ## Used in plugins
 
 [graphql-compose-mongoose](https://github.com/graphql-compose/graphql-compose-mongoose) - converts mongoose models to graphql types

package.json

@@ -24,26 +24,26 @@
   },
   "homepage": "https://github.com/graphql-compose/graphql-compose-connection",
   "peerDependencies": {
-    "graphql-compose": "^7.0.4"
+    "graphql-compose": "^7.15.0"
   },
   "devDependencies": {
     "@types/graphql": "14.5.0",
-    "@types/jest": "26.0.10",
-    "@typescript-eslint/eslint-plugin": "3.9.0",
-    "@typescript-eslint/parser": "3.9.0",
-    "eslint": "7.7.0",
+    "@types/jest": "26.0.13",
+    "@typescript-eslint/eslint-plugin": "4.1.0",
+    "@typescript-eslint/parser": "4.1.0",
+    "eslint": "7.9.0",
     "eslint-config-airbnb-base": "14.2.0",
     "eslint-config-prettier": "6.11.0",
     "eslint-plugin-import": "2.22.0",
     "eslint-plugin-prettier": "3.1.4",
     "graphql": "15.3.0",
-    "graphql-compose": "7.19.4",
-    "jest": "26.4.0",
-    "prettier": "2.0.5",
+    "graphql-compose": "7.21.1",
+    "jest": "26.4.2",
+    "prettier": "2.1.1",
     "rimraf": "3.0.2",
     "semantic-release": "17.1.1",
-    "ts-jest": "26.2.0",
-    "typescript": "3.9.7"
+    "ts-jest": "26.3.0",
+    "typescript": "4.0.2"
   },
   "scripts": {
     "build": "rimraf lib && tsc -p ./tsconfig.build.json",

src/__mocks__/userTC.ts renamed to src/__mocks__/User.ts

@@ -1,51 +1,24 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import { schemaComposer, ResolverResolveParams } from 'graphql-compose';
-import {
-  GraphQLString,
-  GraphQLObjectType,
-  GraphQLInputObjectType,
-  GraphQLEnumType,
-  GraphQLInt,
-} from 'graphql-compose/lib/graphql';
-import type { ConnectionSortMapOpts } from '../connectionResolver';
+import type { ConnectionSortMapOpts } from '../connection';
 
-export const UserType = new GraphQLObjectType({
-  name: 'User',
-  fields: {
-    id: {
-      type: GraphQLInt,
-    },
-    name: {
-      type: GraphQLString,
-    },
-    age: {
-      type: GraphQLInt,
-    },
-    gender: {
-      type: GraphQLString,
-    },
-  },
-});
-
-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(`
+  type User {
+    id: Int
+    name: String
+    age: Int
+    gender: String
+  }
+`);
 
-export const userTC = schemaComposer.createObjectTC(UserType);
-export const userLinkTC = schemaComposer.createObjectTC(UserLinkType);
+export const UserLinkTC = schemaComposer.createObjectTC(`
+  type UserLink {
+    id: Int
+    type: String
+    userId: Int
+    otherUserId: Int
+  }
+`);
 
 export const userList = [
   { id: 1, name: 'user01', age: 11, gender: 'm' },
@@ -70,52 +43,29 @@ export const userLinkList = [
   { id: 2, type: 'dislikes', userId: 2, otherUserId: 1 },
 ];
 
-const filterArgConfig = {
-  name: 'filter',
-  type: new GraphQLInputObjectType({
-    name: 'FilterUserInput',
-    fields: {
-      gender: {
-        type: GraphQLString,
-      },
-      age: {
-        type: GraphQLInt,
-      },
-    },
-  }),
-};
+const filterArgConfig = schemaComposer.createInputTC(`
+  input FilterUserInput {
+    gender: String
+    age: Int
+  }
+`);
 
-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,
-            },
-          },
-        }),
-      },
-    },
-  }),
-};
+const filterEdgeArgConfig = schemaComposer.createInputTC({
+  name: 'FilterNodeEdgeUserInput',
+  fields: {
+    edge: `
+      input FilterNodeEdgeEdgeUserInput {
+        type: String
+      }
+    `,
+    node: `
+      input FilterNodeNodeEdgeUserInput {
+        gender: String
+        age: Int
+      }
+    `,
+  },
+});
 
 function filterUserLink(
   link: typeof userLinkList[0],
@@ -189,13 +139,13 @@ function prepareFilterFromArgs(resolveParams = {} as ResolverResolveParams<any,
   return filter;
 }
 
-export const findManyResolver = schemaComposer.createResolver({
+export const findManyResolver = schemaComposer.createResolver<any, any>({
   name: 'findMany',
   kind: 'query',
-  type: UserType,
+  type: UserTC,
   args: {
     filter: filterArgConfig,
-    sort: new GraphQLEnumType({
+    sort: UserTC.schemaComposer.createEnumTC({
       name: 'SortUserInput',
       values: {
         ID_ASC: { value: { id: 1 } },
@@ -204,8 +154,8 @@ export const findManyResolver = schemaComposer.createResolver({
         AGE_DESC: { value: { age: -1 } },
       },
     }),
-    limit: GraphQLInt,
-    skip: GraphQLInt,
+    limit: 'Int',
+    skip: 'Int',
   },
   resolve: (resolveParams) => {
     const args = resolveParams.args || {};
@@ -226,20 +176,18 @@ export const findManyResolver = schemaComposer.createResolver({
     return Promise.resolve(list);
   },
 });
-userTC.setResolver('findMany', findManyResolver);
 
 export const countResolver = schemaComposer.createResolver({
   name: 'count',
   kind: 'query',
-  type: GraphQLInt,
+  type: 'Int',
   args: {
     filter: filterArgConfig,
   },
   resolve: (resolveParams) => {
     return Promise.resolve(filteredUserList(userList, prepareFilterFromArgs(resolveParams)).length);
   },
 });
-userTC.setResolver('count', countResolver);
 
 function getThroughLinkResolver(list: typeof userLinkList, filter: any) {
   const nodeFilter = filter ? filter.node : {};
@@ -255,11 +203,11 @@ function getThroughLinkResolver(list: typeof userLinkList, filter: any) {
 export const findManyThroughLinkResolver = schemaComposer.createResolver({
   name: 'findManyThroughLink',
   kind: 'query',
-  type: UserType,
+  type: UserTC,
   args: {
     filter: filterEdgeArgConfig,
-    limit: GraphQLInt,
-    skip: GraphQLInt,
+    limit: 'Int',
+    skip: 'Int',
   },
   resolve: async (resolveParams) => {
     const args = resolveParams.args || {};
@@ -277,12 +225,11 @@ export const findManyThroughLinkResolver = schemaComposer.createResolver({
     return getThroughLinkResolver(list, args.filter);
   },
 });
-userTC.setResolver('findManyThroughLink', findManyThroughLinkResolver);
 
 export const countThroughLinkResolver = schemaComposer.createResolver({
   name: 'count',
   kind: 'query',
-  type: GraphQLInt,
+  type: 'Int',
   args: {
     filter: filterEdgeArgConfig,
   },
@@ -291,7 +238,6 @@ export const countThroughLinkResolver = schemaComposer.createResolver({
     return getThroughLinkResolver(userLinkList.slice(), args.filter).length;
   },
 });
-userTC.setResolver('countThroughLink', countThroughLinkResolver);
 
 export const sortOptions: ConnectionSortMapOpts = {
   ID_ASC: {