fix: improve typedefs for connection resolver factory (#338)

* Improve typedefs for connection resolver factory * Fix lint problem Co-authored-by: Yoad <[email protected]>
graphql-compose · May 18, 2021 · dbc609d · dbc609d
1 parent a4e0662
commit dbc609d
Show file tree

Hide file tree

Showing 3 changed files with 41 additions and 12 deletions.
diff --git a/README.md b/README.md
@@ -376,7 +376,8 @@ UserTC.mongooseResolvers.findMany(opts);
 
 ```ts
 type ConnectionResolverOpts<TContext = any> = {
-  sort: ConnectionSortMapOpts;
+  /** See below **/
+  sort?: ConnectionSortMapOpts;
   name?: string;
   defaultLimit?: number | undefined;
   edgeTypeName?: string;
@@ -388,6 +389,15 @@ type ConnectionResolverOpts<TContext = any> = {
 }
 ```
 
+The `countOpts` and `findManyOpts` props would be used to customize the internally created `findMany` and `count` resolver factories used by the connection resolver.
+If not provided the default configuration for each of the resolver factories is assumed.
+
+The `sort` prop is optional. When provided it is used to customize the sorting behaviour of the connection. When not provided, the sorting configuration is derived from the existing indexes on the model.
+
+Please refer to the documentation of the [graphql-compose-connection](https://github.com/graphql-compose/graphql-compose-connection) plugin for more details on the sorting customization parameter.
+
+
+
 ### `count(opts?: CountResolverOpts)`
 
 ```ts

diff --git a/src/resolvers/__tests__/connection-test.ts b/src/resolvers/__tests__/connection-test.ts
@@ -7,6 +7,13 @@ import { count } from '../count';
 import { convertModelToGraphQL } from '../../fieldsConverter';
 import { ExtendedResolveParams } from '..';
 
+jest.mock('../findMany', () => ({
+  findMany: jest.fn((...args) => jest.requireActual('../findMany').findMany(...args)),
+}));
+jest.mock('../count', () => ({
+  count: jest.fn((...args) => jest.requireActual('../count').count(...args)),
+}));
+
 beforeAll(() => UserModel.base.createConnection());
 afterAll(() => UserModel.base.disconnect());
 
@@ -111,8 +118,6 @@ describe('connection() resolver', () => {
     beforeEach(() => {
       schemaComposer.clear();
       UserTC = convertModelToGraphQL(UserModel, 'User', schemaComposer);
-      UserTC.setResolver('findMany', findMany(UserModel, UserTC));
-      UserTC.setResolver('count', count(UserModel, UserTC));
     });
 
     let user1: IUser;
@@ -287,20 +292,23 @@ describe('connection() resolver', () => {
         expect(result).toHaveProperty('edges.0.node', { overrides: true });
       });
 
-      it('should return mongoose documents for custom resolvers from opts', async () => {
+      it('should use internal resolver custom opts', async () => {
         schemaComposer.clear();
         UserTC = convertModelToGraphQL(UserModel, 'User', schemaComposer);
-        UserTC.setResolver('customFindMany', findMany(UserModel, UserTC));
-        UserTC.setResolver('customCount', count(UserModel, UserTC));
+        const mockCountOpts = { suffix: 'ABC' };
+        const mockFindManyOpts = { suffix: 'DEF' };
         const resolver = connection(UserModel, UserTC, {
-          findResolverName: 'customFindMany',
-          countResolverName: 'customCount',
+          countOpts: mockCountOpts,
+          findManyOpts: mockFindManyOpts,
         } as any);
         if (!resolver) throw new Error('Connection resolver is undefined');
 
-        const result = await resolver.resolve({ args: { first: 20 } });
-        expect(result.edges[0].node).toBeInstanceOf(UserModel);
-        expect(result.edges[1].node).toBeInstanceOf(UserModel);
+        expect(count).toHaveBeenCalledWith(expect.anything(), expect.anything(), mockCountOpts);
+        expect(findMany).toHaveBeenCalledWith(
+          expect.anything(),
+          expect.anything(),
+          mockFindManyOpts
+        );
       });
     });
   });

diff --git a/src/resolvers/connection.ts b/src/resolvers/connection.ts
@@ -2,19 +2,30 @@ import type { Document, Model } from 'mongoose';
 import {
   prepareConnectionResolver,
   ConnectionResolverOpts as _ConnectionResolverOpts,
+  ConnectionSortMapOpts as _ConnectionSortMapOpts,
   ConnectionTArgs,
 } from 'graphql-compose-connection';
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import { CountResolverOpts, count } from './count';
 import { FindManyResolverOpts, findMany } from './findMany';
 import { getUniqueIndexes, extendByReversedIndexes, IndexT } from '../utils/getIndexesFromModel';
 
+/**
+ * Allows customization of the generated `connection` resolver.
+ *
+ * It is based on the `ConnectionResolverOpts` from: https://github.com/graphql-compose/graphql-compose-connection
+ * With the following changes:
+ * - `sort` prop is optional - when not provided derived from existing model indexes
+ * - `findManyResolver` prop is removed - use the optional `findManyOpts` to customize the internally created `findMany` resolver
+ * - `countResolver` prop is removed - use the optional `countOpts` to customize the internally created `count` resolver
+ */
 export type ConnectionResolverOpts<TContext = any> = Omit<
   _ConnectionResolverOpts<TContext>,
-  'countResolver' | 'findManyResolver'
+  'countResolver' | 'findManyResolver' | 'sort'
 > & {
   countOpts?: CountResolverOpts;
   findManyOpts?: FindManyResolverOpts;
+  sort?: _ConnectionSortMapOpts;
 };
 
 export function connection<TSource = any, TContext = any, TDoc extends Document = any>(