feat: add support for alias mongoose option. It allows to have different names in schema and database. See https://mongoosejs.com/docs/guide.html#aliases

Closes #194

Author: nodkz

README.md

@@ -34,7 +34,7 @@ import { composeWithMongoose } from 'graphql-compose-mongoose';
 // For using node 8 and above (native async/await)
 import { composeWithMongoose } from 'graphql-compose-mongoose/node8';
 
-// Source code without Flowtype declarations
+// Source code without FlowType declarations
 import { composeWithMongoose } from 'graphql-compose-mongoose/es';
 ```
 
@@ -56,7 +56,7 @@ Small explanation for variables naming:
 
 - `UserSchema` - this is a mongoose schema
 - `User` - this is a mongoose model
-- `UserTC` - this is a `ObjectTypeComposer` instance for User. `ObjectTypeComposer` has `GraphQLObjectType` inside, avaliable via method `UserTC.getType()`.
+- `UserTC` - this is a `ObjectTypeComposer` instance for User. `ObjectTypeComposer` has `GraphQLObjectType` inside, available via method `UserTC.getType()`.
 - Here and in all other places of code variables suffix `...TC` means that this is `ObjectTypeComposer` instance, `...ITC` - `InputTypeComposer`, `...ETC` - `EnumTypeComposer`.
 
 ```js
@@ -79,17 +79,18 @@ const UserSchema = new mongoose.Schema({
     type: Number,
     index: true,
   },
-  languages: {
+  ln: {
     type: [LanguagesSchema], // you may include other schemas (here included as array of embedded documents)
     default: [],
+    alias: 'languages', // in schema `ln` will be named as `languages`
   },
   contacts: { // another mongoose way for providing embedded documents
     email: String,
     phones: [String], // array of strings
   },
   gender: { // enum field with values
     type: String,
-    enum: ['male', 'female', 'ladyboy'],
+    enum: ['male', 'female'],
   },
   someMixed: {
     type: mongoose.Schema.Types.Mixed,
@@ -201,7 +202,7 @@ Variable Namings
   const CharacterDTC = composeWithMongooseDiscriminators(CharacterModel, baseOptions);
 
   // create Discriminator Types
-  const droidTypeConverterOptions = {  // this options will be merged with baseOptions -> customisationsOptions
+  const droidTypeConverterOptions = {  // this options will be merged with baseOptions -> customizationsOptions
     fields: {
       remove: ['makeDate'],
     }
@@ -528,6 +529,19 @@ const UsersSchema = new Schema({
 });
 ```
 
+### Can field name in schema have different name in database?
+
+Yes, it can. This package understands mongoose [`alias` option](https://mongoosejs.com/docs/guide.html#aliases) for fields. Just provide `alias: 'country'` for field `c` and you get `country` field name in GraphQL schema and Mongoose model but `c` field in database:
+
+```js
+const childSchema = new Schema({
+  c: {
+    type: String,
+    alias: 'country'
+  }
+});
+```
+
 ## Customization options
 
 When we convert model `const UserTC = composeWithMongoose(User, customizationOptions);` you may tune every piece of future derived types and resolvers.

src/__mocks__/userModel.js

@@ -26,10 +26,11 @@ const UserSchema: SchemaType<any> = new Schema(
       ref: 'UserModel',
     },
 
-    name: {
+    n: {
       type: String,
       required: true,
       description: 'Person name',
+      alias: 'name',
     },
 
     age: {

src/__tests__/__snapshots__/integration-test.js.snap

@@ -8,7 +8,7 @@ Array [
   "employment",
   "contacts",
   "_id",
-  "name",
+  "n",
   "age",
   "gender",
   "relocation",
@@ -17,6 +17,7 @@ Array [
   "createdAt",
   "updatedAt",
   "__v",
+  "name",
   "nameVirtual",
   "id",
 ]

src/__tests__/fieldConverter-test.js

@@ -26,7 +26,7 @@ describe('fieldConverter', () => {
 
   describe('getFieldsFromModel()', () => {
     it('should get fieldsMap from mongoose model', () => {
-      expect(Object.keys(fields)).toEqual(expect.arrayContaining(['name', 'createdAt', '_id']));
+      expect(Object.keys(fields)).toEqual(expect.arrayContaining(['n', 'createdAt', '_id']));
     });
 
     it('should skip double undescored fields', () => {
@@ -101,7 +101,7 @@ describe('fieldConverter', () => {
     });
 
     it('should derive SCALAR', () => {
-      expect(deriveComplexType(fields.name)).toBe(ComplexTypes.SCALAR);
+      expect(deriveComplexType(fields.n)).toBe(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.relocation)).toBe(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.age)).toBe(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.createdAt)).toBe(ComplexTypes.SCALAR);

src/__tests__/github_issues/194-test.js

@@ -0,0 +1,57 @@
+/* @flow */
+/* eslint-disable no-await-in-loop */
+
+import mongoose from 'mongoose';
+import MongodbMemoryServer from 'mongodb-memory-server';
+import { schemaComposer, graphql } from 'graphql-compose';
+import { composeWithMongoose } from '../../index';
+
+let mongoServer;
+beforeAll(async () => {
+  mongoServer = new MongodbMemoryServer();
+  const mongoUri = await mongoServer.getConnectionString();
+  await mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+  // mongoose.set('debug', true);
+});
+
+afterAll(() => {
+  mongoose.disconnect();
+  mongoServer.stop();
+});
+
+// May require additional time for downloading MongoDB binaries
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
+
+describe('issue #194 - useAlias', () => {
+  const UserSchema = new mongoose.Schema({
+    e: {
+      type: String,
+      alias: 'emailAddress',
+    },
+  });
+
+  const User = mongoose.model('User', UserSchema);
+  const UserTC = composeWithMongoose(User);
+
+  it('check that virtual field works', async () => {
+    // INIT GRAPHQL SCHEMA
+    schemaComposer.Query.addFields({ findMany: UserTC.getResolver('findMany') });
+    schemaComposer.Mutation.addFields({
+      createOne: UserTC.getResolver('createOne'),
+    });
+    const schema = schemaComposer.buildSchema();
+
+    const res = await graphql.graphql({
+      schema,
+      source:
+        'mutation { createOne(record: { emailAddress: "[email protected]" }) { record { emailAddress } } }',
+    });
+    expect(res).toEqual({ data: { createOne: { record: { emailAddress: '[email protected]' } } } });
+
+    const res2 = await graphql.graphql({
+      schema,
+      source: 'query { findMany { emailAddress } }',
+    });
+    expect(res2).toEqual({ data: { findMany: [{ emailAddress: '[email protected]' }] } });
+  });
+});

src/fieldsConverter.js

@@ -142,8 +142,13 @@ export function convertModelToGraphQL<TSource, TContext>(
   const graphqlFields = {};
   const requiredFields = [];
 
-  Object.keys(mongooseFields).forEach((fieldName) => {
-    const mongooseField: MongooseFieldT = mongooseFields[fieldName];
+  Object.keys(mongooseFields).forEach((key) => {
+    const mongooseField: MongooseFieldT = mongooseFields[key];
+
+    let fieldName = key;
+    if (typeof (mongooseField: any)?.options?.alias === 'string') {
+      fieldName = (mongooseField: any)?.options?.alias;
+    }
 
     if (
       (mongooseField: any).isRequired &&

src/resolvers/__tests__/createMany-test.js

@@ -111,8 +111,8 @@ describe('createMany() ->', () => {
 
       const docs = await UserModel.collection.find({ _id: { $in: res.recordIds } }).toArray();
       expect(docs.length).toBe(2);
-      expect(docs[0].name).toBe(checkedName);
-      expect(docs[1].name).toBe(checkedName);
+      expect(docs[0].n).toBe(checkedName);
+      expect(docs[1].n).toBe(checkedName);
     });
 
     it('should return payload.records', async () => {

src/resolvers/__tests__/createOne-test.js

@@ -77,7 +77,7 @@ describe('createOne() ->', () => {
       });
 
       const doc = await UserModel.collection.findOne({ _id: res.record._id });
-      expect(doc.name).toBe(checkedName);
+      expect(doc.n).toBe(checkedName);
     });
 
     it('should return payload.record', async () => {

src/resolvers/__tests__/removeById-test.js

@@ -145,7 +145,7 @@ describe('removeById() ->', () => {
       });
       await expect(result).rejects.toMatchSnapshot();
       const exist = await UserModel.collection.findOne({ _id: user._id });
-      expect(exist.name).toBe(user.name);
+      expect(exist.n).toBe(user.name);
     });
 
     it('should call `beforeQuery` method with non-executed `query` as arg', async () => {

src/resolvers/__tests__/removeOne-test.js

@@ -187,7 +187,7 @@ describe('removeOne() ->', () => {
       });
       await expect(result).rejects.toMatchSnapshot();
       const exist = await UserModel.collection.findOne({ _id: user1._id });
-      expect(exist.name).toBe(user1.name);
+      expect(exist.n).toBe(user1.name);
     });
 
     it('should call `beforeQuery` method with non-executed `query` as arg', async () => {