Add removeOne resolver

Author: nodkz

src/__mocks__/userModel.js

@@ -28,6 +28,11 @@ const UserSchema = new Schema(
       description: 'Person name',
     },
 
+    age: {
+      type: Number,
+      description: 'Full years',
+    },
+
     gender: {
       type: String,
       enum: ['male', 'female', 'ladyboy'],
@@ -65,11 +70,6 @@ const UserSchema = new Schema(
       description: 'Knowledge of languages',
     },
 
-    totalExperience: {
-      type: Number,
-      description: 'Work experience in months',
-    },
-
     // createdAt, created via option `timastamp: true`
 
     // updatedAt, created via option `timastamp: true`

src/__tests__/fieldConverter-test.js

@@ -94,7 +94,7 @@ describe('fieldConverter', () => {
     it('schould derive SCALAR', () => {
       expect(deriveComplexType(fields.name)).to.equal(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.relocation)).to.equal(ComplexTypes.SCALAR);
-      expect(deriveComplexType(fields.totalExperience)).to.equal(ComplexTypes.SCALAR);
+      expect(deriveComplexType(fields.age)).to.equal(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.createdAt)).to.equal(ComplexTypes.SCALAR);
 
       expect(deriveComplexType(fields.gender)).not.to.equal(ComplexTypes.SCALAR);

src/definition.js

@@ -20,12 +20,13 @@ export type MonooseModelIndex = [
 
 export type MongooseModelT = {
   schema: MongooseModelSchemaT,
-  findOne(criteria: ?Object, projection?: Object): MongooseQuery,
+  findOne(conditions: ?Object, projection?: Object): MongooseQuery,
   findById(id: mixed, projection?: Object, options?: Object): MongooseQuery,
   find(conditions: ?Object, projection?: Object, options?: Object): MongooseQuery,
   findOneAndRemove(conditions: ?Object, options?: Object): MongooseQuery,
-  where(criteria: ObjectMap): MongooseQuery,
+  where(conditions: ObjectMap): MongooseQuery,
   findByIdAndRemove(id: mixed, options?: Object): MongooseQuery,
+  findOneAndRemove(conditions: ?Object, options?: Object): MongooseQuery,
 }
 
 export type MongooseFieldOptionsT = {

src/resolvers/__tests__/removeOne-test.js

@@ -0,0 +1,155 @@
+/* @flow */
+
+import { expect } from 'chai';
+import { UserModel } from '../../__mocks__/userModel.js';
+import removeOne from '../removeOne';
+import Resolver from '../../../../graphql-compose/src/resolver/resolver';
+import TypeComposer from '../../../../graphql-compose/src/typeComposer';
+import { convertModelToGraphQL } from '../../fieldsConverter';
+import GraphQLMongoID from '../../types/mongoid';
+import { mongoose } from '../../__mocks__/mongooseCommon';
+
+const UserType = convertModelToGraphQL(UserModel, 'User');
+
+describe('removeOne() ->', () => {
+  let user1;
+  let user2;
+  let user3;
+
+  before('clear UserModel collection', (done) => {
+    UserModel.collection.drop(() => {
+      done();
+    });
+  });
+
+  beforeEach('add test user document to mongoDB', () => {
+    user1 = new UserModel({
+      name: 'userName1',
+      gender: 'male',
+      relocation: true,
+      age: 28,
+    });
+
+    user2 = new UserModel({
+      name: 'userName2',
+      gender: 'female',
+      relocation: true,
+      age: 29,
+    });
+
+    user3 = new UserModel({
+      name: 'userName3',
+      gender: 'female',
+      relocation: true,
+      age: 30,
+    });
+
+    return Promise.all([
+      user1.save(),
+      user2.save(),
+      user3.save(),
+    ]);
+  });
+
+  it('should return Resolver object', () => {
+    const resolver = removeOne(UserModel, UserType);
+    expect(resolver).to.be.instanceof(Resolver);
+  });
+
+  describe('Resolver.args', () => {
+    it('should have `filter` arg', () => {
+      const resolver = removeOne(UserModel, UserType);
+      expect(resolver.hasArg('filter')).to.be.true;
+    });
+
+    it('should not have `skip` arg due mongoose error: '
+     + 'skip cannot be used with findOneAndRemove', () => {
+      const resolver = removeOne(UserModel, UserType);
+      expect(resolver.hasArg('skip')).to.be.false;
+    });
+
+    it('should have `sort` arg', () => {
+      const resolver = removeOne(UserModel, UserType);
+      expect(resolver.hasArg('sort')).to.be.true;
+    });
+  });
+
+  describe('Resolver.resolve():Promise', () => {
+    it('should be promise', () => {
+      // some crazy shit for method `MongooseModel.findOneAndRemove`
+      // needs to set explicitly Promise object
+      // otherwise it returns Promise object, but it not instanse of global Promise
+      mongoose.Promise = Promise; // eslint-disable-line
+      const result = removeOne(UserModel, UserType).resolve({});
+      expect(result).instanceof(Promise);
+      result.catch(() => 'catch error if appears, hide it from mocha');
+    });
+
+    it('should return payload.recordId if record existed in db', async () => {
+      const result = await removeOne(UserModel, UserType).resolve({
+        args: { filter: { _id: user1.id } },
+      });
+      expect(result).have.property('recordId', user1.id);
+    });
+
+    it('should remove document in database', (done) => {
+      const checkedName = 'nameForMongoDB';
+      removeOne(UserModel, UserType).resolve({
+        args: {
+          filter: { _id: user1.id },
+          input: { name: checkedName },
+        },
+      }).then(() => {
+        UserModel.collection.findOne({ _id: user1._id }, (err, doc) => {
+          expect(err).to.be.null;
+          expect(doc).to.be.null;
+          done();
+        });
+      });
+    });
+
+    it('should return payload.record', async () => {
+      const result = await removeOne(UserModel, UserType).resolve({
+        args: { filter: { _id: user1.id } },
+      });
+      expect(result).have.deep.property('record.id', user1.id);
+    });
+
+    it('should sort records', async () => {
+      const result1 = await removeOne(UserModel, UserType).resolve({
+        args: {
+          filter: { relocation: true },
+          sort: { age: 1 },
+        },
+      });
+      expect(result1).have.deep.property('record.age', user1.age);
+
+      const result2 = await removeOne(UserModel, UserType).resolve({
+        args: {
+          filter: { relocation: true },
+          sort: { age: -1 },
+        },
+      });
+      expect(result2).have.deep.property('record.age', user3.age);
+    });
+  });
+
+  describe('Resolver.getOutputType()', () => {
+    it('should have correct output type name', () => {
+      const outputType = removeOne(UserModel, UserType).getOutputType();
+      expect(outputType).property('name').to.equal(`RemoveOne${UserType.name}Payload`);
+    });
+
+    it('should have recordId field', () => {
+      const outputType = removeOne(UserModel, UserType).getOutputType();
+      const recordIdField = new TypeComposer(outputType).getField('recordId');
+      expect(recordIdField).property('type').to.equal(GraphQLMongoID);
+    });
+
+    it('should have record field', () => {
+      const outputType = removeOne(UserModel, UserType).getOutputType();
+      const recordField = new TypeComposer(outputType).getField('record');
+      expect(recordField).property('type').to.equal(UserType);
+    });
+  });
+});

src/resolvers/removeOne.js

@@ -1,32 +1,69 @@
 /* @flow */
 /* eslint-disable no-param-reassign */
 
-import type {
-  MongooseModelT,
-  GraphQLObjectType,
-} from '../definition';
-import Resolver from '../../../graphql-compose/src/resolver/resolver';
+import { GraphQLObjectType } from 'graphql';
+import GraphQLMongoID from '../types/mongoid';
 
 import { skipHelperArgs, skipHelper } from './helpers/skip';
 import { filterHelperArgsGen, filterHelper } from './helpers/filter';
+import { sortHelperArgsGen, sortHelper } from './helpers/sort';
+import { projectionHelper } from './helpers/projection';
 
+import type {
+  MongooseModelT,
+  ExtendedResolveParams,
+} from '../definition';
+import Resolver from '../../../graphql-compose/src/resolver/resolver';
 
-export default function removeOne(model: MongooseModelT, gqType: GraphQLObjectType): Resolver {
-  const filterHelperArgs = filterHelperArgsGen();
-
-  return new Resolver({
-    outputType: 'someCrazy',
+export default function removeOne(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+): Resolver {
+  const resolver = new Resolver({
     name: 'removeOne',
+    kind: 'mutation',
+    description: 'Remove one document: '
+               + '1) Remove with hooks via findOneAndRemove. '
+               + '2) Return removed document.',
+    outputType: new GraphQLObjectType({
+      name: `RemoveOne${gqType.name}Payload`,
+      fields: {
+        recordId: {
+          type: GraphQLMongoID,
+          description: 'Removed document ID',
+        },
+        record: {
+          type: gqType,
+          description: 'Removed document',
+        },
+      },
+    }),
     args: {
-      ...filterHelperArgs,
-      ...skipHelperArgs,
+      ...filterHelperArgsGen(),
+      ...sortHelperArgsGen(model, {
+        sortTypeName: `Sort${gqType.name}Input`,
+      }),
     },
-    resolve: ({ args }) => {
-      let cursor = model.findOneAndRemove({});
-      cursor = filterHelper(cursor, args);
-      cursor = skipHelper(cursor, args);
+    resolve: (resolveParams: ExtendedResolveParams) => {
+      resolveParams.query = model.findOneAndRemove({});
+      filterHelper(resolveParams);
+      sortHelper(resolveParams);
+      projectionHelper(resolveParams);
 
-      return cursor;
+      return resolveParams.query
+        .exec()
+        .then(res => {
+          if (res) {
+            return {
+              record: res.toObject(),
+              recordId: res.id,
+            };
+          }
+
+          return null;
+        });
     },
   });
+
+  return resolver;
 }