refactor resolvers: change gqType on TypeComposer

Author: nodkz

.eslintignore

@@ -0,0 +1,2 @@
+lib/*
+es/*

src/__mocks__/userModel.js

@@ -93,7 +93,7 @@ UserSchema.virtual('nameVirtual').get(function () { // eslint-disable-line
 });
 
 
-const UserModel = mongoose.model('UserModel', UserSchema);
+const UserModel = mongoose.model('User', UserSchema);
 
 export {
   UserSchema,

src/__tests__/fieldConverter-test.js

@@ -27,7 +27,7 @@ import {
   GraphQLDate,
   GraphQLBuffer,
   GraphQLGeneric,
-} from '../../../graphql-compose/src/type';
+} from 'graphql-compose';
 
 /*
 Object.prototype.getClassName = function getClassName() {

src/__tests__/modelConverter-test.js

@@ -3,9 +3,7 @@
 import { expect } from 'chai';
 import { UserModel } from '../__mocks__/userModel.js';
 import { mongooseModelToTypeComposer as mm2tc } from '../modelConverter';
-
-import TypeComposer from 'graphql-compose/lib/typeComposer';
-import InputTypeComposer from 'graphql-compose/lib/inputTypeComposer';
+import { TypeComposer, InputTypeComposer } from 'graphql-compose';
 
 
 describe('modelConverter', () => {

src/modelConverter.js

@@ -17,7 +17,7 @@ import type {
 export function mongooseModelToTypeComposer(
   model: MongooseModelT,
   opts: typeConverterOpts = {}
-): GraphQLObjectType {
+): TypeComposer {
   const name: string = (opts && opts.name) || model.modelName;
 
   const type = convertModelToGraphQL(model, name);
@@ -31,6 +31,8 @@ export function mongooseModelToTypeComposer(
     prepareFields(typeComposer, opts.fields);
   }
 
+  typeComposer.setRecordIdFn((source) => `${source._id}`);
+
   createInputType(typeComposer, opts.inputType);
 
   if (!opts.hasOwnProperty('resolvers') || opts.resolvers !== false) {
@@ -112,7 +114,7 @@ export function createResolvers(
       const createResolverFn = resolvers[resolverName];
       const resolver = createResolverFn(
         model,
-        typeComposer.getType(),
+        typeComposer,
         opts[resolverName] || {}
       );
       typeComposer.setResolver(resolver);

src/resolvers/__tests__/count-test.js

@@ -3,12 +3,11 @@
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import count from '../count';
-import Resolver from 'graphql-compose/lib/resolver/resolver';
-import { GraphQLObjectType, GraphQLInt } from 'graphql';
+import { Resolver } from 'graphql-compose';
+import { mongooseModelToTypeComposer } from '../../modelConverter';
+import { GraphQLInt } from 'graphql';
 
-const UserType = new GraphQLObjectType({
-  name: 'MockUserType',
-});
+const UserTypeComposer = mongooseModelToTypeComposer(UserModel);
 
 describe('count() ->', () => {
   let user1;
@@ -42,30 +41,30 @@ describe('count() ->', () => {
   });
 
   it('should return Resolver object', () => {
-    const resolver = count(UserModel, UserType);
+    const resolver = count(UserModel, UserTypeComposer);
     expect(resolver).to.be.instanceof(Resolver);
   });
 
   describe('Resolver.args', () => {
     it('should have `filter` arg', () => {
-      const resolver = count(UserModel, UserType);
+      const resolver = count(UserModel, UserTypeComposer);
       expect(resolver.hasArg('filter')).to.be.true;
     });
   });
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled promise', async () => {
-      const result = count(UserModel, UserType).resolve({});
+      const result = count(UserModel, UserTypeComposer).resolve({});
       await expect(result).be.fulfilled;
     });
 
     it('should return total number of documents in collection if args is empty', async () => {
-      const result = await count(UserModel, UserType).resolve({ args: {} });
+      const result = await count(UserModel, UserTypeComposer).resolve({ args: {} });
       expect(result).to.equal(2);
     });
 
     it('should return number of document by filter data', async () => {
-      const result = await count(UserModel, UserType).resolve(
+      const result = await count(UserModel, UserTypeComposer).resolve(
         { args: { filter: { gender: 'male' } } }
       );
       expect(result).to.equal(1);
@@ -74,7 +73,7 @@ describe('count() ->', () => {
 
   describe('Resolver.getOutputType()', () => {
     it('should return GraphQLInt type', () => {
-      const outputType = count(UserModel, UserType).getOutputType();
+      const outputType = count(UserModel, UserTypeComposer).getOutputType();
       expect(outputType).to.equal(GraphQLInt);
     });
   });

src/resolvers/__tests__/createOne-test.js

@@ -3,13 +3,12 @@
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import createOne from '../createOne';
-import Resolver from 'graphql-compose/lib/resolver/resolver';
-import TypeComposer from 'graphql-compose/lib/typeComposer';
-import { convertModelToGraphQL } from '../../fieldsConverter';
+import { Resolver, TypeComposer } from 'graphql-compose';
+import { mongooseModelToTypeComposer } from '../../modelConverter';
 import GraphQLMongoID from '../../types/mongoid';
 import { GraphQLNonNull } from 'graphql';
 
-const UserType = convertModelToGraphQL(UserModel, 'User');
+const UserTypeComposer = mongooseModelToTypeComposer(UserModel);
 
 describe('createOne() ->', () => {
   before('clear UserModel collection', (done) => {
@@ -19,13 +18,13 @@ describe('createOne() ->', () => {
   });
 
   it('should return Resolver object', () => {
-    const resolver = createOne(UserModel, UserType);
+    const resolver = createOne(UserModel, UserTypeComposer);
     expect(resolver).to.be.instanceof(Resolver);
   });
 
   describe('Resolver.args', () => {
     it('should have required `input` arg', () => {
-      const resolver = createOne(UserModel, UserType);
+      const resolver = createOne(UserModel, UserTypeComposer);
       const argConfig = resolver.getArg('input');
       expect(argConfig).property('type').instanceof(GraphQLNonNull);
       expect(argConfig).deep.property('type.ofType.name', 'CreateOneUserInput');
@@ -34,18 +33,18 @@ describe('createOne() ->', () => {
 
   describe('Resolver.resolve():Promise', () => {
     it('should be promise', () => {
-      const result = createOne(UserModel, UserType).resolve({});
+      const result = createOne(UserModel, UserTypeComposer).resolve({});
       expect(result).instanceof(Promise);
       result.catch(() => 'catch error if appear, hide it from mocha');
     });
 
     it('should rejected with Error if args.input is empty', async () => {
-      const result = createOne(UserModel, UserType).resolve({ args: {} });
+      const result = createOne(UserModel, UserTypeComposer).resolve({ args: {} });
       await expect(result).be.rejectedWith(Error, 'at least one value in args.input');
     });
 
     it('should return payload.recordId', async () => {
-      const result = await createOne(UserModel, UserType).resolve({
+      const result = await createOne(UserModel, UserTypeComposer).resolve({
         args: {
           input: { name: 'newName' },
         },
@@ -54,7 +53,7 @@ describe('createOne() ->', () => {
     });
 
     it('should create document with args.input', async () => {
-      const result = await createOne(UserModel, UserType).resolve({
+      const result = await createOne(UserModel, UserTypeComposer).resolve({
         args: {
           input: { name: 'newName' },
         },
@@ -64,7 +63,7 @@ describe('createOne() ->', () => {
 
     it('should save document to database', (done) => {
       const checkedName = 'nameForMongoDB';
-      createOne(UserModel, UserType).resolve({
+      createOne(UserModel, UserTypeComposer).resolve({
         args: {
           input: { name: checkedName },
         },
@@ -77,7 +76,7 @@ describe('createOne() ->', () => {
     });
 
     it('should return payload.record', async () => {
-      const result = await createOne(UserModel, UserType).resolve({
+      const result = await createOne(UserModel, UserTypeComposer).resolve({
         args: {
           input: { name: 'NewUser' },
         },
@@ -88,20 +87,21 @@ describe('createOne() ->', () => {
 
   describe('Resolver.getOutputType()', () => {
     it('should have correct output type name', () => {
-      const outputType = createOne(UserModel, UserType).getOutputType();
-      expect(outputType).property('name').to.equal(`CreateOne${UserType.name}Payload`);
+      const outputType = createOne(UserModel, UserTypeComposer).getOutputType();
+      expect(outputType).property('name')
+        .to.equal(`CreateOne${UserTypeComposer.getTypeName()}Payload`);
     });
 
     it('should have recordId field', () => {
-      const outputType = createOne(UserModel, UserType).getOutputType();
+      const outputType = createOne(UserModel, UserTypeComposer).getOutputType();
       const recordIdField = new TypeComposer(outputType).getField('recordId');
       expect(recordIdField).property('type').to.equal(GraphQLMongoID);
     });
 
     it('should have record field', () => {
-      const outputType = createOne(UserModel, UserType).getOutputType();
+      const outputType = createOne(UserModel, UserTypeComposer).getOutputType();
       const recordField = new TypeComposer(outputType).getField('record');
-      expect(recordField).property('type').to.equal(UserType);
+      expect(recordField).property('type').to.equal(UserTypeComposer.getType());
     });
   });
 });

src/resolvers/__tests__/findById-test.js

@@ -3,12 +3,12 @@
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findById from '../findById';
-import Resolver from 'graphql-compose/lib/resolver/resolver';
+import { Resolver } from 'graphql-compose';
 import { GraphQLNonNull } from 'graphql';
 import GraphQLMongoID from '../../types/mongoid';
-import { convertModelToGraphQL } from '../../fieldsConverter';
+import { mongooseModelToTypeComposer } from '../../modelConverter';
 
-const UserType = convertModelToGraphQL(UserModel, 'User');
+const UserTypeComposer = mongooseModelToTypeComposer(UserModel);
 
 describe('findById() ->', () => {
   let user;
@@ -25,13 +25,13 @@ describe('findById() ->', () => {
   });
 
   it('should return Resolver object', () => {
-    const resolver = findById(UserModel, UserType);
+    const resolver = findById(UserModel, UserTypeComposer);
     expect(resolver).to.be.instanceof(Resolver);
   });
 
   describe('Resolver.args', () => {
     it('should have non-null `_id` arg', () => {
-      const resolver = findById(UserModel, UserType);
+      const resolver = findById(UserModel, UserTypeComposer);
       expect(resolver.hasArg('_id')).to.be.true;
       const argConfig = resolver.getArg('_id');
       expect(argConfig).property('type').that.instanceof(GraphQLNonNull);
@@ -41,22 +41,23 @@ describe('findById() ->', () => {
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled promise', async () => {
-      const result = findById(UserModel, UserType).resolve({});
+      const result = findById(UserModel, UserTypeComposer).resolve({});
       await expect(result).be.fulfilled;
     });
 
     it('should be rejected if args.id is not objectId', async () => {
-      const result = findById(UserModel, UserType).resolve({ args: { _id: 1 } });
+      const result = findById(UserModel, UserTypeComposer).resolve({ args: { _id: 1 } });
       await expect(result).be.rejected;
     });
 
     it('should return null if args.id is empty', async () => {
-      const result = await findById(UserModel, UserType).resolve({});
+      const result = await findById(UserModel, UserTypeComposer).resolve({});
       expect(result).equal(null);
     });
 
     it('should return document if provided existed id', async () => {
-      const result = await findById(UserModel, UserType).resolve({ args: { _id: user._id } });
+      const result = await findById(UserModel, UserTypeComposer)
+        .resolve({ args: { _id: user._id } });
       expect(result).have.property('name').that.equal(user.name);
     });
   });

src/resolvers/__tests__/findByIds-test.js

@@ -3,12 +3,12 @@
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findByIds from '../findByIds';
-import Resolver from 'graphql-compose/lib/resolver/resolver';
+import { Resolver } from 'graphql-compose';
 import { GraphQLNonNull, GraphQLList } from 'graphql';
 import GraphQLMongoID from '../../types/mongoid';
-import { convertModelToGraphQL } from '../../fieldsConverter';
+import { mongooseModelToTypeComposer } from '../../modelConverter';
 
-const UserType = convertModelToGraphQL(UserModel, 'User');
+const UserTypeComposer = mongooseModelToTypeComposer(UserModel);
 
 describe('findByIds() ->', () => {
   let user1;
@@ -34,13 +34,13 @@ describe('findByIds() ->', () => {
   });
 
   it('should return Resolver object', () => {
-    const resolver = findByIds(UserModel, UserType);
+    const resolver = findByIds(UserModel, UserTypeComposer);
     expect(resolver).to.be.instanceof(Resolver);
   });
 
   describe('Resolver.args', () => {
     it('should have non-null `_ids` arg', () => {
-      const resolver = findByIds(UserModel, UserType);
+      const resolver = findByIds(UserModel, UserTypeComposer);
       expect(resolver.hasArg('_ids')).to.be.true;
       const argConfig = resolver.getArg('_ids');
       expect(argConfig).property('type').that.instanceof(GraphQLNonNull);
@@ -49,36 +49,36 @@ describe('findByIds() ->', () => {
     });
 
     it('should have `limit` arg', () => {
-      const resolver = findByIds(UserModel, UserType);
+      const resolver = findByIds(UserModel, UserTypeComposer);
       expect(resolver.hasArg('limit')).to.be.true;
     });
 
     it('should have `sort` arg', () => {
-      const resolver = findByIds(UserModel, UserType);
+      const resolver = findByIds(UserModel, UserTypeComposer);
       expect(resolver.hasArg('sort')).to.be.true;
     });
   });
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled promise', async () => {
-      const result = findByIds(UserModel, UserType).resolve({});
+      const result = findByIds(UserModel, UserTypeComposer).resolve({});
       await expect(result).be.fulfilled;
     });
 
     it('should return empty array if args._ids is empty', async () => {
-      const result = await findByIds(UserModel, UserType).resolve({});
+      const result = await findByIds(UserModel, UserTypeComposer).resolve({});
       expect(result).to.be.instanceOf(Array);
       expect(result).to.be.empty;
     });
 
     it('should return empty array if args._ids is not valid objectIds', async () => {
-      const result = await findByIds(UserModel, UserType).resolve({ args: { _ids: ['d', 'e'] } });
+      const result = await findByIds(UserModel, UserTypeComposer).resolve({ args: { _ids: ['d', 'e'] } });
       expect(result).to.be.instanceOf(Array);
       expect(result).to.be.empty;
     });
 
     it('should return array of documents', async () => {
-      const result = await findByIds(UserModel, UserType)
+      const result = await findByIds(UserModel, UserTypeComposer)
         .resolve({ args: { _ids: [user1._id, user2._id, user3._id] } });
 
       expect(result).to.be.instanceOf(Array);
@@ -89,7 +89,7 @@ describe('findByIds() ->', () => {
 
     it('should return array of documents if object id is string', async () => {
       const stringId = `${user1._id}`;
-      const result = await findByIds(UserModel, UserType)
+      const result = await findByIds(UserModel, UserTypeComposer)
         .resolve({ args: { _ids: [stringId] } });
 
       expect(result).to.be.instanceOf(Array);