graphql-compose-mongoose/lib/__tests__/guthub_issues/135-test.js

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

"use strict";

var _mongoose = _interopRequireDefault(require("mongoose"));

var _mongodbMemoryServer = _interopRequireDefault(require("mongodb-memory-server"));

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

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

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

let mongoServer;
beforeAll(
/*#__PURE__*/
_asyncToGenerator(function* () {
  mongoServer = new _mongodbMemoryServer.default();
  const mongoUri = yield mongoServer.getConnectionString();
  yield _mongoose.default.connect(mongoUri, {
    useNewUrlParser: true
  }); // mongoose.set('debug', true);
}));
afterAll(() => {
  _mongoose.default.disconnect();

  mongoServer.stop();
}); // May require additional time for downloading MongoDB binaries

jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
describe('issue #135 - Mongoose virtuals', () => {
  const RecordSchema = new _mongoose.default.Schema({
    id: String,
    title: String
  }); // ADD VIRTUAL FIELDS VIA loadClass METHOD
  // see https://mongoosejs.com/docs/api.html#schema_Schema-loadClass

  class RecordDoc {
    get virtualField123() {
      // $FlowFixMe
      return `Improved ${this.title}`;
    }

  }

  RecordSchema.loadClass(RecordDoc); // ADD MOCK DATA TO DB

  const Record = _mongoose.default.model('Record', RecordSchema);

  beforeAll(
  /*#__PURE__*/
  _asyncToGenerator(function* () {
    for (let i = 1; i <= 3; i++) {
      // $FlowFixMe
      yield Record.create({
        _id: `10000000000000000000000${i}`,
        title: `Title ${i}`
      });
    }
  })); // ADD VIRTUAL FIELD DEFINITION <-------------------   JUST ADD FIELD DEFINITION 🛑🛑🛑
  // no need to define resolve method explicitly

  const RecordTC = (0, _index.composeWithMongoose)(Record);
  RecordTC.addFields({
    virtualField123: {
      type: 'String'
    }
  }); // INIT GRAPHQL SCHEMA

  _graphqlCompose.schemaComposer.Query.addFields({
    findMany: RecordTC.getResolver('findMany')
  });

  const schema = _graphqlCompose.schemaComposer.buildSchema();

  it('check that virtual field works',
  /*#__PURE__*/
  _asyncToGenerator(function* () {
    const res = yield _graphqlCompose.graphql.graphql({
      schema,
      source: 'query { findMany { id title virtualField123 } }'
    });
    expect(res).toEqual({
      data: {
        findMany: [{
          id: null,
          title: 'Title 1',
          virtualField123: 'Improved Title 1'
        }, {
          id: null,
          title: 'Title 2',
          virtualField123: 'Improved Title 2'
        }, {
          id: null,
          title: 'Title 3',
          virtualField123: 'Improved Title 3'
        }]
      }
    });
  }));
});