graphql-compose-mongoose/lib/__tests__/integration-test.js

Plugin for `graphql-compose` which derive a graphql types from a mongoose model.

"use strict";

var _graphqlCompose = require("graphql-compose");

var _graphql = require("graphql-compose/lib/graphql");

var _userModel = require("../__mocks__/userModel");

var _index = require("../index");

beforeAll(() => _userModel.UserModel.base.connect());
afterAll(() => _userModel.UserModel.base.disconnect());
describe('integration tests', () => {
  beforeEach(() => {
    _graphqlCompose.schemaComposer.clear();
  });
  describe('check subdocuments', () => {
    it('should return null if subdocument is empty', async () => {
      const UserTC = (0, _index.composeWithMongoose)(_userModel.UserModel);

      _graphqlCompose.schemaComposer.Query.addFields({
        user: UserTC.getResolver('findById')
      });

      const schema = _graphqlCompose.schemaComposer.buildSchema();

      const user = new _userModel.UserModel({
        name: 'Test empty subDoc'
      });
      await user.save();
      const result = await (0, _graphql.graphql)(schema, `{
        user(_id: "${user._id}") {
          name
          subDoc {
            field1
            field2 {
              field21
            }
          }
        }
      }`);
      expect(result.data.user).toEqual({
        name: 'Test empty subDoc',
        subDoc: null
      });
    });
    it('should return subdocument if it is non-empty', async () => {
      const UserTC = (0, _index.composeWithMongoose)(_userModel.UserModel); // UserTC.get('$findById.subDoc').extendField('field2', {
      //   resolve: (source) => {
      //     console.log('$findById.subDoc.field2 source:', source)
      //     return source.field2;
      //   }
      // })

      _graphqlCompose.schemaComposer.Query.addFields({
        user: UserTC.getResolver('findById')
      });

      const schema = _graphqlCompose.schemaComposer.buildSchema();

      const user2 = new _userModel.UserModel({
        name: 'Test non empty subDoc',
        subDoc: {
          field2: {
            field21: 'ok'
          }
        }
      });
      await user2.save();
      const result2 = await (0, _graphql.graphql)(schema, `{
        user(_id: "${user2._id}") {
          name
          subDoc {
            field1
            field2 {
              field21
            }
          }
        }
      }`);
      expect(result2.data.user).toEqual({
        name: 'Test non empty subDoc',
        subDoc: {
          field1: null,
          field2: {
            field21: 'ok'
          }
        }
      });
    });
  });
  describe('check mixed field', () => {
    it('should properly return data via graphql query', async () => {
      const UserTC = (0, _index.composeWithMongoose)(_userModel.UserModel, {
        schemaComposer: _graphqlCompose.schemaComposer
      });
      const user = new _userModel.UserModel({
        name: 'nodkz',
        someDynamic: {
          a: 123,
          b: [1, 2, true, false, 'ok'],
          c: {
            c: 1
          },
          d: null,
          e: 'str',
          f: true,
          g: false
        }
      });
      await user.save();

      _graphqlCompose.schemaComposer.Query.addFields({
        user: UserTC.getResolver('findById')
      });

      const schema = _graphqlCompose.schemaComposer.buildSchema();

      const query = `{
        user(_id: "${user._id}") {
          name
          someDynamic
        }
      }`;
      const result = await (0, _graphql.graphql)(schema, query);
      expect(result.data.user.name).toBe(user.name);
      expect(result.data.user.someDynamic).toEqual(user.someDynamic);
    });
  });
  describe('projection', () => {
    let schema;
    let UserTC;
    beforeAll(async () => {
      UserTC = (0, _index.composeWithMongoose)(_userModel.UserModel);
      UserTC.addFields({
        rawData: {
          type: 'JSON',
          resolve: source => source.toJSON(),
          projection: {
            '*': true
          }
        }
      });

      _graphqlCompose.schemaComposer.Query.addFields({
        user: UserTC.getResolver('findById')
      });

      schema = _graphqlCompose.schemaComposer.buildSchema();
      await _userModel.UserModel.create({
        _id: '100000000000000000000000',
        name: 'Name',
        age: 20,
        gender: 'male',
        skills: ['a', 'b', 'c'],
        relocation: true
      });
    });
    it('should request only fields from query', async () => {
      const res = await (0, _graphql.graphql)(schema, '{ user(_id: "100000000000000000000000") { name } }');
      expect(res).toMatchSnapshot('projection from query fields');
    });
    it('should request all fields to rawData field', async () => {
      const res = await (0, _graphql.graphql)(schema, '{ user(_id: "100000000000000000000000") { rawData } }');
      expect(Object.keys(res.data.user.rawData)).toMatchSnapshot('projection from all fields');
    });
  });
});