chore: update

Author: meabed

package.json

@@ -60,7 +60,7 @@
     "lint": "yarn eslint && yarn tscheck",
     "eslint": "eslint --ext .ts ./src",
     "tscheck": "tsc --noEmit",
-    "test": "yarn coverage && yarn lint",
+    "test": "jest",
     "link": "yarn build && yarn link graphql-compose && yarn link graphql-compose-connection && yarn link graphql-compose-pagination && yarn link mongoose && yarn link",
     "unlink": "rimraf node_modules && yarn install",
     "semantic-release": "semantic-release",

src/__tests__/github_issues/117-test.ts

@@ -60,7 +60,7 @@ describe('issue #117', () => {
 
     const player1 = await PlayerModel.create({ name: '1', surname: '1', sex: 'm' });
     const player2 = await PlayerModel.create({ name: '2', surname: '2', sex: 'f' });
-    const game = await GameModel.create({ players: [player1, player2] });
+    const game = await GameModel.create({ players: [player1._id, player2._id] });
 
     const id = game._id;
     const g1 = await GameModel.findOne({ _id: id }).populate('players');

src/fieldsConverter.ts

@@ -17,7 +17,10 @@ import GraphQLBSONDecimal from './types/BSONDecimal';
 type MongooseFieldT = {
   path?: string;
   instance: string;
+  // mongoose 8
   caster?: any;
+  // mongoose 9
+  embeddedSchemaType?: any;
   options?: {
     description?: string;
     alias?: string;
@@ -330,14 +333,14 @@ export function arrayToGraphQL(
   prefix: string = '',
   schemaComposer: SchemaComposer<any>
 ): ComposeOutputTypeDefinition<any> {
-  if (!field || !field.caster) {
+  if (!field || (!field.caster && !field.embeddedSchemaType)) {
     throw new Error(
       'You provide incorrect mongoose field to `arrayToGraphQL()`. ' +
         'Correct field should contain `caster` property.'
     );
   }
 
-  const unwrappedField = { ...field.caster };
+  const unwrappedField = { ...(field.caster || field.embeddedSchemaType) } as MongooseFieldT;
 
   const outputType: any = convertFieldToGraphQL(unwrappedField, prefix, schemaComposer);
   return [outputType];

src/resolvers/helpers/__tests__/filter-test.ts

@@ -146,15 +146,15 @@ describe('Resolver helper `filter` ->', () => {
 
     it('should not call query.where if args.filter is empty', () => {
       filterHelper(resolveParams, aliases);
-      expect(spyWhereFn).not.toBeCalled();
+      expect(spyWhereFn).not.toHaveBeenCalled();
     });
 
     it('should call query.where if args.filter is provided', () => {
       resolveParams.args = {
         filter: { name: 'nodkz' },
       };
       filterHelper(resolveParams, aliases);
-      expect(spyWhereFn).toBeCalledWith({ n: 'nodkz' });
+      expect(spyWhereFn).toHaveBeenCalledWith({ n: 'nodkz' });
     });
 
     it('should convert deep object in args.filter to dotted object', () => {
@@ -167,7 +167,7 @@ describe('Resolver helper `filter` ->', () => {
         },
       };
       filterHelper(resolveParams, aliases);
-      expect(spyWhereFn).toBeCalledWith({
+      expect(spyWhereFn).toHaveBeenCalledWith({
         'n.first': 'Pavel',
         age: 30,
       });
@@ -180,7 +180,7 @@ describe('Resolver helper `filter` ->', () => {
         },
       };
       filterHelper(resolveParams, aliases);
-      expect(spyWhereFn).toBeCalledWith({ age: { $gt: 10, $lt: 20 } });
+      expect(spyWhereFn).toHaveBeenCalledWith({ age: { $gt: 10, $lt: 20 } });
     });
 
     it('should add rawQuery to query', () => {

src/resolvers/helpers/__tests__/limit-test.ts

@@ -33,17 +33,17 @@ describe('Resolver helper `limit` ->', () => {
 
     it('should not call query.limit if args.limit is empty', () => {
       limitHelper(resolveParams);
-      expect(spyFn).not.toBeCalled();
+      expect(spyFn).not.toHaveBeenCalled();
     });
     it('should call query.limit if args.limit is provided', () => {
       resolveParams.args = { limit: 333 };
       limitHelper(resolveParams);
-      expect(spyFn).toBeCalledWith(333);
+      expect(spyFn).toHaveBeenCalledWith(333);
     });
     it('should convert string to int in args.limit', () => {
       resolveParams.args = { limit: '444' };
       limitHelper(resolveParams);
-      expect(spyFn).toBeCalledWith(444);
+      expect(spyFn).toHaveBeenCalledWith(444);
     });
   });
 });

src/resolvers/helpers/__tests__/projection-test.ts

@@ -16,51 +16,51 @@ describe('Resolver helper `projection` ->', () => {
 
     it('should not call query.select if projection is empty', () => {
       projectionHelper(resolveParams);
-      expect(spyFn).not.toBeCalled();
+      expect(spyFn).not.toHaveBeenCalled();
     });
 
     it('should call query.select if projection is provided', () => {
       resolveParams.projection = { name: 1, age: 1 };
       projectionHelper(resolveParams, { name: 'n' });
-      expect(spyFn).toBeCalledWith({ n: true, age: true });
+      expect(spyFn).toHaveBeenCalledWith({ n: true, age: true });
     });
 
     it('should make projection fields flat', () => {
       resolveParams.projection = { name: { first: 1, last: 1 } };
       projectionHelper(resolveParams, { name: 'n' });
-      expect(spyFn).toBeCalledWith({ 'n.first': true, 'n.last': true });
+      expect(spyFn).toHaveBeenCalledWith({ 'n.first': true, 'n.last': true });
     });
 
     it('should make projection fields flat with nested aliases', () => {
       resolveParams.projection = { name: { first: 1, last: 1 } };
       projectionHelper(resolveParams, { name: { __selfAlias: 'n', first: 'f', last: 'l' } });
-      expect(spyFn).toBeCalledWith({ 'n.f': true, 'n.l': true });
+      expect(spyFn).toHaveBeenCalledWith({ 'n.f': true, 'n.l': true });
     });
 
     it('should not call query.select if projection has * key', () => {
       resolveParams.projection = { '*': true };
       projectionHelper(resolveParams);
-      expect(spyFn).not.toBeCalled();
+      expect(spyFn).not.toHaveBeenCalled();
     });
 
     describe('projection operators', () => {
       // see more details here https://docs.mongodb.com/v3.2/reference/operator/projection/meta/
       it('should pass $meta non-flatten', () => {
         resolveParams.projection = { score: { $meta: 'textScore' } };
         projectionHelper(resolveParams);
-        expect(spyFn).toBeCalledWith({ score: { $meta: 'textScore' } });
+        expect(spyFn).toHaveBeenCalledWith({ score: { $meta: 'textScore' } });
       });
 
       it('should pass $slice non-flatten', () => {
         resolveParams.projection = { comments: { $slice: 5 } };
         projectionHelper(resolveParams);
-        expect(spyFn).toBeCalledWith({ comments: { $slice: 5 } });
+        expect(spyFn).toHaveBeenCalledWith({ comments: { $slice: 5 } });
       });
 
       it('should pass $elemMatch non-flatten', () => {
         resolveParams.projection = { students: { $elemMatch: { school: 102 } } };
         projectionHelper(resolveParams);
-        expect(spyFn).toBeCalledWith({ students: { $elemMatch: { school: 102 } } });
+        expect(spyFn).toHaveBeenCalledWith({ students: { $elemMatch: { school: 102 } } });
       });
     });
   });

src/resolvers/helpers/__tests__/skip-test.ts

@@ -23,17 +23,17 @@ describe('Resolver helper `skip` ->', () => {
 
     it('should not call query.skip if args.skip is empty', () => {
       skipHelper(resolveParams);
-      expect(spyFn).not.toBeCalled();
+      expect(spyFn).not.toHaveBeenCalled();
     });
     it('should call query.skip if args.skip is provided', () => {
       resolveParams.args = { skip: 333 };
       skipHelper(resolveParams);
-      expect(spyFn).toBeCalledWith(333);
+      expect(spyFn).toHaveBeenCalledWith(333);
     });
     it('should convert skip to int in args.skip', () => {
       resolveParams.args = { skip: '444' };
       skipHelper(resolveParams);
-      expect(spyFn).toBeCalledWith(444);
+      expect(spyFn).toHaveBeenCalledWith(444);
     });
   });
 });

src/resolvers/helpers/__tests__/sort-test.ts

@@ -111,7 +111,7 @@ describe('Resolver helper `sort` ->', () => {
       const sortValue = { _id: 1 };
       resolveParams.args = { sort: sortValue };
       sortHelper(resolveParams);
-      expect(spyFn).toBeCalledWith(sortValue);
+      expect(spyFn).toHaveBeenCalledWith(sortValue);
     });
   });
 });

src/types/MongoID.ts

@@ -12,7 +12,7 @@ const GraphQLMongoID = new GraphQLScalarType({
     'But MongoDB also may accepts string or integer as correct values for _id field.',
   serialize: String,
   parseValue(value: any) {
-    if (!ObjectId.isValid(value) && typeof value !== 'string') {
+    if (!ObjectId.isValid(value) && (typeof value !== 'string' && typeof value !== 'number')) {
       throw new TypeError('Field error: value is an invalid ObjectId');
     }
     return value;