fix(findByIds): Allowed to be id of any type

According to the documentation, `_id` field can be of any type.
https://docs.mongodb.com/manual/core/document/#the-id-field
"The field name _id is reserved for use as a primary key; its value must be unique in the collection, is immutable, and may be of any type other than an array."

Thanks @unkleho for his great first PR 🎉

Closes #4

Author: unkleho

src/__mocks__/postModel.js

@@ -0,0 +1,24 @@
+import { mongoose, Schema } from './mongooseCommon';
+
+const PostSchema = new Schema(
+  {
+    _id: {
+      type: Number,
+      unique: true,
+    },
+    title: {
+      type: String,
+      description: 'Post title',
+    },
+
+    // createdAt, created via option `timastamp: true` (see bottom)
+    // updatedAt, created via option `timastamp: true` (see bottom)
+  }
+);
+
+const PostModel = mongoose.model('Post', PostSchema);
+
+export {
+  PostSchema,
+  PostModel,
+};

src/resolvers/__tests__/findById-test.js

@@ -4,14 +4,17 @@ import { expect } from 'chai';
 import { GraphQLNonNull } from 'graphql';
 import { Resolver } from 'graphql-compose';
 import { UserModel } from '../../__mocks__/userModel';
+import { PostModel } from '../../__mocks__/postModel';
 import findById from '../findById';
 import GraphQLMongoID from '../../types/mongoid';
 import { composeWithMongoose } from '../../composeWithMongoose';
 
 const UserTypeComposer = composeWithMongoose(UserModel);
+const PostTypeComposer = composeWithMongoose(PostModel);
 
 describe('findById() ->', () => {
   let user;
+  let post;
 
   before('clear UserModel collection', (done) => {
     UserModel.collection.drop(() => {
@@ -24,6 +27,17 @@ describe('findById() ->', () => {
     user.save(done);
   });
 
+  before('clear PostModel collection', (done) => {
+    PostModel.collection.drop(() => {
+      done();
+    });
+  });
+
+  before('add test post document with integer _id to mongoDB', (done) => {
+    post = new PostModel({ _id: 1, title: 'Post 1' });
+    post.save(done);
+  });
+
   it('should return Resolver object', () => {
     const resolver = findById(UserModel, UserTypeComposer);
     expect(resolver).to.be.instanceof(Resolver);
@@ -67,5 +81,12 @@ describe('findById() ->', () => {
       });
       expect(result).instanceof(UserModel);
     });
+
+    it('should return mongoose Post document', async () => {
+      const result = await findById(PostModel, PostTypeComposer).resolve({
+        args: { _id: 1 },
+      });
+      expect(result).instanceof(PostModel);
+    });
   });
 });

src/resolvers/__tests__/findByIds-test.js

@@ -4,16 +4,21 @@ import { expect } from 'chai';
 import { GraphQLNonNull, GraphQLList } from 'graphql';
 import { Resolver } from 'graphql-compose';
 import { UserModel } from '../../__mocks__/userModel';
+import { PostModel } from '../../__mocks__/postModel';
 import findByIds from '../findByIds';
 import GraphQLMongoID from '../../types/mongoid';
 import { composeWithMongoose } from '../../composeWithMongoose';
 
 const UserTypeComposer = composeWithMongoose(UserModel);
+const PostTypeComposer = composeWithMongoose(PostModel);
 
 describe('findByIds() ->', () => {
   let user1;
   let user2;
   let user3;
+  let post1;
+  let post2;
+  let post3;
 
   before('clear UserModel collection', (done) => {
     UserModel.collection.drop(() => {
@@ -33,6 +38,24 @@ describe('findByIds() ->', () => {
     ]).then(() => done());
   });
 
+  before('clear PostModel collection', (done) => {
+    PostModel.collection.drop(() => {
+      done();
+    });
+  });
+
+  before('add test post documents with integer _id to mongoDB', (done) => {
+    post1 = new PostModel({ _id: 1, title: 'Post 1' });
+    post2 = new PostModel({ _id: 2, title: 'Post 2' });
+    post3 = new PostModel({ _id: 3, title: 'Post 3' });
+
+    Promise.all([
+      post1.save(),
+      post2.save(),
+      post3.save(),
+    ]).then(() => done());
+  });
+
   it('should return Resolver object', () => {
     const resolver = findByIds(UserModel, UserTypeComposer);
     expect(resolver).to.be.instanceof(Resolver);
@@ -71,13 +94,6 @@ describe('findByIds() ->', () => {
       expect(result).to.be.empty;
     });
 
-    it('should return empty array if args._ids is not valid objectIds', async () => {
-      const result = await findByIds(UserModel, UserTypeComposer)
-        .resolve({ args: { _ids: ['d', 'e'] } });
-      expect(result).to.be.instanceOf(Array);
-      expect(result).to.be.empty;
-    });
-
     it('should return array of documents', async () => {
       const result = await findByIds(UserModel, UserTypeComposer)
         .resolve({ args: { _ids: [user1._id, user2._id, user3._id] } });
@@ -97,6 +113,13 @@ describe('findByIds() ->', () => {
       expect(result).to.have.lengthOf(1);
     });
 
+    it('should return array of documents if args._ids are integers', async () => {
+      const result = await findByIds(PostModel, PostTypeComposer)
+        .resolve({ args: { _ids: [1, 2, 3] } });
+      expect(result).to.be.instanceOf(Array);
+      expect(result).to.have.lengthOf(3);
+    });
+
     it('should return mongoose documents', async () => {
       const result = await findByIds(UserModel, UserTypeComposer)
         .resolve({ args: { _ids: [user1._id, user2._id] } });

src/resolvers/findByIds.js

@@ -53,11 +53,8 @@ export default function findByIds(
         return Promise.resolve([]);
       }
 
-      const selector = {};
-      selector._id = {
-        $in: args._ids
-          .filter(id => mongoose.Types.ObjectId.isValid(id))
-          .map(id => mongoose.Types.ObjectId(id)), // eslint-disable-line
+      const selector = {
+        _id: { $in: args._ids },
       };
 
       resolveParams.query = model.find(selector); // eslint-disable-line