refactor: remove *Lean resolvers in favor of config option lean addition to basic resolvers

related: #263 (comment)

closes #266
related #140

Author: nodkz

src/__tests__/github_issues/141-test.ts

@@ -49,19 +49,15 @@ describe('issue #141 - createOne with custom id (not MongoId)', () => {
 
   it('Resolvers *ById should have Int type for args._id', () => {
     expect(UserTC.mongooseResolvers.findById().getArgTypeName('_id')).toBe('Int!');
-    expect(UserTC.mongooseResolvers.findByIdLean().getArgTypeName('_id')).toBe('Int!');
     expect(UserTC.mongooseResolvers.removeById().getArgTypeName('_id')).toBe('Int!');
     expect(UserTC.mongooseResolvers.updateById().getArgTypeName('_id')).toBe('Int!');
 
     expect(UserTC.mongooseResolvers.findByIds().getArgTypeName('_ids')).toBe('[Int!]!');
-    expect(UserTC.mongooseResolvers.findByIdsLean().getArgTypeName('_ids')).toBe('[Int!]!');
   });
 
   it('Resolvers dataLoader* should have Int type for args._id', () => {
     expect(UserTC.mongooseResolvers.dataLoader().getArgTypeName('_id')).toBe('Int!');
-    expect(UserTC.mongooseResolvers.dataLoaderLean().getArgTypeName('_id')).toBe('Int!');
     expect(UserTC.mongooseResolvers.dataLoaderMany().getArgTypeName('_ids')).toBe('[Int!]!');
-    expect(UserTC.mongooseResolvers.dataLoaderManyLean().getArgTypeName('_ids')).toBe('[Int!]!');
   });
 
   it('Check createOne/findOne resolvers', async () => {
@@ -133,27 +129,15 @@ describe('issue #141 - createOne with custom id (not MongoId)', () => {
       }"
     `);
     expect(ComplexTC.mongooseResolvers.findById().getArgTypeName('_id')).toBe('Complex_idInput!');
-    expect(ComplexTC.mongooseResolvers.findByIdLean().getArgTypeName('_id')).toBe(
-      'Complex_idInput!'
-    );
     expect(ComplexTC.mongooseResolvers.removeById().getArgTypeName('_id')).toBe('Complex_idInput!');
     expect(ComplexTC.mongooseResolvers.updateById().getArgTypeName('_id')).toBe('Complex_idInput!');
     expect(ComplexTC.mongooseResolvers.findByIds().getArgTypeName('_ids')).toBe(
       '[Complex_idInput!]!'
     );
-    expect(ComplexTC.mongooseResolvers.findByIdsLean().getArgTypeName('_ids')).toBe(
-      '[Complex_idInput!]!'
-    );
     expect(ComplexTC.mongooseResolvers.dataLoader().getArgTypeName('_id')).toBe('Complex_idInput!');
-    expect(ComplexTC.mongooseResolvers.dataLoaderLean().getArgTypeName('_id')).toBe(
-      'Complex_idInput!'
-    );
     expect(ComplexTC.mongooseResolvers.dataLoaderMany().getArgTypeName('_ids')).toBe(
       '[Complex_idInput!]!'
     );
-    expect(ComplexTC.mongooseResolvers.dataLoaderManyLean().getArgTypeName('_ids')).toBe(
-      '[Complex_idInput!]!'
-    );
 
     await ComplexModel.create({
       _id: { region: 'us-west', zone: 'a' },

src/__tests__/github_issues/260-test.ts

@@ -1,5 +1,5 @@
 import { schemaComposer, graphql } from 'graphql-compose';
-import { composeWithMongoose } from '../../index';
+import { composeMongoose } from '../../index';
 import { mongoose } from '../../__mocks__/mongooseCommon';
 import { Document } from 'mongoose';
 
@@ -25,29 +25,31 @@ interface IPost extends Document {
 const UserModel = mongoose.model<IUser>('User', UserSchema);
 const PostModel = mongoose.model<IPost>('Post', PostSchema);
 
-const UserTC = composeWithMongoose(UserModel);
-const PostTC = composeWithMongoose(PostModel);
+const UserTC = composeMongoose(UserModel);
+const PostTC = composeMongoose(PostModel);
 
 PostTC.addRelation('author', {
-  // resolver: UserTC.getResolver('dataLoader'), // <---- DataLoader for getting one mongoose doc by id (slower than `dataLoaderLean` but more functional)
-  resolver: UserTC.getResolver('dataLoaderLean'), // <---- `Lean` loads record from DB without support of mongoose getters & virtuals
+  resolver: UserTC.mongooseResolvers.dataLoader({
+    lean: true, // <---- `Lean` loads record from DB without support of mongoose getters & virtuals
+  }),
   prepareArgs: {
     _id: (s) => s.authorId,
   },
   projection: { authorId: true },
 });
 
 PostTC.addRelation('reviewers', {
-  // resolver: UserTC.getResolver('dataLoaderMany'), // <---- DataLoader for getting many mongoose docs by ids (slower than `dataLoaderManyLean` but more functional)
-  resolver: UserTC.getResolver('dataLoaderManyLean'), // <---- `Lean` loads records from DB without support of mongoose getters & virtuals
+  resolver: UserTC.mongooseResolvers.dataLoaderMany({
+    lean: true, // <---- `Lean` loads records from DB without support of mongoose getters & virtuals
+  }),
   prepareArgs: {
     _ids: (s) => s.reviewerIds,
   },
   projection: { reviewerIds: true },
 });
 
 schemaComposer.Query.addFields({
-  posts: PostTC.getResolver('findMany'),
+  posts: PostTC.mongooseResolvers.findMany(),
 });
 const schema = schemaComposer.buildSchema();
 

src/__tests__/github_issues/263-test.ts

@@ -30,15 +30,15 @@ const UserTC = composeMongoose(UserModel);
 const PostTC = composeMongoose(PostModel);
 
 PostTC.addRelation('author', {
-  resolver: UserTC.mongooseResolvers.dataLoaderLean(),
+  resolver: UserTC.mongooseResolvers.dataLoader({ lean: true }),
   prepareArgs: {
     _id: (s) => s.authorId,
   },
   projection: { authorId: true },
 });
 
 PostTC.addRelation('reviewers', {
-  resolver: UserTC.mongooseResolvers.dataLoaderManyLean(),
+  resolver: UserTC.mongooseResolvers.dataLoaderMany({ lean: true }),
   prepareArgs: {
     _ids: (s) => s.reviewerIds,
   },

src/__tests__/github_issues/268-test.ts

@@ -33,7 +33,7 @@ beforeAll(async () => {
 });
 afterAll(() => UserModel.base.disconnect());
 
-describe('issue #268 - Allow to provide `suffixes` for resolvers configs', () => {
+describe('issue #268 - Allow to provide `suffix` option for resolvers configs', () => {
   it('generate deferent resolvers with different configs', async () => {
     const createOne1 = UserTC.mongooseResolvers.createOne();
     expect(createOne1.getTypeName()).toBe('CreateOneUserPayload');
@@ -76,14 +76,6 @@ describe('issue #268 - Allow to provide `suffixes` for resolvers configs', () =>
     expect(resolver.getArgTypeName('sort')).toBe('SortFindManyUserXXXInput');
   });
 
-  it('Resolver:findManyLean', () => {
-    const resolver = UserTC.mongooseResolvers.findManyLean({
-      suffix: 'XXX',
-    });
-    expect(resolver.getArgTypeName('filter')).toBe('FilterFindManyLeanUserXXXInput');
-    expect(resolver.getArgTypeName('sort')).toBe('SortFindManyLeanUserXXXInput');
-  });
-
   it('Resolver:findOne', () => {
     const resolver = UserTC.mongooseResolvers.findOne({
       suffix: 'XXX',
@@ -92,14 +84,6 @@ describe('issue #268 - Allow to provide `suffixes` for resolvers configs', () =>
     expect(resolver.getArgTypeName('sort')).toBe('SortFindOneUserXXXInput');
   });
 
-  it('Resolver:findOneLean', () => {
-    const resolver = UserTC.mongooseResolvers.findOneLean({
-      suffix: 'XXX',
-    });
-    expect(resolver.getArgTypeName('filter')).toBe('FilterFindOneLeanUserXXXInput');
-    expect(resolver.getArgTypeName('sort')).toBe('SortFindOneLeanUserXXXInput');
-  });
-
   it('Resolver:createMany', () => {
     const resolver = UserTC.mongooseResolvers.createMany({
       suffix: 'XXX',

src/resolvers/__tests__/dataLoader-test.ts

@@ -92,6 +92,15 @@ describe('dataLoader() ->', () => {
       expect(result).toBeInstanceOf(UserModel);
     });
 
+    it('should return lean object from DB', async () => {
+      const result = await dataLoader(UserModel, UserTC, { lean: true }).resolve({
+        args: { _id: user._id },
+        context: {},
+        info,
+      });
+      expect(result).not.toBeInstanceOf(UserModel);
+    });
+
     it('should return mongoose Post document', async () => {
       const result = await dataLoader(PostModel, PostTypeComposer).resolve({
         args: { _id: 1 },
@@ -101,6 +110,15 @@ describe('dataLoader() ->', () => {
       expect(result).toBeInstanceOf(PostModel);
     });
 
+    it('should return lean Post object directly from DB', async () => {
+      const result = await dataLoader(PostModel, PostTypeComposer, { lean: true }).resolve({
+        args: { _id: 1 },
+        context: {},
+        info,
+      });
+      expect(result).not.toBeInstanceOf(PostModel);
+    });
+
     it('should call `beforeQuery` method with non-executed `query` as arg', async () => {
       const result = await dataLoader(PostModel, PostTypeComposer).resolve({
         args: { _id: 1 },
@@ -163,4 +181,14 @@ describe('dataLoader() ->', () => {
     // return undefined for not found record
     expect(await resultPromise5).toBe(undefined);
   });
+
+  it('check aliases for lean record', async () => {
+    const resolver = dataLoader(UserModel, UserTC, { lean: true });
+    const resultPromise1 = resolver.resolve({
+      args: { _id: user2._id },
+      context: {},
+      info,
+    });
+    expect((await resultPromise1).name).toEqual('user2');
+  });
 });