feat(MongoID): allow to override build-in MongoID type

```js
schemaComposer.set('MongoID', YOUR_TYPE_IMPLEMENTATION);
const UserTC = composeWithMongoose(UserModel, { schemaComposer });
```

Related #98

Author: nodkz

src/__tests__/fieldConverter-test.js

@@ -118,14 +118,38 @@ describe('fieldConverter', () => {
       };
       expect(convertFieldToGraphQL(mongooseField, '', schemaComposer)).toBe('String');
     });
+
+    it('should add GraphQLMongoID to schemaComposer', () => {
+      schemaComposer.clear();
+      expect(schemaComposer.has('MongoID')).toBeFalsy();
+      const mongooseField = {
+        path: 'strFieldName',
+        instance: 'ObjectID',
+      };
+      expect(convertFieldToGraphQL(mongooseField, '', schemaComposer)).toBe('MongoID');
+      expect(schemaComposer.get('MongoID')).toBe(GraphQLMongoID);
+    });
+
+    it('should use existed GraphQLMongoID in schemaComposer', () => {
+      schemaComposer.clear();
+      expect(schemaComposer.has('MongoID')).toBeFalsy();
+      schemaComposer.set('MongoID', ('MockGraphQLType': any));
+      const mongooseField = {
+        path: 'strFieldName',
+        instance: 'ObjectID',
+      };
+      expect(convertFieldToGraphQL(mongooseField, '', schemaComposer)).toBe('MongoID');
+      expect(schemaComposer.get('MongoID')).toBe('MockGraphQLType');
+      schemaComposer.delete('MongoID');
+    });
   });
 
   describe('scalarToGraphQL()', () => {
     it('should properly convert mongoose scalar type to default graphQL types', () => {
       expect(scalarToGraphQL({ instance: 'String' })).toBe('String');
       expect(scalarToGraphQL({ instance: 'Number' })).toBe('Float');
       expect(scalarToGraphQL({ instance: 'Boolean' })).toBe('Boolean');
-      expect(scalarToGraphQL({ instance: 'ObjectID' })).toBe(GraphQLMongoID);
+      expect(scalarToGraphQL({ instance: 'ObjectID' })).toBe('MongoID');
     });
 
     it('should properly convert mongoose scalar type to scalar graphql-compose types', () => {
@@ -196,7 +220,7 @@ describe('fieldConverter', () => {
 
   describe('referenceToGraphQL()', () => {
     it('should return type of field', () => {
-      expect(referenceToGraphQL(fields.user)).toBe(GraphQLMongoID);
+      expect(referenceToGraphQL(fields.user)).toBe('MongoID');
     });
   });
 });

src/composeWithMongoose.js

@@ -14,6 +14,7 @@ import type {
   SortHelperArgsOpts,
   RecordHelperArgsOpts,
 } from './resolvers/helpers';
+import MongoID from './types/mongoid';
 
 export type TypeConverterOpts = {
   schemaComposer?: SchemaComposer<any>,
@@ -120,6 +121,7 @@ export function composeWithMongoose(
   const name: string = (opts && opts.name) || model.modelName;
 
   const sc = opts.schemaComposer || schemaComposer;
+  sc.set('MongoID', MongoID);
   const tc = convertModelToGraphQL(model, name, sc);
 
   if (opts.description) {

src/fieldsConverter.js

@@ -188,6 +188,10 @@ export function convertFieldToGraphQL(
   prefix?: string = '',
   schemaComposer: SchemaComposer<any>
 ): ComposeOutputType {
+  if (!schemaComposer.has('MongoID')) {
+    schemaComposer.set('MongoID', GraphQLMongoID);
+  }
+
   const complexType = deriveComplexType(field);
   switch (complexType) {
     case ComplexTypes.SCALAR:
@@ -257,7 +261,7 @@ export function scalarToGraphQL(field: MongooseFieldT): ComposeScalarType {
     case 'Boolean':
       return 'Boolean';
     case 'ObjectID':
-      return GraphQLMongoID;
+      return 'MongoID';
     default:
       return 'JSON';
   }

src/resolvers/__tests__/createOne-test.js

@@ -33,7 +33,7 @@ describe('createOne() ->', () => {
   describe('Resolver.args', () => {
     it('should have required `record` arg', () => {
       const resolver = createOne(UserModel, UserTC);
-      const argConfig: any = resolver.getArg('record');
+      const argConfig: any = resolver.getArgConfig('record');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType.name).toBe('CreateOneUserInput');
     });

src/resolvers/__tests__/findById-test.js

@@ -48,7 +48,7 @@ describe('findById() ->', () => {
     it('should have non-null `_id` arg', () => {
       const resolver = findById(UserModel, UserTC);
       expect(resolver.hasArg('_id')).toBe(true);
-      const argConfig: any = resolver.getArg('_id');
+      const argConfig: any = resolver.getArgConfig('_id');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType).toBe(GraphQLMongoID);
     });

src/resolvers/__tests__/findByIds-test.js

@@ -58,7 +58,7 @@ describe('findByIds() ->', () => {
     it('should have non-null `_ids` arg', () => {
       const resolver = findByIds(UserModel, UserTC);
       expect(resolver.hasArg('_ids')).toBe(true);
-      const argConfig: any = resolver.getArg('_ids');
+      const argConfig: any = resolver.getArgConfig('_ids');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType).toBeInstanceOf(GraphQLList);
       expect(argConfig.type.ofType.ofType).toBe(GraphQLMongoID);

src/resolvers/__tests__/removeById-test.js

@@ -45,7 +45,7 @@ describe('removeById() ->', () => {
     it('should have non-null `_id` arg', () => {
       const resolver = removeById(UserModel, UserTC);
       expect(resolver.hasArg('_id')).toBe(true);
-      const argConfig: any = resolver.getArg('_id');
+      const argConfig: any = resolver.getArgConfig('_id');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType).toBe(GraphQLMongoID);
     });

src/resolvers/__tests__/updateById-test.js

@@ -56,14 +56,14 @@ describe('updateById() ->', () => {
   describe('Resolver.args', () => {
     it('should have `record` arg', () => {
       const resolver = updateById(UserModel, UserTC);
-      const argConfig: any = resolver.getArg('record');
+      const argConfig: any = resolver.getArgConfig('record');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType.name).toBe('UpdateByIdUserInput');
     });
 
     it('should have `record._id` required arg', () => {
       const resolver = updateById(UserModel, UserTC);
-      const argConfig: any = resolver.getArg('record') || {};
+      const argConfig: any = resolver.getArgConfig('record') || {};
       expect(argConfig.type.ofType).toBeInstanceOf(GraphQLInputObjectType);
       if (argConfig.type && argConfig.type.ofType) {
         const _idFieldType = new InputTypeComposer(argConfig.type.ofType).getFieldType('_id');

src/resolvers/__tests__/updateMany-test.js

@@ -70,7 +70,7 @@ describe('updateMany() ->', () => {
 
     it('should have `record` arg', () => {
       const resolver = updateMany(UserModel, UserTC);
-      const argConfig: any = resolver.getArg('record');
+      const argConfig: any = resolver.getArgConfig('record');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType.name).toBe('UpdateManyUserInput');
     });

src/resolvers/__tests__/updateOne-test.js

@@ -67,7 +67,7 @@ describe('updateOne() ->', () => {
 
     it('should have required `record` arg', () => {
       const resolver = updateOne(UserModel, UserTC);
-      const argConfig: any = resolver.getArg('record');
+      const argConfig: any = resolver.getArgConfig('record');
       expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
       expect(argConfig.type.ofType.name).toBe('UpdateOneUserInput');
     });