test: add integration test for dataLoaderXXX resolvers

Author: nodkz

src/__tests__/github_issues/260-test.ts

@@ -0,0 +1,100 @@
+/* eslint-disable no-param-reassign */
+
+import { schemaComposer, graphql } from 'graphql-compose';
+import { composeWithMongoose } from '../../index';
+import { mongoose } from '../../__mocks__/mongooseCommon';
+
+const UserSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+});
+const PostSchema = new mongoose.Schema({
+  title: { type: String, required: true },
+  authorId: { type: mongoose.Types.ObjectId },
+  reviewerIds: { type: [mongoose.Types.ObjectId] },
+});
+
+const UserModel = mongoose.model('User', UserSchema);
+const PostModel = mongoose.model('Post', PostSchema);
+
+const UserTC = composeWithMongoose(UserModel);
+const PostTC = composeWithMongoose(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
+  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
+  prepareArgs: {
+    _ids: (s) => s.reviewerIds,
+  },
+  projection: { reviewerIds: true },
+});
+
+schemaComposer.Query.addFields({
+  posts: PostTC.getResolver('findMany'),
+});
+const schema = schemaComposer.buildSchema();
+
+// console.log(schemaComposer.toSDL());
+
+beforeAll(async () => {
+  await UserModel.base.createConnection();
+  const User1 = await UserModel.create({ name: 'User1' });
+  const User2 = await UserModel.create({ name: 'User2' });
+  const User3 = await UserModel.create({ name: 'User3' });
+
+  await PostModel.create({ title: 'Post1', authorId: User1._id });
+  await PostModel.create({ title: 'Post2', authorId: User1._id, reviewerIds: [] });
+  await PostModel.create({ title: 'Post3', authorId: User1._id, reviewerIds: [User2._id] });
+  await PostModel.create({ title: 'Post4', authorId: User2._id, reviewerIds: [User1._id] });
+  await PostModel.create({ title: 'Post5', authorId: User2._id, reviewerIds: [User1._id] });
+  await PostModel.create({
+    title: 'Post6',
+    authorId: User3._id,
+    reviewerIds: [User1._id, User2._id],
+  });
+});
+afterAll(() => UserModel.base.disconnect());
+
+describe('issue #260 - new resolvers which works via DataLoader', () => {
+  it('check response', async () => {
+    // 👀 uncomment next line if you want to see real mongoose queries
+    // mongoose.set('debug', true);
+
+    expect(
+      await graphql.graphql({
+        schema,
+        source: `query {
+          posts {
+            title
+            author { name }
+            reviewers { name }
+          }
+        }`,
+        contextValue: {},
+      })
+    ).toEqual({
+      data: {
+        posts: [
+          { title: 'Post1', author: { name: 'User1' }, reviewers: [] },
+          { title: 'Post2', author: { name: 'User1' }, reviewers: [] },
+          { title: 'Post3', author: { name: 'User1' }, reviewers: [{ name: 'User2' }] },
+          { title: 'Post4', author: { name: 'User2' }, reviewers: [{ name: 'User1' }] },
+          { title: 'Post5', author: { name: 'User2' }, reviewers: [{ name: 'User1' }] },
+          {
+            title: 'Post6',
+            author: { name: 'User3' },
+            reviewers: [{ name: 'User1' }, { name: 'User2' }],
+          },
+        ],
+      },
+    });
+  });
+});

src/__tests__/github_issues/282-test.ts renamed to src/__tests__/github_issues/gc282-test.ts

@@ -60,7 +60,9 @@ beforeAll(async () => {
 });
 afterAll(() => EventModel.base.disconnect());
 
-describe('issue #282 - Filter nested array by string', () => {
+// Issue from graphql-compose repo
+// @see https://github.com/graphql-compose/graphql-compose/pull/282
+describe('graphql-compose/issue #282 - Filter nested array by string', () => {
   it('correct request', async () => {
     expect(
       await graphql.graphql(

src/resolvers/helpers/dataLoaderHelper.ts

@@ -15,19 +15,34 @@ export function getDataLoader(
   // get or create DataLoader in GraphQL context
   let dl: DataLoader<any, any> = _gqlDataLoaders.get(dlKey);
   if (!dl) {
+    const dataLoaderOptions = {
+      cacheKeyFn: (k) => {
+        if (k?.equals) {
+          // Convert ObjectId to string for combining different instances of same ObjectIds.
+          // Eg. you have 10 articles with same authorId. So in memory `authorId` for every record
+          //     will have its own instance of ObjectID.
+          //
+          // mongoose will convert them back to ObjectId automatically when call `find` method
+          return k.toString();
+        }
+        return k;
+      },
+    } as DataLoader.Options<any, any, any>;
+
     dl = new DataLoader(async (ids) => {
       const result = await batchLoadFn(ids);
       // return docs in the same order as were provided their ids
       return ids.map((id) =>
-        (result as any).find((d: any) => {
-          if (d?._id?.equals) {
+        (result as any).find((doc: any) => {
+          if (doc?._id?.equals) {
             // compare correctly MongoIDs via ObjectID.equals() method
-            return d._id.equals(id);
+            return doc._id.equals(id);
           }
-          return d._id === id;
+          return doc._id === id;
         })
       );
-    });
+    }, dataLoaderOptions);
+
     _gqlDataLoaders.set(dlKey, dl);
   }
   return dl;

src/resolvers/index.ts

@@ -18,8 +18,8 @@ import findOneLean from './findOneLean';
 
 import dataLoader from './dataLoader';
 import dataLoaderLean from './dataLoaderLean';
-import dataLoaderMany from './dataLoader';
-import dataLoaderManyLean from './dataLoaderLean';
+import dataLoaderMany from './dataLoaderMany';
+import dataLoaderManyLean from './dataLoaderManyLean';
 
 import type {
   FilterHelperArgsOpts,