refactor: get rid of TC.getResolver() method

BREAKING CHANGE: change config options. Get rid of `TC.getResolver()` method. Now you need to pass Resolver instance explicitly.

Author: nodkz

README.md

@@ -23,25 +23,20 @@ Modules `graphql` and `graphql-compose` are in `peerDependencies`, so should be
 ## Example
 
 ```js
-import composeWithPagination from 'graphql-compose-pagination';
-import userTypeComposer from './user.js';
+import { preparePaginationResolver } from 'graphql-compose-pagination';
+import { UserTC, findManyResolver, countResolver } from './user';
 
-composeWithPagination(userTypeComposer, {
-  paginationResolverName: 'pagination', // Default
-  findResolverName: 'findMany',
-  countResolverName: 'count',
+const paginationResolver = preparePaginationResolver(UserTC, {
+  findManyResolver,
+  countResolver,
+  name: 'pagination', // Default
   perPage: 20, // Default
 });
 ```
 
-<img width="832" alt="screen shot 2017-08-07 at 23 31 46" src="https://user-images.githubusercontent.com/1946920/29038210-ad2390e4-7bc8-11e7-8143-ff0cca2b39cc.png">
-
-## Requirements
+Implementation of `findManyResolver` and `countResolver` can be found in [this file](./src/__mocks__/User.ts).
 
-Types should have following resolvers:
-
-- `count` - for records count
-- `findMany` - for filtering records. Resolver `findMany` should have `limit` and `skip` args.
+<img width="832" alt="screen shot 2017-08-07 at 23 31 46" src="https://user-images.githubusercontent.com/1946920/29038210-ad2390e4-7bc8-11e7-8143-ff0cca2b39cc.png">
 
 ## Used in plugins
 

package.json

@@ -23,26 +23,26 @@
   },
   "homepage": "https://github.com/graphql-compose/graphql-compose-pagination",
   "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.1",
-    "@typescript-eslint/parser": "3.9.1",
-    "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__/User.ts

@@ -93,7 +93,7 @@ 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: UserTC,
@@ -130,7 +130,6 @@ export const findManyResolver = schemaComposer.createResolver({
     return Promise.resolve(list);
   },
 });
-UserTC.setResolver('findMany', findManyResolver);
 
 export const countResolver = schemaComposer.createResolver({
   name: 'count',
@@ -143,4 +142,3 @@ export const countResolver = schemaComposer.createResolver({
     return Promise.resolve(filteredUserList(userList, prepareFilterFromArgs(resolveParams)).length);
   },
 });
-UserTC.setResolver('count', countResolver);

src/__tests__/composeWithPagination-test.ts

@@ -1,12 +1,12 @@
 import { ObjectTypeComposer, schemaComposer } from 'graphql-compose';
 import { GraphQLList, graphql } from 'graphql-compose/lib/graphql';
 import { composeWithPagination } from '../composeWithPagination';
-import { UserTC } from '../__mocks__/User';
+import { UserTC, countResolver, findManyResolver } from '../__mocks__/User';
 
-describe('composeWithRelay', () => {
+describe('composeWithPagination', () => {
   const userComposer = composeWithPagination(UserTC, {
-    countResolverName: 'count',
-    findResolverName: 'findMany',
+    countResolver,
+    findManyResolver,
     perPage: 5,
   });
 
@@ -32,17 +32,17 @@ describe('composeWithRelay', () => {
       }).toThrowError('should provide non-empty options');
     });
 
-    it('should not change `pagination` resolver if exists', () => {
+    it('should not change `pagination` resolver if it already exists', () => {
       let myTC = schemaComposer.createObjectTC('type Complex { a: String, b: Int }');
       myTC.addResolver({
         name: 'pagination',
         resolve: () => 'mockData',
       });
 
-      // try ovewrite `pagination` resolver
+      // try overwrite `pagination` resolver
       myTC = composeWithPagination(myTC, {
-        countResolverName: 'count',
-        findResolverName: 'findMany',
+        countResolver,
+        findManyResolver,
       });
 
       expect(myTC.getResolver('pagination')).toBeTruthy();
@@ -60,33 +60,33 @@ describe('composeWithRelay', () => {
         resolve: () => ['mockData'],
       });
       myTC = composeWithPagination(myTC, {
-        paginationResolverName: 'customPagination',
-        countResolverName: 'count',
-        findResolverName: 'findMany',
+        name: 'customPagination',
+        countResolver,
+        findManyResolver,
       });
 
       expect(myTC.getResolver('customPagination')).toBeTruthy();
       expect(myTC.hasResolver('pagination')).toBeFalsy();
     });
 
-    it('should add two connection resolvers', () => {
+    it('should return different resolvers', () => {
       let myTC = schemaComposer.createObjectTC('type CustomComplex { a: String, b: Int }');
-      myTC.addResolver({
+      const myCountResolver = schemaComposer.createResolver({
         name: 'count',
         resolve: () => 1,
       });
-      myTC.addResolver({
+      const myFindManyResolver = schemaComposer.createResolver({
         name: 'findMany',
         resolve: () => ['mockData'],
       });
       myTC = composeWithPagination(myTC, {
-        countResolverName: 'count',
-        findResolverName: 'findMany',
+        countResolver: myCountResolver,
+        findManyResolver: myFindManyResolver,
       });
       myTC = composeWithPagination(myTC, {
-        paginationResolverName: 'customPagination',
-        countResolverName: 'count',
-        findResolverName: 'findMany',
+        name: 'customPagination',
+        countResolver: myCountResolver,
+        findManyResolver: myFindManyResolver,
       });
 
       expect(myTC.hasResolver('pagination')).toBeTruthy();

src/__tests__/mocks-userTypeComposer-test.ts

@@ -1,18 +1,18 @@
-import { UserTC } from '../__mocks__/User';
+import { countResolver, findManyResolver } from '../__mocks__/User';
 
 describe('mocks/UserTC', () => {
-  it('UserTC should have `count` resolver', async () => {
-    const cnt = await UserTC.getResolver('count').resolve({});
+  it('UserTC should have `countResolver`', async () => {
+    const cnt = await countResolver.resolve({});
     expect(cnt).toBe(15);
   });
 
-  it('UserTC should have `findMany` resolver', async () => {
-    const res = await UserTC.getResolver('findMany').resolve({});
+  it('UserTC should have `findManyResolver`', async () => {
+    const res = await findManyResolver.resolve({});
     expect(res).toHaveLength(15);
   });
 
-  it('UserTC should have `findMany` resolver with working `filter` arg', async () => {
-    const res = await UserTC.getResolver('findMany').resolve({
+  it('UserTC should have `findManyResolver` with working `filter` arg', async () => {
+    const res = await findManyResolver.resolve({
       args: {
         filter: {
           gender: 'm',
@@ -32,8 +32,8 @@ describe('mocks/UserTC', () => {
     expect(res).toEqual([{ id: 9, name: 'user09', age: 19, gender: 'm' }]);
   });
 
-  it('UserTC should have `findMany` resolver with working `sort` arg', async () => {
-    const res = await UserTC.getResolver('findMany').resolve({
+  it('UserTC should have `findManyResolver` with working `sort` arg', async () => {
+    const res = await findManyResolver.resolve({
       args: {
         sort: {
           age: -1,

src/__tests__/paginationResolver-test.ts src/__tests__/pagination-test.ts

@@ -1,14 +1,14 @@
 import { Resolver, ResolverResolveParams } from 'graphql-compose';
 import { GraphQLInt } from 'graphql-compose/lib/graphql';
-import { UserTC } from '../__mocks__/User';
-import { preparePaginationResolver } from '../paginationResolver';
+import { UserTC, countResolver, findManyResolver } from '../__mocks__/User';
+import { preparePaginationResolver } from '../pagination';
 
-describe('paginationResolver', () => {
-  const spyFindManyResolve = jest.spyOn(UserTC.getResolver('findMany'), 'resolve');
-  const spyCountResolve = jest.spyOn(UserTC.getResolver('count'), 'resolve');
+describe('preparePaginationResolver()', () => {
+  const spyFindManyResolve = jest.spyOn(findManyResolver, 'resolve');
+  const spyCountResolve = jest.spyOn(countResolver, 'resolve');
   const paginationResolver = preparePaginationResolver(UserTC, {
-    countResolverName: 'count',
-    findResolverName: 'findMany',
+    countResolver,
+    findManyResolver,
     perPage: 5,
   });
 
@@ -25,38 +25,36 @@ describe('paginationResolver', () => {
       }).toThrowError('should be instance of ObjectTypeComposer');
     });
 
-    it('should throw error if opts.countResolverName are empty', () => {
+    it('should throw error if opts.countResolverName are empty or wrong', () => {
       expect(() => {
         const wrongArgs = [UserTC, {}];
         // @ts-expect-error
         preparePaginationResolver(...wrongArgs);
-      }).toThrowError('should have option `opts.countResolverName`');
-    });
+      }).toThrowError("'opts.countResolver' must be a Resolver instance");
 
-    it('should throw error if resolver opts.countResolverName does not exists', () => {
       expect(() =>
         preparePaginationResolver(UserTC, {
-          countResolverName: 'countDoesNotExists',
-          findResolverName: 'findMany',
+          // @ts-expect-error
+          countResolver: 'countDoesNotExists',
+          findManyResolver,
         })
-      ).toThrowError("does not have resolver with name 'countDoesNotExists'");
+      ).toThrowError("'opts.countResolver' must be a Resolver instance");
     });
 
-    it('should throw error if opts.findResolverName are empty', () => {
+    it('should throw error if opts.findManyResolver are empty or wrong', () => {
       expect(() => {
         const wrongArgs = [UserTC, { countResolverName: 'count' }];
         // @ts-expect-error
         preparePaginationResolver(...wrongArgs);
-      }).toThrowError('should have option `opts.findResolverName`');
-    });
+      }).toThrowError("'opts.countResolver' must be a Resolver instance");
 
-    it('should throw error if resolver opts.countResolverName does not exists', () => {
       expect(() =>
         preparePaginationResolver(UserTC, {
-          countResolverName: 'count',
-          findResolverName: 'findManyDoesNotExists',
+          countResolver,
+          // @ts-expect-error
+          findManyResolver: 'findManyDoesNotExists',
         })
-      ).toThrowError("does not have resolver with name 'findManyDoesNotExists'");
+      ).toThrowError("'opts.findManyResolver' must be a Resolver instance");
     });
   });
 
@@ -93,23 +91,19 @@ describe('paginationResolver', () => {
     beforeEach(() => {
       findManyResolverCalled = false;
       countResolverCalled = false;
-      const mockedFindMany = UserTC.getResolver('findMany').wrapResolve(
-        (next) => (resolveParams) => {
-          findManyResolverCalled = true;
-          spyResolveParams = resolveParams;
-          return next(resolveParams);
-        }
-      );
-      const mockedCount = UserTC.getResolver('findMany').wrapResolve((next) => (resolveParams) => {
+      const mockedFindMany = findManyResolver.wrapResolve((next) => (resolveParams) => {
+        findManyResolverCalled = true;
+        spyResolveParams = resolveParams;
+        return next(resolveParams);
+      });
+      const mockedCount = countResolver.wrapResolve((next) => (resolveParams) => {
         countResolverCalled = true;
         spyResolveParams = resolveParams;
         return next(resolveParams);
       });
-      UserTC.setResolver('mockedFindMany', mockedFindMany);
-      UserTC.setResolver('mockedCount', mockedCount);
       mockedPaginationResolver = preparePaginationResolver(UserTC, {
-        countResolverName: 'mockedCount',
-        findResolverName: 'mockedFindMany',
+        countResolver: mockedCount,
+        findManyResolver: mockedFindMany,
       });
     });
 

src/__tests__/preparePaginationType-test.ts src/__tests__/types-test.ts

@@ -1,7 +1,7 @@
 import { ObjectTypeComposer } from 'graphql-compose';
 import { GraphQLNonNull, getNamedType, GraphQLInt, GraphQLList } from 'graphql-compose/lib/graphql';
 import { UserTC } from '../__mocks__/User';
-import { preparePaginationTC, preparePaginationInfoTC } from '../preparePaginationType';
+import { preparePaginationTC, preparePaginationInfoTC } from '../types';
 
 describe('preparePaginationTC()', () => {
   it('should return ObjectTypeComposer', () => {

src/composeWithPagination.ts

@@ -3,7 +3,7 @@ import {
   preparePaginationResolver,
   ComposeWithPaginationOpts,
   DEFAULT_RESOLVER_NAME,
-} from './paginationResolver';
+} from './pagination';
 
 export function composeWithPagination<TSource, TContext>(
   typeComposer: ObjectTypeComposer<TSource, TContext>,
@@ -19,14 +19,12 @@ export function composeWithPagination<TSource, TContext>(
     throw new Error('You should provide non-empty options to composeWithPagination');
   }
 
-  const resolverName = opts.paginationResolverName || DEFAULT_RESOLVER_NAME;
-
+  const resolverName = opts.name || DEFAULT_RESOLVER_NAME;
   if (typeComposer.hasResolver(resolverName)) {
     return typeComposer;
   }
-
   const resolver = preparePaginationResolver(typeComposer, opts);
-
   typeComposer.setResolver(resolverName, resolver);
+
   return typeComposer;
 }

src/index.ts

@@ -1,13 +1,11 @@
+import { preparePaginationResolver } from './pagination';
 import { composeWithPagination } from './composeWithPagination';
-import { preparePaginationResolver } from './paginationResolver';
-
-export default composeWithPagination;
 
 export { composeWithPagination, preparePaginationResolver };
 
 export type {
   ComposeWithPaginationOpts,
-  PaginationResolveParams,
+  PaginationTArgs,
   PaginationType,
   PaginationInfoType,
-} from './paginationResolver';
+} from './pagination';