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 () => {

src/resolvers/__tests__/updateById-test.js

@@ -185,7 +185,7 @@ describe('updateById() ->', () => {
       });
       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 () => {

src/resolvers/__tests__/updateMany-test.js

@@ -98,7 +98,7 @@ describe('updateMany() ->', () => {
       });
 
       await expect(UserModel.findOne({ _id: user1._id })).resolves.toEqual(
-        expect.objectContaining({ name: checkedName })
+        expect.objectContaining({ n: checkedName })
       );
     });
 

src/resolvers/__tests__/updateOne-test.js

@@ -209,7 +209,7 @@ describe('updateOne() ->', () => {
       });
       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 () => {

src/resolvers/count.js

@@ -3,7 +3,7 @@
 
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { MongooseDocument } from 'mongoose';
-import { filterHelper, filterHelperArgs } from './helpers';
+import { filterHelper, filterHelperArgs, prepareAliases } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 
@@ -20,6 +20,8 @@ export default function count<TSource: MongooseDocument, TContext>(
     throw new Error('Second arg for Resolver count() should be instance of ObjectTypeComposer.');
   }
 
+  const aliases = prepareAliases(model);
+
   return tc.schemaComposer.createResolver({
     type: 'Int',
     name: 'count',
@@ -34,7 +36,7 @@ export default function count<TSource: MongooseDocument, TContext>(
     resolve: (resolveParams: ExtendedResolveParams) => {
       resolveParams.query = model.find();
       resolveParams.model = model;
-      filterHelper(resolveParams);
+      filterHelper(resolveParams, aliases);
       if (resolveParams.query.countDocuments) {
         // mongoose 5.2.0 and above
         resolveParams.query.countDocuments();

src/resolvers/findById.js

@@ -2,7 +2,7 @@
 
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { MongooseDocument } from 'mongoose';
-import { projectionHelper } from './helpers';
+import { projectionHelper, prepareAliases } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 
@@ -19,6 +19,8 @@ export default function findById<TSource: MongooseDocument, TContext>(
     throw new Error('Second arg for Resolver findById() should be instance of ObjectTypeComposer.');
   }
 
+  const aliases = prepareAliases(model);
+
   return tc.schemaComposer.createResolver({
     type: tc,
     name: 'findById',
@@ -32,7 +34,7 @@ export default function findById<TSource: MongooseDocument, TContext>(
       if (args._id) {
         resolveParams.query = model.findById(args._id); // eslint-disable-line
         resolveParams.model = model; // eslint-disable-line
-        projectionHelper(resolveParams);
+        projectionHelper(resolveParams, aliases);
         return beforeQueryHelper(resolveParams);
       }
       return Promise.resolve(null);

src/resolvers/findByIds.js

@@ -8,6 +8,7 @@ import {
   sortHelper,
   sortHelperArgs,
   projectionHelper,
+  prepareAliases,
 } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
@@ -27,6 +28,8 @@ export default function findByIds<TSource: MongooseDocument, TContext>(
     );
   }
 
+  const aliases = prepareAliases(model);
+
   return tc.schemaComposer.createResolver({
     type: tc.getTypeNonNull().getTypePlural(),
     name: 'findByIds',
@@ -54,7 +57,7 @@ export default function findByIds<TSource: MongooseDocument, TContext>(
 
       resolveParams.query = model.find(selector); // eslint-disable-line
       resolveParams.model = model; // eslint-disable-line
-      projectionHelper(resolveParams);
+      projectionHelper(resolveParams, aliases);
       limitHelper(resolveParams);
       sortHelper(resolveParams);
       return beforeQueryHelper(resolveParams);

src/resolvers/findMany.js

@@ -13,6 +13,7 @@ import {
   sortHelper,
   sortHelperArgs,
   projectionHelper,
+  prepareAliases,
 } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
@@ -30,6 +31,8 @@ export default function findMany<TSource: MongooseDocument, TContext>(
     throw new Error('Second arg for Resolver findMany() should be instance of ObjectTypeComposer.');
   }
 
+  const aliases = prepareAliases(model);
+
   return tc.schemaComposer.createResolver({
     type: tc.getTypeNonNull().getTypePlural(),
     name: 'findMany',
@@ -52,11 +55,11 @@ export default function findMany<TSource: MongooseDocument, TContext>(
     resolve: (resolveParams: ExtendedResolveParams) => {
       resolveParams.query = model.find();
       resolveParams.model = model;
-      filterHelper(resolveParams);
+      filterHelper(resolveParams, aliases);
       skipHelper(resolveParams);
       limitHelper(resolveParams);
       sortHelper(resolveParams);
-      projectionHelper(resolveParams);
+      projectionHelper(resolveParams, aliases);
       return beforeQueryHelper(resolveParams);
     },
   });

src/resolvers/findOne.js

@@ -11,6 +11,7 @@ import {
   sortHelper,
   sortHelperArgs,
   projectionHelper,
+  prepareAliases,
 } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
@@ -28,6 +29,8 @@ export default function findOne<TSource: MongooseDocument, TContext>(
     throw new Error('Second arg for Resolver findOne() should be instance of ObjectTypeComposer.');
   }
 
+  const aliases = prepareAliases(model);
+
   return tc.schemaComposer.createResolver({
     type: tc,
     name: 'findOne',
@@ -47,10 +50,10 @@ export default function findOne<TSource: MongooseDocument, TContext>(
     resolve: (resolveParams: ExtendedResolveParams) => {
       resolveParams.query = model.findOne({}); // eslint-disable-line
       resolveParams.model = model;
-      filterHelper(resolveParams);
+      filterHelper(resolveParams, aliases);
       skipHelper(resolveParams);
       sortHelper(resolveParams);
-      projectionHelper(resolveParams);
+      projectionHelper(resolveParams, aliases);
       return beforeQueryHelper(resolveParams);
     },
   });