add beforeQueryHelper

src/resolvers/__tests__/connection-test.js

@@ -1,6 +1,7 @@
 /* @flow */
 
 import { Resolver, schemaComposer } from 'graphql-compose';
+import { Query } from 'mongoose';
 import { UserModel } from '../../__mocks__/userModel';
 import connection, { prepareCursorQuery } from '../connection';
 import findMany from '../findMany';
@@ -217,6 +218,63 @@ describe('connection() resolver', () => {
         expect(result.edges[0].node).toBeInstanceOf(UserModel);
         expect(result.edges[1].node).toBeInstanceOf(UserModel);
       });
+
+      it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+        const mongooseActions = [];
+
+        UserModel.base.set('debug', function debugMongoose(...args) {
+          mongooseActions.push(args);
+        });
+
+        const resolver = connection(UserModel, UserTC);
+
+        if (!resolver) {
+          throw new Error('resolver is undefined');
+        }
+
+        const result = await resolver.resolve({
+          args: {},
+          beforeQuery: (query, rp) => {
+            expect(query).toBeInstanceOf(Query);
+            expect(rp.model).toBe(UserModel);
+            // modify query before execution
+            return query.where({ _id: user1.id }).limit(1989);
+          },
+        });
+
+        expect(mongooseActions).toEqual([
+          [
+            'users',
+            'find',
+            { _id: user1._id },
+            {
+              limit: 1989,
+              projection: {},
+            },
+          ],
+        ]);
+
+        expect(result.edges).toHaveLength(1);
+      });
+
+      it('should override result with `beforeQuery`', async () => {
+        const resolver = connection(UserModel, UserTC);
+
+        if (!resolver) {
+          throw new Error('resolver is undefined');
+        }
+
+        const result = await resolver.resolve({
+          args: {},
+          beforeQuery: (query, rp) => {
+            expect(query).toBeInstanceOf(Query);
+            expect(rp.model).toBe(UserModel);
+            return [{ overrides: true }];
+          },
+        });
+
+        expect(result).toHaveProperty('edges.0.node', { overrides: true });
+      });
     });
   });
 });

src/resolvers/__tests__/count-test.js

@@ -70,6 +70,50 @@ describe('count() ->', () => {
       });
       expect(result).toBe(1);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const mongooseActions = [];
+
+      UserModel.base.set('debug', function debugMongoose(...args) {
+        mongooseActions.push(args);
+      });
+
+      const result = await count(UserModel, UserTC).resolve({
+        args: {},
+        beforeQuery: (query, rp) => {
+          expect(query).toHaveProperty('exec');
+          expect(rp.model).toBe(UserModel);
+
+          // modify query before execution
+          return query.limit(1);
+        },
+      });
+
+      expect(mongooseActions).toEqual([
+        [
+          'users',
+          'countDocuments',
+          {},
+          {
+            limit: 1,
+          },
+        ],
+      ]);
+
+      expect(result).toBe(1);
+    });
+
+    it('should override result with `beforeQuery`', async () => {
+      const result = await count(UserModel, UserTC).resolve({
+        args: {},
+        beforeQuery: (query, rp) => {
+          expect(query).toHaveProperty('exec');
+          expect(rp.model).toBe(UserModel);
+          return 1989;
+        },
+      });
+      expect(result).toBe(1989);
+    });
   });
 
   describe('Resolver.getType()', () => {

src/resolvers/__tests__/findById-test.js

@@ -87,5 +87,22 @@ describe('findById() ->', () => {
       });
       expect(result).toBeInstanceOf(PostModel);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      let beforeQueryCalled = false;
+
+      const result = await findById(PostModel, PostTypeComposer).resolve({
+        args: { _id: 1 },
+        beforeQuery: (query, rp) => {
+          expect(query).toHaveProperty('exec');
+          expect(rp.model).toBe(PostModel);
+          beforeQueryCalled = true;
+          return { overrides: true };
+        },
+      });
+
+      expect(beforeQueryCalled).toBe(true);
+      expect(result).toEqual({ overrides: true });
+    });
   });
 });

src/resolvers/__tests__/findByIds-test.js

@@ -121,5 +121,18 @@ describe('findByIds() ->', () => {
       expect(result[0]).toBeInstanceOf(UserModel);
       expect(result[1]).toBeInstanceOf(UserModel);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const result = await findByIds(UserModel, UserTC).resolve({
+        args: { _ids: [user1._id, user2._id] },
+        beforeQuery(query, rp) {
+          expect(rp.model).toBe(UserModel);
+          expect(rp.query).toHaveProperty('exec');
+          return query.where({ _id: user1._id });
+        },
+      });
+
+      expect(result).toHaveLength(1);
+    });
   });
 });

src/resolvers/__tests__/findMany-test.js

@@ -110,5 +110,18 @@ describe('findMany() ->', () => {
       expect(result[0]).toBeInstanceOf(UserModel);
       expect(result[1]).toBeInstanceOf(UserModel);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const result = await findMany(UserModel, UserTC).resolve({
+        args: { limit: 2 },
+        beforeQuery(query, rp) {
+          expect(rp.model).toBe(UserModel);
+          expect(rp.query).toHaveProperty('exec');
+          return [{ overridden: true }];
+        },
+      });
+
+      expect(result).toEqual([{ overridden: true }]);
+    });
   });
 });

src/resolvers/__tests__/findOne-test.js

@@ -118,6 +118,19 @@ describe('findOne() ->', () => {
       });
       expect(result).toBeInstanceOf(UserModel);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const result = await findOne(UserModel, UserTC).resolve({
+        args: { _id: user1._id },
+        beforeQuery(query, rp) {
+          expect(rp.model).toBe(UserModel);
+          expect(rp.query).toHaveProperty('exec');
+          return query.where({ _id: user2._id });
+        },
+      });
+
+      expect(result._id).toEqual(user2._id);
+    });
   });
 
   describe('Resolver.getType()', () => {

src/resolvers/__tests__/pagination-test.js

@@ -144,5 +144,21 @@ describe('pagination() ->', () => {
       expect(result.items[0]).toBeInstanceOf(UserModel);
       expect(result.items[1]).toBeInstanceOf(UserModel);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const resolver = pagination(UserModel, UserTC);
+      if (!resolver) throw new Error('Pagination resolver is undefined');
+
+      const result = await resolver.resolve({
+        args: { page: 1, perPage: 20 },
+        beforeQuery(query, rp) {
+          expect(rp.model).toBe(UserModel);
+          expect(rp.query).toHaveProperty('exec');
+          return [{ overrides: true }];
+        },
+      });
+
+      expect(result.items).toEqual([{ overrides: true }]);
+    });
   });
 });

src/resolvers/__tests__/removeById-test.js

@@ -147,6 +147,32 @@ describe('removeById() ->', () => {
       const exist = await UserModel.collection.findOne({ _id: user._id });
       expect(exist.name).toBe(user.name);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const mongooseActions = [];
+
+      UserModel.base.set('debug', function debugMongoose(...args) {
+        mongooseActions.push(args);
+      });
+
+      const resolveParams = {
+        args: { _id: 'INVALID_ID' },
+        context: { ip: '1.1.1.1' },
+        beforeQuery(query, rp) {
+          expect(rp.model).toBe(UserModel);
+          expect(rp.query).toHaveProperty('exec');
+          return query.where({ _id: user._id, canDelete: false });
+        },
+      };
+
+      const result = await removeById(UserModel, UserTC).resolve(resolveParams);
+
+      expect(mongooseActions).toEqual([
+        ['users', 'findOne', { _id: user._id, canDelete: false }, { projection: {} }],
+      ]);
+
+      expect(result).toBeNull();
+    });
   });
 
   describe('Resolver.getType()', () => {

src/resolvers/__tests__/removeMany-test.js

@@ -109,8 +109,9 @@ describe('removeMany() ->', () => {
         args: {
           filter: { gender: 'female' },
         },
-        beforeQuery: query => {
+        beforeQuery: (query, rp) => {
           expect(query).toBeInstanceOf(Query);
+          expect(rp.model).toBe(UserModel);
           beforeQueryCalled = true;
           return query;
         },

src/resolvers/__tests__/removeOne-test.js

@@ -189,6 +189,25 @@ describe('removeOne() ->', () => {
       const exist = await UserModel.collection.findOne({ _id: user1._id });
       expect(exist.name).toBe(user1.name);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      let beforeQueryCalled = false;
+
+      const result = await removeOne(UserModel, UserTC).resolve({
+        args: { filter: { _id: 'INVALID_ID' } },
+        beforeQuery: (query, rp) => {
+          expect(query).toHaveProperty('exec');
+          expect(rp.model).toBe(UserModel);
+
+          beforeQueryCalled = true;
+          // modify query before execution
+          return query.where({ _id: user1.id });
+        },
+      });
+
+      expect(result).toHaveProperty('record._id', user1._id);
+      expect(beforeQueryCalled).toBe(true);
+    });
   });
 
   describe('Resolver.getType()', () => {

src/resolvers/__tests__/updateById-test.js

@@ -187,6 +187,25 @@ describe('updateById() ->', () => {
       const exist = await UserModel.collection.findOne({ _id: user1._id });
       expect(exist.name).toBe(user1.name);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      let beforeQueryCalled = false;
+
+      const result = await updateById(UserModel, UserTC).resolve({
+        args: { record: { _id: user1.id, name: 'new name' } },
+        beforeQuery: (query, rp) => {
+          expect(query).toHaveProperty('exec');
+          expect(rp.model).toBe(UserModel);
+
+          beforeQueryCalled = true;
+          // modify query before execution
+          return query.where({ _id: user2.id });
+        },
+      });
+
+      expect(result).toHaveProperty('record._id', user2._id);
+      expect(beforeQueryCalled).toBe(true);
+    });
   });
 
   describe('Resolver.getType()', () => {

src/resolvers/__tests__/updateMany-test.js

@@ -117,8 +117,9 @@ describe('updateMany() ->', () => {
         args: {
           record: { gender: 'female' },
         },
-        beforeQuery: query => {
+        beforeQuery: (query, rp) => {
           expect(query).toBeInstanceOf(Query);
+          expect(rp.model).toBe(UserModel);
           beforeQueryCalled = true;
           // modify query before execution
           return query.where({ _id: user1.id });

src/resolvers/__tests__/updateOne-test.js

@@ -211,6 +211,25 @@ describe('updateOne() ->', () => {
       const exist = await UserModel.collection.findOne({ _id: user1._id });
       expect(exist.name).toBe(user1.name);
     });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      let beforeQueryCalled = false;
+
+      const result = await updateOne(UserModel, UserTC).resolve({
+        args: { filter: { _id: user1.id }, record: { name: 'new name' } },
+        beforeQuery: (query, rp) => {
+          expect(query).toHaveProperty('exec');
+          expect(rp.model).toBe(UserModel);
+
+          beforeQueryCalled = true;
+          // modify query before execution
+          return query.where({ _id: user2.id });
+        },
+      });
+
+      expect(result).toHaveProperty('record._id', user2._id);
+      expect(beforeQueryCalled).toBe(true);
+    });
   });
 
   describe('Resolver.getType()', () => {

src/resolvers/count.js

@@ -5,6 +5,7 @@ import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { MongooseDocument } from 'mongoose';
 import { filterHelper, filterHelperArgs } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
+import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 
 export default function count<TSource: MongooseDocument, TContext>(
   model: Class<TSource>, // === MongooseModel
@@ -32,13 +33,16 @@ export default function count<TSource: MongooseDocument, TContext>(
     },
     resolve: (resolveParams: ExtendedResolveParams) => {
       resolveParams.query = model.find();
+      resolveParams.model = model;
       filterHelper(resolveParams);
       if (resolveParams.query.countDocuments) {
         // mongoose 5.2.0 and above
-        return resolveParams.query.countDocuments().exec();
+        resolveParams.query.countDocuments();
+        return beforeQueryHelper(resolveParams);
       } else {
         // mongoose 5 and below
-        return resolveParams.query.count().exec();
+        resolveParams.query.count();
+        return beforeQueryHelper(resolveParams);
       }
     },
   });