fix(connection): Add customization options to connection resolver (#218)

* Add customization options to connection resolver

* fix: flow type checking

* chore: add tests

Co-authored-by: Michael Beaumont <[email protected]>

Author: PeteMac88

src/composeWithMongoose.d.ts

@@ -4,7 +4,7 @@ import {
   ObjectTypeComposer,
 } from 'graphql-compose';
 import { Document, Model } from 'mongoose';
-import { ConnectionSortMapOpts } from './resolvers/connection';
+import { ConnectionOpts } from './resolvers/connection';
 import {
   FilterHelperArgsOpts,
   LimitHelperArgsOpts,
@@ -107,7 +107,7 @@ export type TypeConverterResolversOpts = {
     | {
         filter?: FilterHelperArgsOpts | false;
       };
-  connection?: ConnectionSortMapOpts | false;
+  connection?: ConnectionOpts | false;
   pagination?: PaginationResolverOpts | false;
 };
 

src/composeWithMongoose.js

@@ -14,7 +14,7 @@ import type {
 } from './resolvers/helpers';
 import MongoID from './types/mongoid';
 import type { PaginationResolverOpts } from './resolvers/pagination';
-import type { ConnectionSortMapOpts } from './resolvers/connection';
+import type { ConnectionOpts } from './resolvers/connection';
 
 export type ComposeWithMongooseOpts<TContext> = {|
   schemaComposer?: SchemaComposer<TContext>,
@@ -111,7 +111,7 @@ export type TypeConverterResolversOpts = {
     | {
         filter?: FilterHelperArgsOpts | false,
       },
-  connection?: ConnectionSortMapOpts | false,
+  connection?: ConnectionOpts<any> | false,
   pagination?: PaginationResolverOpts | false,
 };
 

src/resolvers/__tests__/connection-test.js

@@ -140,26 +140,38 @@ describe('connection() resolver', () => {
       await user2.save();
     });
 
-    it('should return Resolver object', () => {
+    it('should return Resolver object with default name', () => {
       const resolver = connection(UserModel, UserTC);
+      if (!resolver) throw new Error('Connection resolver is undefined');
       expect(resolver).toBeInstanceOf(Resolver);
+      expect(resolver.getNestedName()).toEqual('connection');
+    });
+
+    it('should return Resolver object with custom name', () => {
+      const resolver = connection(UserModel, UserTC, {
+        // $FlowFixMe
+        connectionResolverName: 'customConnection',
+      });
+      if (!resolver) throw new Error('Connection resolver is undefined');
+      expect(resolver).toBeInstanceOf(Resolver);
+      expect(resolver.getNestedName()).toEqual('customConnection');
     });
 
     it('Resolver object should have `filter` arg', () => {
       const resolver = connection(UserModel, UserTC);
-      if (!resolver) throw new Error('Connection resolveris undefined');
+      if (!resolver) throw new Error('Connection resolver is undefined');
       expect(resolver.hasArg('filter')).toBe(true);
     });
 
     it('Resolver object should have `sort` arg', () => {
       const resolver = connection(UserModel, UserTC);
-      if (!resolver) throw new Error('Connection resolveris undefined');
+      if (!resolver) throw new Error('Connection resolver is undefined');
       expect(resolver.hasArg('sort')).toBe(true);
     });
 
     it('Resolver object should have `connection args', () => {
       const resolver = connection(UserModel, UserTC);
-      if (!resolver) throw new Error('Connection resolveris undefined');
+      if (!resolver) throw new Error('Connection resolver is undefined');
       expect(resolver.hasArg('first')).toBe(true);
       expect(resolver.hasArg('last')).toBe(true);
       expect(resolver.hasArg('before')).toBe(true);
@@ -169,14 +181,14 @@ describe('connection() resolver', () => {
     describe('Resolver.resolve():Promise', () => {
       it('should be fulfilled Promise', async () => {
         const resolver = connection(UserModel, UserTC);
-        if (!resolver) throw new Error('Connection resolveris undefined');
+        if (!resolver) throw new Error('Connection resolver is undefined');
         const result = resolver.resolve({ args: { first: 20 } });
         await expect(result).resolves.toBeDefined();
       });
 
       it('should return array of documents in `edges`', async () => {
         const resolver = connection(UserModel, UserTC);
-        if (!resolver) throw new Error('Connection resolveris undefined');
+        if (!resolver) throw new Error('Connection resolver is undefined');
         const result = await resolver.resolve({ args: { first: 20 } });
 
         expect(result.edges).toBeInstanceOf(Array);
@@ -188,7 +200,7 @@ describe('connection() resolver', () => {
 
       it('should limit records', async () => {
         const resolver = connection(UserModel, UserTC);
-        if (!resolver) throw new Error('Connection resolveris undefined');
+        if (!resolver) throw new Error('Connection resolver is undefined');
         const result = await resolver.resolve({ args: { first: 1 } });
 
         expect(result.edges).toBeInstanceOf(Array);
@@ -197,7 +209,7 @@ describe('connection() resolver', () => {
 
       it('should sort records', async () => {
         const resolver = connection(UserModel, UserTC);
-        if (!resolver) throw new Error('Connection resolveris undefined');
+        if (!resolver) throw new Error('Connection resolver is undefined');
 
         const result1 = await resolver.resolve({
           args: { sort: { _id: 1 }, first: 1 },
@@ -212,7 +224,7 @@ describe('connection() resolver', () => {
 
       it('should return mongoose documents', async () => {
         const resolver = connection(UserModel, UserTC);
-        if (!resolver) throw new Error('Connection resolveris undefined');
+        if (!resolver) throw new Error('Connection resolver is undefined');
 
         const result = await resolver.resolve({ args: { first: 20 } });
         expect(result.edges[0].node).toBeInstanceOf(UserModel);
@@ -275,6 +287,24 @@ describe('connection() resolver', () => {
 
         expect(result).toHaveProperty('edges.0.node', { overrides: true });
       });
+
+      it('should return mongoose documents for custom resolvers from opts', async () => {
+        schemaComposer.clear();
+        UserTC = convertModelToGraphQL(UserModel, 'User', schemaComposer);
+        UserTC.setResolver('customFindMany', findMany(UserModel, UserTC));
+        UserTC.setResolver('customCount', count(UserModel, UserTC));
+        const resolver = connection(UserModel, UserTC, {
+          // $FlowFixMe
+          findResolverName: 'customFindMany',
+          // $FlowFixMe
+          countResolverName: 'customCount',
+        });
+        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);
+      });
     });
   });
 });

src/resolvers/connection.d.ts

@@ -1,4 +1,4 @@
-import { Resolver, ObjectTypeComposer } from 'graphql-compose';
+import { Resolver, ObjectTypeComposer, ObjectTypeComposerFieldConfigMap } from 'graphql-compose';
 // import { ConnectionSortMapOpts } from 'graphql-compose-connection';
 import { Model } from 'mongoose';
 import { MongoId } from '../types/mongoid';
@@ -7,12 +7,17 @@ import { FilterHelperArgs, SortHelperArgs } from './helpers';
 
 // @ts-todo The ConnectionSortMapOpts is not available yet since graphql-compose-connection doesn't have types for now,
 //          fallback to a simple object.
-export type ConnectionSortMapOpts = { [opt: string]: any };
+export type ConnectionOpts<TContext = any> = { [opt: string]: any } & {
+  connectionResolverName?: string,
+  findResolverName?: string;
+  countResolverName?: string;
+  edgeFields?: ObjectTypeComposerFieldConfigMap<any, TContext>;
+};
 
 export default function connection(
   model: Model<any>,
   tc: ObjectTypeComposer<any>,
-  opts?: ConnectionSortMapOpts,
+  opts?: ConnectionOpts<any>,
 ): Resolver<any, any> | undefined;
 
 export function prepareCursorQuery(

src/resolvers/connection.js

@@ -3,19 +3,28 @@
 
 import type { MongooseDocument } from 'mongoose';
 import type { ConnectionSortMapOpts as _ConnectionSortMapOpts } from 'graphql-compose-connection';
-import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
+import type {
+  Resolver,
+  ObjectTypeComposer,
+  ObjectTypeComposerFieldConfigMap,
+} from 'graphql-compose';
 import {
   getUniqueIndexes,
   extendByReversedIndexes,
   type IndexT,
 } from '../utils/getIndexesFromModel';
 
-export type ConnectionSortMapOpts = _ConnectionSortMapOpts;
+export type ConnectionOpts<TContext = any> = _ConnectionSortMapOpts & {
+  edgeFields?: ObjectTypeComposerFieldConfigMap<any, TContext>,
+  connectionResolverName?: string,
+  findResolverName?: string,
+  countResolverName?: string,
+};
 
 export default function connection<TSource: MongooseDocument, TContext>(
   model: Class<TSource>, // === MongooseModel
   tc: ObjectTypeComposer<TSource, TContext>,
-  opts?: ConnectionSortMapOpts
+  opts?: ConnectionOpts<TContext>
 ): ?Resolver<TSource, TContext> {
   try {
     require.resolve('graphql-compose-connection');
@@ -56,14 +65,22 @@ export default function connection<TSource: MongooseDocument, TContext>(
       },
     };
   });
-
+  const {
+    connectionResolverName = 'connection',
+    findResolverName = 'findMany',
+    countResolverName = 'count',
+    edgeFields,
+    ...sortOptions
+  } = opts || {};
   return prepareConnectionResolver(tc, {
-    findResolverName: 'findMany',
-    countResolverName: 'count',
+    connectionResolverName,
+    findResolverName,
+    countResolverName,
     sort: {
       ...sortConfigs,
-      ...opts,
+      ...sortOptions,
     },
+    edgeFields,
   });
 }