feat: add new resolvers findByIdLean, findByIdsLean, findByManyLean, findByOneLean which returns data from DB without instantiating a full Mongoose documents. It's faster in several times but doesn't support getters & virtuals fields. See https://mongoosejs.com/docs/tutorials/lean.html#using-lean

Related #140

Author: nodkz

README.md

@@ -98,6 +98,10 @@ schemaComposer.Query.addFields({
   userByIds: UserTC.getResolver('findByIds'),
   userOne: UserTC.getResolver('findOne'),
   userMany: UserTC.getResolver('findMany'),
+  userByIdLean: UserTC.getResolver('findByIdLean'),
+  userByIdsLean: UserTC.getResolver('findByIdsLean'),
+  userOneLean: UserTC.getResolver('findOneLean'),
+  userManyLean: UserTC.getResolver('findManyLean'),
   userCount: UserTC.getResolver('count'),
   userConnection: UserTC.getResolver('connection'),
   userPagination: UserTC.getResolver('pagination'),

src/composeWithMongoose.ts

@@ -61,6 +61,28 @@ export type TypeConverterResolversOpts = {
         limit?: LimitHelperArgsOpts | false;
         skip?: false;
       };
+  findByIdLean?: false;
+  findByIdsLean?:
+    | false
+    | {
+        limit?: LimitHelperArgsOpts | false;
+        sort?: SortHelperArgsOpts | false;
+      };
+  findOneLean?:
+    | false
+    | {
+        filter?: FilterHelperArgsOpts | false;
+        sort?: SortHelperArgsOpts | false;
+        skip?: false;
+      };
+  findManyLean?:
+    | false
+    | {
+        filter?: FilterHelperArgsOpts | false;
+        sort?: SortHelperArgsOpts | false;
+        limit?: LimitHelperArgsOpts | false;
+        skip?: false;
+      };
   updateById?:
     | false
     | {

src/discriminators/prepareChildResolvers.ts

@@ -166,6 +166,8 @@ export function prepareChildResolvers<TSource, TContext>(
 
         case EMCResolvers.findOne:
         case EMCResolvers.findMany:
+        case EMCResolvers.findOneLean:
+        case EMCResolvers.findManyLean:
         case EMCResolvers.removeOne:
         case EMCResolvers.removeMany:
         case EMCResolvers.count:

src/resolvers/__tests__/findById-test.ts

@@ -1,9 +1,7 @@
 import { Resolver, schemaComposer, ObjectTypeComposer } from 'graphql-compose';
-import { GraphQLNonNull } from 'graphql-compose/lib/graphql';
 import { UserModel, IUser } from '../../__mocks__/userModel';
 import { PostModel, IPost } from '../../__mocks__/postModel';
 import findById from '../findById';
-import GraphQLMongoID from '../../types/MongoID';
 import { convertModelToGraphQL } from '../../fieldsConverter';
 import { ExtendedResolveParams } from '..';
 
@@ -43,10 +41,7 @@ describe('findById() ->', () => {
   describe('Resolver.args', () => {
     it('should have non-null `_id` arg', () => {
       const resolver = findById(UserModel, UserTC);
-      expect(resolver.hasArg('_id')).toBe(true);
-      const argConfig: any = resolver.getArgConfig('_id');
-      expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
-      expect(argConfig.type.ofType).toBe(GraphQLMongoID);
+      expect(resolver.getArgTypeName('_id')).toBe('MongoID!');
     });
   });
 

src/resolvers/__tests__/findByIdLean-test.ts

@@ -0,0 +1,105 @@
+import { Resolver, schemaComposer, ObjectTypeComposer } from 'graphql-compose';
+import { UserModel, IUser } from '../../__mocks__/userModel';
+import { PostModel, IPost } from '../../__mocks__/postModel';
+import findByIdLean from '../findByIdLean';
+import { convertModelToGraphQL } from '../../fieldsConverter';
+import { ExtendedResolveParams } from '..';
+
+beforeAll(() => UserModel.base.createConnection());
+afterAll(() => UserModel.base.disconnect());
+
+describe('findByIdLean() ->', () => {
+  let UserTC: ObjectTypeComposer;
+  let PostTypeComposer: ObjectTypeComposer;
+
+  beforeEach(() => {
+    schemaComposer.clear();
+    UserTC = convertModelToGraphQL(UserModel, 'User', schemaComposer);
+    PostTypeComposer = convertModelToGraphQL(PostModel, 'Post', schemaComposer);
+  });
+
+  let user: IUser;
+  let post: IPost;
+
+  beforeEach(async () => {
+    await UserModel.deleteMany({});
+
+    user = new UserModel({ name: 'nodkz', contacts: { email: 'mail' } });
+    await user.save();
+
+    await PostModel.deleteMany({});
+
+    post = new PostModel({ _id: 1, title: 'Post 1' });
+    await post.save();
+  });
+
+  it('should return Resolver object', () => {
+    const resolver = findByIdLean(UserModel, UserTC);
+    expect(resolver).toBeInstanceOf(Resolver);
+  });
+
+  describe('Resolver.args', () => {
+    it('should have non-null `_id` arg', () => {
+      const resolver = findByIdLean(UserModel, UserTC);
+      expect(resolver.getArgTypeName('_id')).toBe('MongoID!');
+    });
+  });
+
+  describe('Resolver.resolve():Promise', () => {
+    it('should be fulfilled promise', async () => {
+      const result = findByIdLean(UserModel, UserTC).resolve({});
+      await expect(result).resolves.toBeDefined();
+    });
+
+    it('should be rejected if args.id is not objectId', async () => {
+      const result = findByIdLean(UserModel, UserTC).resolve({ args: { _id: 1 } });
+      await expect(result).rejects.toBeDefined();
+    });
+
+    it('should return null if args.id is empty', async () => {
+      const result = await findByIdLean(UserModel, UserTC).resolve({});
+      expect(result).toBe(null);
+    });
+
+    it('should return document if provided existed id', async () => {
+      const result = await findByIdLean(UserModel, UserTC).resolve({
+        args: { _id: user._id },
+      });
+      expect(result.name).toBe(user.name);
+    });
+
+    it('should return lean User object', async () => {
+      const result = await findByIdLean(UserModel, UserTC).resolve({
+        args: { _id: user._id },
+      });
+      expect(result).not.toBeInstanceOf(UserModel);
+      // aliases should be translated `User.n` -> `User.name`
+      expect(result).toEqual(expect.objectContaining({ name: 'nodkz' }));
+    });
+
+    it('should return lean Post object', async () => {
+      const result = await findByIdLean(PostModel, PostTypeComposer).resolve({
+        args: { _id: 1 },
+      });
+      expect(result).not.toBeInstanceOf(PostModel);
+      expect(result).toEqual({ __v: 0, _id: 1, title: 'Post 1' });
+    });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      let beforeQueryCalled = false;
+
+      const result = await findByIdLean(PostModel, PostTypeComposer).resolve({
+        args: { _id: 1 },
+        beforeQuery: (query: any, rp: ExtendedResolveParams) => {
+          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.ts

@@ -1,9 +1,7 @@
 import { Resolver, schemaComposer, ObjectTypeComposer } from 'graphql-compose';
-import { GraphQLNonNull, GraphQLList } from 'graphql-compose/lib/graphql';
 import { UserModel, IUser } from '../../__mocks__/userModel';
 import { PostModel, IPost } from '../../__mocks__/postModel';
 import findByIds from '../findByIds';
-import GraphQLMongoID from '../../types/MongoID';
 import { convertModelToGraphQL } from '../../fieldsConverter';
 import { ExtendedResolveParams } from '..';
 
@@ -53,11 +51,7 @@ describe('findByIds() ->', () => {
   describe('Resolver.args', () => {
     it('should have non-null `_ids` arg', () => {
       const resolver = findByIds(UserModel, UserTC);
-      expect(resolver.hasArg('_ids')).toBe(true);
-      const argConfig: any = resolver.getArgConfig('_ids');
-      expect(argConfig.type).toBeInstanceOf(GraphQLNonNull);
-      expect(argConfig.type.ofType).toBeInstanceOf(GraphQLList);
-      expect(argConfig.type.ofType.ofType).toBe(GraphQLMongoID);
+      expect(resolver.getArgTypeName('_ids')).toBe('[MongoID]!');
     });
 
     it('should have `limit` arg', () => {

src/resolvers/__tests__/findByIdsLean-test.ts

@@ -0,0 +1,136 @@
+import { Resolver, schemaComposer, ObjectTypeComposer } from 'graphql-compose';
+import { UserModel, IUser } from '../../__mocks__/userModel';
+import { PostModel, IPost } from '../../__mocks__/postModel';
+import findByIdsLean from '../findByIdsLean';
+import { convertModelToGraphQL } from '../../fieldsConverter';
+import { ExtendedResolveParams } from '..';
+
+beforeAll(() => UserModel.base.createConnection());
+afterAll(() => UserModel.base.disconnect());
+
+describe('findByIdsLean() ->', () => {
+  let UserTC: ObjectTypeComposer;
+  let PostTypeComposer: ObjectTypeComposer;
+
+  beforeEach(() => {
+    schemaComposer.clear();
+    UserTC = convertModelToGraphQL(UserModel, 'User', schemaComposer);
+    PostTypeComposer = convertModelToGraphQL(PostModel, 'Post', schemaComposer);
+  });
+
+  let user1: IUser;
+  let user2: IUser;
+  let user3: IUser;
+  let post1: IPost;
+  let post2: IPost;
+  let post3: IPost;
+
+  beforeEach(async () => {
+    await UserModel.deleteMany({});
+
+    user1 = new UserModel({ name: 'nodkz1', contacts: { email: 'mail' } });
+    user2 = new UserModel({ name: 'nodkz2', contacts: { email: 'mail' } });
+    user3 = new UserModel({ name: 'nodkz3', contacts: { email: 'mail' } });
+
+    await Promise.all([user1.save(), user2.save(), user3.save()]);
+
+    await PostModel.deleteMany({});
+
+    post1 = new PostModel({ _id: 1, title: 'Post 1' });
+    post2 = new PostModel({ _id: 2, title: 'Post 2' });
+    post3 = new PostModel({ _id: 3, title: 'Post 3' });
+
+    await Promise.all([post1.save(), post2.save(), post3.save()]);
+  });
+
+  it('should return Resolver object', () => {
+    const resolver = findByIdsLean(UserModel, UserTC);
+    expect(resolver).toBeInstanceOf(Resolver);
+  });
+
+  describe('Resolver.args', () => {
+    it('should have non-null `_ids` arg', () => {
+      const resolver = findByIdsLean(UserModel, UserTC);
+      expect(resolver.getArgTypeName('_ids')).toBe('[MongoID]!');
+    });
+
+    it('should have `limit` arg', () => {
+      const resolver = findByIdsLean(UserModel, UserTC);
+      expect(resolver.hasArg('limit')).toBe(true);
+    });
+
+    it('should have `sort` arg', () => {
+      const resolver = findByIdsLean(UserModel, UserTC);
+      expect(resolver.hasArg('sort')).toBe(true);
+    });
+  });
+
+  describe('Resolver.resolve():Promise', () => {
+    it('should be fulfilled promise', async () => {
+      const result = findByIdsLean(UserModel, UserTC).resolve({});
+      await expect(result).resolves.toBeDefined();
+    });
+
+    it('should return empty array if args._ids is empty', async () => {
+      const result = await findByIdsLean(UserModel, UserTC).resolve({});
+      expect(result).toBeInstanceOf(Array);
+      expect(Object.keys(result)).toHaveLength(0);
+    });
+
+    it('should return array of documents', async () => {
+      const result = await findByIdsLean(UserModel, UserTC).resolve({
+        args: { _ids: [user1._id, user2._id, user3._id] },
+      });
+
+      expect(result).toBeInstanceOf(Array);
+      expect(result).toHaveLength(3);
+      expect(result.map((d: any) => d.name)).toEqual(
+        expect.arrayContaining([user1.name, user2.name, user3.name])
+      );
+    });
+
+    it('should return array of documents if object id is string', async () => {
+      const stringId = `${user1._id}`;
+      const result = await findByIdsLean(UserModel, UserTC).resolve({
+        args: { _ids: [stringId] },
+      });
+
+      expect(result).toBeInstanceOf(Array);
+      expect(result).toHaveLength(1);
+    });
+
+    it('should return array of documents if args._ids are integers', async () => {
+      const result = await findByIdsLean(PostModel, PostTypeComposer).resolve({
+        args: { _ids: [1, 2, 3] },
+      });
+      expect(result).toBeInstanceOf(Array);
+      expect(result).toHaveLength(3);
+    });
+
+    it('should return mongoose documents', async () => {
+      const result = await findByIdsLean(UserModel, UserTC).resolve({
+        args: { _ids: [user1._id, user2._id] },
+      });
+      expect(result[0]).not.toBeInstanceOf(UserModel);
+      expect(result[1]).not.toBeInstanceOf(UserModel);
+      // should translate aliases fields
+      expect(result).toEqual([
+        expect.objectContaining({ name: 'nodkz1' }),
+        expect.objectContaining({ name: 'nodkz2' }),
+      ]);
+    });
+
+    it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
+      const result = await findByIdsLean(UserModel, UserTC).resolve({
+        args: { _ids: [user1._id, user2._id] },
+        beforeQuery(query: any, rp: ExtendedResolveParams) {
+          expect(rp.model).toBe(UserModel);
+          expect(rp.query).toHaveProperty('exec');
+          return query.where({ _id: user1._id });
+        },
+      });
+
+      expect(result).toHaveLength(1);
+    });
+  });
+});