feat: add createMany Resolver (thanks @mernxl)

* feat(resolvers): add `createMany` resolver
* test(discriminators): add test cases and optimise tests
* doc: update README.md with newly added `createMany` resolver info

Author: mernxl

README.md

@@ -105,7 +105,8 @@ schemaComposer.Query.addFields({
 });
 
 schemaComposer.Mutation.addFields({
-  userCreate: UserTC.getResolver('createOne'),
+  userCreateOne: UserTC.getResolver('createOne'),
+  userCreateMany: UserTC.getResolver('createMany'),
   userUpdateById: UserTC.getResolver('updateById'),
   userUpdateOne: UserTC.getResolver('updateOne'),
   userUpdateMany: UserTC.getResolver('updateMany'),
@@ -374,17 +375,18 @@ fragment fullImageData on EmbeddedImage {
 ```
 
 ### Access and modify mongoose doc before save
-This library provides some amount of ready resolvers for fetch and update data which was mentioned above. And you can [create your own resolver](https://github.com/graphql-compose/graphql-compose) of course. However you can find that add some actions or light modifications of mongoose document directly before save at existing resolvers appears more simple than create new resolver. Some of resolvers accepts *before save hook* wich can be provided in *resolver params* as param named `beforeRecordMutate`. This hook allows to have access and modify mongoose document before save. The resolvers which supports this hook are:
+This library provides some amount of ready resolvers for fetch and update data which was mentioned above. And you can [create your own resolver](https://github.com/graphql-compose/graphql-compose) of course. However you can find that add some actions or light modifications of mongoose document directly before save at existing resolvers appears more simple than create new resolver. Some of resolvers accepts *before save hook* which can be provided in *resolver params* as param named `beforeRecordMutate`. This hook allows to have access and modify mongoose document before save. The resolvers which supports this hook are:
 
 * createOne
+* createMany
 * removeById
 * removeOne
 * updateById
 * updateOne
 
-The protype of before save hook:
+The prototype of before save hook:
 ```js
-(record: mixed, rp: ExtendedResolveParams) => Promise<*>,
+(doc: mixed, rp: ExtendedResolveParams) => Promise<*>,
 ```
 
 The typical implementation may be like this:
@@ -434,6 +436,7 @@ function adminAccess(resolvers) {
 // and wrap the resolvers
 schemaComposer.Mutation.addFields({
   createResource: ResourceTC.getResolver('createOne'),
+  createResources: ResourceTC.getResolver('createMany'),
   ...adminAccess({
     updateResource: ResourceTC.getResolver('updateById'),
     removeResource: ResourceTC.getResolver('removeById'),
@@ -522,6 +525,9 @@ export type typeConverterResolversOpts = {
   createOne?: false | {
     record?: recordHelperArgsOpts | false,
   },
+  createMany?: false | {
+    records?: recordHelperArgsOpts | false,
+  },
   count?: false | {
     filter?: filterHelperArgsOpts | false,
   },

src/__tests__/composeWithMongooseDiscriminators-test.js

@@ -72,5 +72,21 @@ describe('composeWithMongooseDiscriminators ->', () => {
       expect(createOneRecordArgTC.isRequired('name')).toBe(true);
       expect(createOneRecordArgTC.hasField('friends')).toBe(false);
     });
+
+    it('should pass down records opts to createMany resolver', () => {
+      const typeComposer = composeWithMongooseDiscriminators(CharacterModel, {
+        resolvers: {
+          createMany: {
+            records: {
+              removeFields: ['friends'],
+              requiredFields: ['name'],
+            },
+          },
+        },
+      });
+      const createManyRecordsArgTC = typeComposer.getResolver('createMany').getArgTC('records');
+      expect(createManyRecordsArgTC.isRequired('name')).toBe(true);
+      expect(createManyRecordsArgTC.hasField('friends')).toBe(false);
+    });
   });
 });

src/composeWithMongoose.js

@@ -101,6 +101,11 @@ export type TypeConverterResolversOpts = {
     | {
         record?: RecordHelperArgsOpts | false,
       },
+  createMany?:
+    | false
+    | {
+        records?: RecordHelperArgsOpts | false,
+      },
   count?:
     | false
     | {

src/discriminators/__tests__/prepareBaseResolvers-test.js

@@ -1,90 +1,108 @@
 /* @flow */
 
 import { graphql } from 'graphql-compose';
-import { getCharacterModels } from '../__mocks__/characterModels';
 import { composeWithMongooseDiscriminators } from '../../composeWithMongooseDiscriminators';
+import { getCharacterModels } from '../__mocks__/characterModels';
 
 const { CharacterModel } = getCharacterModels('type');
 
 const CharacterDTC = composeWithMongooseDiscriminators(CharacterModel);
+const DKeyFieldName = CharacterDTC.getDKey();
+const DKeyETC = CharacterDTC.getDKeyETC();
+const DInterfaceTC = CharacterDTC.getDInterface();
 
 describe('prepareBaseResolvers()', () => {
   describe('setDKeyEnumOnITCArgs()', () => {
-    const resolversWithFilterAndRecordArgs = [];
-    const resolversWithFilterArgsOnly = [];
-    const resolversWithRecordArgsOnly = [];
-    const resolversWithNoInterestArgs = [];
-    const interestArgs = ['filter', 'record'];
+    const resolversWithFilterArgs = [];
+    const resolversWithRecordArgs = [];
+    const resolversWithRecordsArgs = [];
+    const interestArgs = ['filter', 'record', 'records'];
 
     beforeAll(() => {
       const resolvers = CharacterDTC.getResolvers(); // map
 
       resolvers.forEach(resolver => {
-        if (resolver.hasArg(interestArgs[0]) && resolver.hasArg(interestArgs[1])) {
-          resolversWithFilterAndRecordArgs.push(resolver);
-        } else if (!(resolver.hasArg(interestArgs[0]) && resolver.hasArg(interestArgs[1]))) {
-          resolversWithNoInterestArgs.push(resolver);
-        } else if (resolver.hasArg(interestArgs[0]) && !resolver.hasArg(interestArgs[1])) {
-          resolversWithFilterArgsOnly.push(resolver);
-        } else if (!resolver.hasArg(interestArgs[0]) && resolver.hasArg(interestArgs[1])) {
-          resolversWithRecordArgsOnly.push(resolver);
+        const argNames = resolver.getArgNames();
+
+        for (const argName of argNames) {
+          if (argName === interestArgs[0]) {
+            resolversWithFilterArgs.push(resolver);
+          }
+          if (argName === interestArgs[1]) {
+            resolversWithRecordArgs.push(resolver);
+          }
+          if (argName === interestArgs[2]) {
+            resolversWithRecordsArgs.push(resolver);
+          }
         }
       });
     });
 
-    it('should set type to DKeyEnum on DKey field on filter and record args', () => {
-      for (const resolver of resolversWithFilterAndRecordArgs) {
-        for (const arg of interestArgs) {
-          expect(resolver.getArgTC(arg).getFieldType(CharacterDTC.getDKey())).toEqual(
-            CharacterDTC.getDKeyETC().getType()
-          );
-        }
-      }
-    });
-
-    it('should set type to DKeyEnum on DKey field only on filter args', () => {
-      for (const resolver of resolversWithFilterArgsOnly) {
+    it('should set DKey field type to DKeyETC on filter args', () => {
+      for (const resolver of resolversWithFilterArgs) {
         expect(interestArgs[0]).toEqual('filter');
-        expect(resolver.getArgTC(interestArgs[0]).getFieldType(CharacterDTC.getDKey())).toEqual(
-          CharacterDTC.getDKeyETC().getType()
-        );
-        expect(resolver.getArgTC(interestArgs[1]).getFieldType(CharacterDTC.getDKey())).not.toEqual(
+        expect(resolver.getArgTC(interestArgs[0]).getFieldConfig(DKeyFieldName).type).toEqual(
           CharacterDTC.getDKeyETC().getType()
         );
       }
     });
 
-    it('should set type to DKeyEnum on DKey field only on record args', () => {
-      for (const resolver of resolversWithFilterArgsOnly) {
+    it('should set DKey field type to DKeyETC on record args', () => {
+      for (const resolver of resolversWithRecordArgs) {
         expect(interestArgs[1]).toEqual('record');
-        expect(resolver.getArgTC(interestArgs[1]).getFieldType(CharacterDTC.getDKey())).toEqual(
-          CharacterDTC.getDKeyETC().getType()
-        );
-        expect(resolver.getArgTC(interestArgs[0]).getFieldType(CharacterDTC.getDKey())).not.toEqual(
-          CharacterDTC.getDKeyETC().getType()
-        );
+        if (resolver.name === 'createOne') {
+          expect(resolver.getArgTC(interestArgs[1]).getFieldConfig(DKeyFieldName).type).toEqual(
+            graphql.GraphQLNonNull(DKeyETC.getType())
+          );
+        } else {
+          expect(resolver.getArgTC(interestArgs[1]).getFieldConfig(DKeyFieldName).type).toEqual(
+            DKeyETC.getType()
+          );
+        }
       }
     });
 
-    it('should NOT set type to DKeyEnum on DKey as filter and record not found args', () => {
-      for (const resolver of resolversWithFilterArgsOnly) {
-        for (const arg of interestArgs) {
-          expect(resolver.hasArg(arg)).toBeFalsy();
-        }
+    it('should set DKey field type to DKeyETC on records args', () => {
+      for (const resolver of resolversWithRecordsArgs) {
+        expect(interestArgs[2]).toEqual('records');
+        expect(resolver.getArgTC(interestArgs[2]).getFieldConfig(DKeyFieldName).type).toEqual(
+          graphql.GraphQLNonNull(DKeyETC.getType())
+        );
       }
     });
   });
 
-  it('should set resolver type to DInterface List, findMany', () => {
-    expect(CharacterDTC.getResolver('findMany').getType()).toEqual(
-      graphql.GraphQLList(CharacterDTC.getDInterface().getType())
-    );
+  describe('createOne: Resolver', () => {
+    const resolver = CharacterDTC.getResolver('createOne');
+    it('should set resolver record field type to DInterface', () => {
+      expect(resolver.getTypeComposer().getFieldType('record')).toEqual(DInterfaceTC.getType());
+    });
   });
 
-  it('should set resolver type to DInterface List, findByIds', () => {
-    expect(CharacterDTC.getResolver('findByIds').getType()).toEqual(
-      graphql.GraphQLList(CharacterDTC.getDInterface().getType())
-    );
+  describe('createMany: Resolver', () => {
+    const resolver = CharacterDTC.getResolver('createMany');
+    it('should set resolver records field type to NonNull Plural DInterface', () => {
+      expect(resolver.getTypeComposer().getFieldType('records')).toEqual(
+        new graphql.GraphQLNonNull(graphql.GraphQLList(DInterfaceTC.getType()))
+      );
+    });
+  });
+
+  describe('findById: Resolver', () => {
+    const resolver = CharacterDTC.getResolver('findByIds');
+    it('should set resolver type to DInterface List', () => {
+      expect(resolver.getType()).toEqual(
+        graphql.GraphQLList(CharacterDTC.getDInterface().getType())
+      );
+    });
+  });
+
+  describe('findMany: Resolver', () => {
+    it('should set resolver type to DInterface List', () => {
+      expect(CharacterDTC.getResolver('findMany').getType()).toEqual(
+        graphql.GraphQLList(DInterfaceTC.getType())
+      );
+    });
   });
 
   it('should set resolver type to DInterface, findOne', () => {
@@ -99,14 +117,6 @@ describe('prepareBaseResolvers()', () => {
     );
   });
 
-  it('should set resolver record field type to DInterface, createOne', () => {
-    expect(
-      CharacterDTC.getResolver('createOne')
-        .getTypeComposer()
-        .getFieldType('record')
-    ).toEqual(CharacterDTC.getDInterface().getType());
-  });
-
   it('should set resolver record field type to DInterface, updateOne', () => {
     expect(
       CharacterDTC.getResolver('updateOne')
@@ -131,7 +141,7 @@ describe('prepareBaseResolvers()', () => {
     ).toEqual(CharacterDTC.getDInterface().getType());
   });
 
-  it('should set resolver record arg field, DKey to NonNull DKeyETC type, createOne', () => {
+  it('should set DKey field type to NonNull(DKeyETC) on record arg, createOne', () => {
     expect(
       CharacterDTC.getResolver('createOne')
         .getArgTC('record')

src/discriminators/__tests__/prepareChildResolvers-test.js

@@ -1,12 +1,99 @@
 /* @flow */
 
-import { schemaComposer } from 'graphql-compose';
-import { getCharacterModels } from '../__mocks__/characterModels';
+import { schemaComposer, TypeComposer } from 'graphql-compose';
 import { composeWithMongooseDiscriminators } from '../../composeWithMongooseDiscriminators';
+import { getCharacterModels } from '../__mocks__/characterModels';
 
-const { CharacterModel, PersonModel } = getCharacterModels('type');
+const DKeyFieldName = 'type';
+const { CharacterModel, PersonModel } = getCharacterModels(DKeyFieldName);
+
+beforeAll(() => (CharacterModel: any).base.connect());
+afterAll(() => (CharacterModel: any).base.disconnect());
 
 describe('prepareChildResolvers()', () => {
+  describe('setQueryDKey()', () => {
+    let PersonTC: TypeComposer;
+
+    beforeAll(() => {
+      PersonTC = composeWithMongooseDiscriminators(CharacterModel).discriminator(PersonModel);
+    });
+
+    beforeEach(async () => {
+      await PersonModel.remove({});
+    });
+
+    it('should set DKey on createOne', async () => {
+      const res = await PersonTC.getResolver('createOne').resolve({
+        args: {
+          record: { name: 'Agent 007', dob: 124343 },
+        },
+      });
+
+      expect(res.record[DKeyFieldName]).toBe(PersonModel.modelName);
+    });
+
+    it('should set DKey on createMany', async () => {
+      const res = await PersonTC.getResolver('createMany').resolve({
+        args: {
+          records: [{ name: 'Agent 007', dob: 124343 }, { name: 'Agent 007', dob: 124343 }],
+        },
+      });
+
+      expect(res.records[0][DKeyFieldName]).toBe(PersonModel.modelName);
+      expect(res.records[1][DKeyFieldName]).toBe(PersonModel.modelName);
+    });
+  });
+
+  describe('hideDKey()', () => {
+    const resolversWithFilterArgs = [];
+    const resolversWithRecordArgs = [];
+    const resolversWithRecordsArgs = [];
+    const interestArgs = ['filter', 'record', 'records'];
+
+    beforeAll(() => {
+      const PersonTC = composeWithMongooseDiscriminators(CharacterModel).discriminator(PersonModel);
+
+      const resolvers = PersonTC.getResolvers();
+
+      resolvers.forEach(resolver => {
+        const argNames = resolver.getArgNames();
+
+        for (const argName of argNames) {
+          if (argName === interestArgs[0]) {
+            resolversWithFilterArgs.push(resolver);
+          }
+          if (argName === interestArgs[1]) {
+            resolversWithRecordArgs.push(resolver);
+          }
+          if (argName === interestArgs[2]) {
+            resolversWithRecordsArgs.push(resolver);
+          }
+        }
+      });
+    });
+
+    it('should hide DKey field on filter args', () => {
+      for (const resolver of resolversWithFilterArgs) {
+        expect(interestArgs[0]).toEqual('filter');
+        expect(resolver.getArgTC(interestArgs[0]).hasField(DKeyFieldName)).toBeFalsy();
+      }
+    });
+
+    it('should hide DKey field on record args', () => {
+      for (const resolver of resolversWithRecordArgs) {
+        expect(interestArgs[1]).toEqual('record');
+        expect(resolver.getArgTC(interestArgs[1]).hasField(DKeyFieldName)).toBeFalsy();
+      }
+    });
+
+    it('should hide DKey field on records args', () => {
+      for (const resolver of resolversWithRecordsArgs) {
+        expect(interestArgs[2]).toEqual('records');
+        expect(resolver.getArgTC(interestArgs[2]).hasField(DKeyFieldName)).toBeFalsy();
+      }
+    });
+  });
+
   describe('copyResolverArgTypes()', () => {
     afterAll(() => {
       schemaComposer.clear();