feat: required fields from mongoose schema became required in GraphQL

closes #224

Author: nodkz

src/__mocks__/userModel.js

@@ -28,12 +28,17 @@ const UserSchema: SchemaType<any> = new Schema(
 
     name: {
       type: String,
+      required: true,
       description: 'Person name',
     },
 
     age: {
       type: Number,
       description: 'Full years',
+      required() {
+        // in graphql this field should be Nullable
+        return this.name === 'Something special';
+      },
     },
 
     gender: {
@@ -120,7 +125,7 @@ UserSchema.set('autoIndex', false);
 UserSchema.index({ name: 1, age: -1 });
 
 // eslint-disable-next-line
-UserSchema.virtual('nameVirtual').get(function() {
+UserSchema.virtual('nameVirtual').get(function () {
   return `VirtualFieldValue${this._id}`;
 });
 

src/__tests__/composeWithMongoose-test.js

@@ -208,8 +208,13 @@ describe('composeWithMongoose ->', () => {
           },
         },
       });
-      const filterArgInFindOne = typeComposer.getResolver('findOne').getArgITC('filter');
-      expect(filterArgInFindOne.isFieldNonNull('age')).toBe(true);
+
+      const ac = typeComposer.getResolver('createOne').getArgITC('record');
+      expect(ac.isFieldNonNull('age')).toBe(true);
+
+      // but should be nullable in filters
+      const ac2 = typeComposer.getResolver('findOne').getArgITC('filter');
+      expect(ac2.isFieldNonNull('age')).toBe(false);
     });
 
     it('should use cached type to avoid maximum call stack size exceeded', () => {

src/__tests__/composeWithMongooseDiscriminators-test.js

@@ -39,9 +39,8 @@ describe('composeWithMongooseDiscriminators ->', () => {
           },
         },
       });
-      const filterArgInFindOne: any = typeComposer.getResolver('findOne').getArg('filter');
-      const inputComposer = schemaComposer.createInputTC(filterArgInFindOne.type);
-      expect(inputComposer.isFieldNonNull('kind')).toBe(true);
+      const ac: any = typeComposer.getResolver('createOne').getArgTC('record');
+      expect(ac.isFieldNonNull('kind')).toBe(true);
     });
 
     it('should proceed customizationOptions.inputType.fields.required', () => {

src/__tests__/fieldConverter-test.js

@@ -275,7 +275,7 @@ describe('fieldConverter', () => {
     const tc = convertModelToGraphQL(UserModel, 'User', sc);
 
     it('should work with String', () => {
-      expect(tc.getFieldTypeName('name')).toBe('String');
+      expect(tc.getFieldTypeName('name')).toBe('String!');
       expect(tc.getFieldTypeName('skills')).toBe('[String]');
     });
 

src/fieldsConverter.js

@@ -140,10 +140,19 @@ export function convertModelToGraphQL<TSource, TContext>(
 
   const mongooseFields = getFieldsFromModel(model);
   const graphqlFields = {};
+  const requiredFields = [];
 
   Object.keys(mongooseFields).forEach((fieldName) => {
     const mongooseField: MongooseFieldT = mongooseFields[fieldName];
 
+    if (
+      (mongooseField: any).isRequired &&
+      // conditional required field in mongoose cannot be NonNulable in GraphQL
+      typeof (mongooseField: any).originalRequiredValue !== 'function'
+    ) {
+      requiredFields.push(fieldName);
+    }
+
     graphqlFields[fieldName] = {
       type: convertFieldToGraphQL(mongooseField, typeName, sc),
       description: _getFieldDescription(mongooseField),
@@ -165,6 +174,7 @@ export function convertModelToGraphQL<TSource, TContext>(
   });
 
   typeComposer.addFields(graphqlFields);
+  typeComposer.makeFieldNonNull(requiredFields);
   return typeComposer;
 }
 

src/resolvers/__tests__/createMany-test.js

@@ -187,8 +187,10 @@ describe('createMany() ->', () => {
 
   describe('Resolver.getType()', () => {
     it('should have correct output type name', () => {
-      const outputType: any = createMany(UserModel, UserTC).getType();
-      expect(outputType.name).toBe(`CreateMany${UserTC.getTypeName()}Payload`);
+      const resolver: any = createMany(UserModel, UserTC);
+      expect(resolver.getTypeName()).toBe(`CreateMany${UserTC.getTypeName()}Payload`);
+      expect(resolver.getArgITC('records').getFieldTypeName('name')).toBe('String!');
+      expect(resolver.getArgITC('records').getFieldTypeName('age')).toBe('Float');
     });
 
     it('should have recordIds field, NonNull List', () => {

src/resolvers/__tests__/createOne-test.js

@@ -114,8 +114,10 @@ describe('createOne() ->', () => {
 
   describe('Resolver.getType()', () => {
     it('should have correct output type name', () => {
-      const outputType: any = createOne(UserModel, UserTC).getType();
-      expect(outputType.name).toBe(`CreateOne${UserTC.getTypeName()}Payload`);
+      const resolver = createOne(UserModel, UserTC);
+      expect(resolver.getTypeName()).toBe(`CreateOne${UserTC.getTypeName()}Payload`);
+      expect(resolver.getArgITC('record').getFieldTypeName('name')).toBe('String!');
+      expect(resolver.getArgITC('record').getFieldTypeName('age')).toBe('Float');
     });
 
     it('should have recordId field', () => {

src/resolvers/__tests__/findMany-test.js

@@ -124,4 +124,12 @@ describe('findMany() ->', () => {
       expect(result).toEqual([{ overridden: true }]);
     });
   });
+
+  describe('Resolver.getType()', () => {
+    it('should have all fields optional in filter', () => {
+      const resolver = findMany(UserModel, UserTC);
+      expect(resolver.getArgITC('filter').getFieldTypeName('name')).toBe('String');
+      expect(resolver.getArgITC('filter').getFieldTypeName('age')).toBe('Float');
+    });
+  });
 });

src/resolvers/__tests__/findOne-test.js

@@ -138,5 +138,11 @@ describe('findOne() ->', () => {
       const outputType = findOne(UserModel, UserTC).getType();
       expect(outputType).toBe(UserTC.getType());
     });
+
+    it('should have all fields optional in filter', () => {
+      const resolver = findOne(UserModel, UserTC);
+      expect(resolver.getArgITC('filter').getFieldTypeName('name')).toBe('String');
+      expect(resolver.getArgITC('filter').getFieldTypeName('age')).toBe('Float');
+    });
   });
 });

src/resolvers/__tests__/removeMany-test.js

@@ -142,5 +142,11 @@ describe('removeMany() ->', () => {
       const outputType = removeMany(UserModel, UserTC).getType();
       expect(outputType).toBe(existedType.getType());
     });
+
+    it('should have all fields optional in filter', () => {
+      const resolver = removeMany(UserModel, UserTC);
+      expect(resolver.getArgITC('filter').getFieldTypeName('name')).toBe('String');
+      expect(resolver.getArgITC('filter').getFieldTypeName('age')).toBe('Float');
+    });
   });
 });