Add removeMany resolver

Author: nodkz

src/resolvers/__tests__/removeMany-test.js

@@ -0,0 +1,129 @@
+/* @flow */
+
+import { expect } from 'chai';
+import { UserModel } from '../../__mocks__/userModel.js';
+import removeMany from '../removeMany';
+import Resolver from '../../../../graphql-compose/src/resolver/resolver';
+import TypeComposer from '../../../../graphql-compose/src/typeComposer';
+import { convertModelToGraphQL } from '../../fieldsConverter';
+import { GraphQLInt, GraphQLNonNull } from 'graphql';
+
+const UserType = convertModelToGraphQL(UserModel, 'User');
+
+describe('removeMany() ->', () => {
+  let user1;
+  let user2;
+  let user3;
+
+  beforeEach('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 = removeMany(UserModel, UserType);
+    expect(resolver).to.be.instanceof(Resolver);
+  });
+
+  describe('Resolver.args', () => {
+    it('should have required `filter` arg', () => {
+      const resolver = removeMany(UserModel, UserType);
+      const filterField = resolver.getArg('filter');
+      expect(filterField).to.be.ok;
+      expect(filterField).property('type').instanceof(GraphQLNonNull);
+    });
+  });
+
+  describe('Resolver.resolve():Promise', () => {
+    it('should be promise', () => {
+      const result = removeMany(UserModel, UserType).resolve({});
+      expect(result).instanceof(Promise);
+      result.catch(() => 'catch error if appear, hide it from mocha');
+    });
+
+    it('should rejected with Error if args.filter is empty', async () => {
+      const result = removeMany(UserModel, UserType).resolve({ args: {} });
+      await expect(result).be.rejectedWith(Error, 'at least one value in args.filter');
+    });
+
+    it('should remove data in database', (done) => {
+      removeMany(UserModel, UserType).resolve({
+        args: {
+          filter: { _id: user1.id },
+        },
+      }).then(() => {
+        UserModel.collection.findOne({ _id: user1._id }, (err, doc) => {
+          expect(err).to.be.null;
+          expect(doc).to.be.null;
+          done();
+        });
+      });
+    });
+
+    it('should not remove unsuitable data to filter in database', (done) => {
+      removeMany(UserModel, UserType).resolve({
+        args: {
+          filter: { _id: user1.id },
+        },
+      }).then(() => {
+        UserModel.collection.findOne({ _id: user2._id }, (err, doc) => {
+          expect(err).to.be.null;
+          expect(doc).to.be.ok;
+          done();
+        });
+      });
+    });
+
+    it('should return payload.numAffected', async () => {
+      const result = await removeMany(UserModel, UserType).resolve({
+        args: {
+          filter: { gender: 'female' },
+        },
+      });
+      expect(result).have.property('numAffected', 2);
+    });
+  });
+
+  describe('Resolver.getOutputType()', () => {
+    it('should have correct output type name', () => {
+      const outputType = removeMany(UserModel, UserType).getOutputType();
+      expect(outputType).property('name').to.equal(`RemoveMany${UserType.name}Payload`);
+    });
+
+    it('should have numAffected field', () => {
+      const outputType = removeMany(UserModel, UserType).getOutputType();
+      const numAffectedField = new TypeComposer(outputType).getField('numAffected');
+      expect(numAffectedField).property('type').to.equal(GraphQLInt);
+    });
+  });
+});

src/resolvers/removeMany.js

@@ -1 +1,67 @@
 /* @flow */
+/* eslint-disable no-param-reassign */
+import { filterHelperArgsGen, filterHelper } from './helpers/filter';
+import { GraphQLObjectType, GraphQLInt } from 'graphql';
+
+import type {
+  MongooseModelT,
+  ExtendedResolveParams,
+} from '../definition';
+import Resolver from '../../../graphql-compose/src/resolver/resolver';
+
+export default function removeMany(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+): Resolver {
+  const resolver = new Resolver({
+    name: 'removeMany',
+    kind: 'mutation',
+    description: 'Remove many documents without returning them: '
+               + 'Use Query.remove mongoose method. '
+               + 'Do not apply mongoose defaults, setters, hooks and validation. ',
+    outputType: new GraphQLObjectType({
+      name: `RemoveMany${gqType.name}Payload`,
+      fields: {
+        numAffected: {
+          type: GraphQLInt,
+          description: 'Affected documents number',
+        },
+      },
+    }),
+    args: {
+      ...filterHelperArgsGen(model, {
+        filterTypeName: `Filter${gqType.name}Input`,
+        isRequired: true,
+      }),
+    },
+    resolve: (resolveParams: ExtendedResolveParams) => {
+      const filterData = resolveParams.args && resolveParams.args.filter || {};
+
+      if (!(typeof filterData === 'object')
+        || Object.keys(filterData).length === 0
+      ) {
+        return Promise.reject(
+          new Error(`${gqType.name}.removeMany resolver requires at least one value in args.filter`)
+        );
+      }
+
+      resolveParams.query = model.find();
+      filterHelper(resolveParams);
+      resolveParams.query = resolveParams.query.remove();
+
+      return resolveParams.query
+        .exec()
+        .then(res => {
+          if (res.result && res.result.ok) {
+            return {
+              numAffected: res.result.n,
+            };
+          }
+
+          return Promise.reject(res);
+        });
+    },
+  });
+
+  return resolver;
+}