Add count resolver

Author: nodkz

src/definition.js

@@ -61,6 +61,7 @@ export type MongooseQuery = {
   setOptions(opts: ObjectMap): MongooseQuery,
   update(data: ObjectMap): MongooseQuery,
   remove(conditions: ?Object, options?: Object): MongooseQuery,
+  count(conditions: ?Object): MongooseQuery,
 };
 
 export type MongoseDocument = {

src/resolvers/__tests__/count-test.js

@@ -0,0 +1,81 @@
+/* @flow */
+
+import { expect } from 'chai';
+import { UserModel } from '../../__mocks__/userModel.js';
+import count from '../count';
+import Resolver from '../../../../graphql-compose/src/resolver/resolver';
+import { GraphQLObjectType, GraphQLInt } from 'graphql';
+
+const UserType = new GraphQLObjectType({
+  name: 'MockUserType',
+});
+
+describe('count() ->', () => {
+  let user1;
+  let user2;
+
+  before('clear UserModel collection', (done) => {
+    UserModel.collection.drop(() => {
+      done();
+    });
+  });
+
+  before('add test user document to mongoDB', () => {
+    user1 = new UserModel({
+      name: 'userName1',
+      skills: ['js', 'ruby', 'php', 'python'],
+      gender: 'male',
+      relocation: true,
+    });
+
+    user2 = new UserModel({
+      name: 'userName2',
+      skills: ['go', 'erlang'],
+      gender: 'female',
+      relocation: false,
+    });
+
+    return Promise.all([
+      user1.save(),
+      user2.save(),
+    ]);
+  });
+
+  it('should return Resolver object', () => {
+    const resolver = count(UserModel, UserType);
+    expect(resolver).to.be.instanceof(Resolver);
+  });
+
+  describe('Resolver.args', () => {
+    it('should have `filter` arg', () => {
+      const resolver = count(UserModel, UserType);
+      expect(resolver.hasArg('filter')).to.be.true;
+    });
+  });
+
+  describe('Resolver.resolve():Promise', () => {
+    it('should be fulfilled promise', async () => {
+      const result = count(UserModel, UserType).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: {} });
+      expect(result).to.equal(2);
+    });
+
+    it('should return number of document by filter data', async () => {
+      const result = await count(UserModel, UserType).resolve(
+        { args: { filter: { gender: 'male' } } }
+      );
+      expect(result).to.equal(1);
+    });
+  });
+
+  describe('Resolver.getOutputType()', () => {
+    it('should return GraphQLInt type', () => {
+      const outputType = count(UserModel, UserType).getOutputType();
+      expect(outputType).to.equal(GraphQLInt);
+    });
+  });
+});

src/resolvers/count.js

@@ -0,0 +1,30 @@
+/* @flow */
+/* eslint-disable no-param-reassign */
+
+import type {
+  MongooseModelT,
+  GraphQLObjectType,
+  ExtendedResolveParams,
+} from '../definition';
+import Resolver from '../../../graphql-compose/src/resolver/resolver';
+import { GraphQLInt } from 'graphql';
+
+import { filterHelperArgsGen, filterHelper } from './helpers/filter';
+
+export default function count(model: MongooseModelT, gqType: GraphQLObjectType): Resolver {
+  return new Resolver({
+    outputType: GraphQLInt,
+    name: 'count',
+    kind: 'query',
+    args: {
+      ...filterHelperArgsGen(model, {
+        filterTypeName: `Filter${gqType.name}Input`,
+      }),
+    },
+    resolve: (resolveParams : ExtendedResolveParams) => {
+      resolveParams.query = model.find();
+      filterHelper(resolveParams);
+      return resolveParams.query.count().exec();
+    },
+  });
+}