Add support for fields with MIXED type via https://github.com/taion/graphql-type-json

Author: nodkz

package.json

@@ -25,7 +25,8 @@
   "homepage": "https://github.com/nodkz/graphql-compose-mongoose",
   "dependencies": {
     "babel-runtime": "6.11.6",
-    "object-path": "^0.11.0"
+    "graphql-type-json": "0.1.2",
+    "object-path": "0.11.0"
   },
   "peerDependencies": {
     "graphql": ">=0.5.0 || >=0.6.0",

src/__mocks__/userModel.js

@@ -70,13 +70,17 @@ const UserSchema = new Schema(
       description: 'Knowledge of languages',
     },
 
-    // createdAt, created via option `timastamp: true`
-
-    // updatedAt, created via option `timastamp: true`
-
     __secretField: {
       type: String,
     },
+
+    someDynamic: {
+      type: Schema.Types.Mixed,
+      description: 'Some mixed value, that served with @taion\'s `graphql-type-json`',
+    },
+
+    // createdAt, created via option `timastamp: true` (see bottom)
+    // updatedAt, created via option `timastamp: true` (see bottom)
   },
   {
     timestamps: true, // add createdAt, updatedAt fields

src/__tests__/fieldConverter-test.js

@@ -1,6 +1,22 @@
 /* eslint-disable no-unused-expressions */
 
 import { expect } from 'chai';
+import {
+  GraphQLString,
+  GraphQLFloat,
+  GraphQLBoolean,
+  GraphQLList,
+  GraphQLEnumType,
+  GraphQLSchema,
+  GraphQLObjectType,
+  graphql,
+} from 'graphql';
+import GraphQLJSON from 'graphql-type-json';
+import {
+  GraphQLDate,
+  GraphQLBuffer,
+  GraphQLGeneric,
+} from 'graphql-compose';
 import { UserModel } from '../__mocks__/userModel.js';
 import {
   deriveComplexType,
@@ -12,23 +28,11 @@ import {
   embeddedToGraphQL,
   enumToGraphQL,
   documentArrayToGraphQL,
+  mixedToGraphQL,
 } from '../fieldsConverter';
-
-import {
-  GraphQLString,
-  GraphQLFloat,
-  GraphQLBoolean,
-  GraphQLList,
-  GraphQLEnumType,
-} from 'graphql';
+import { composeWithMongoose } from '../composeWithMongoose';
 import GraphQLMongoID from '../types/mongoid';
 
-import {
-  GraphQLDate,
-  GraphQLBuffer,
-  GraphQLGeneric,
-} from 'graphql-compose';
-
 /*
 Object.prototype.getClassName = function getClassName() {
   const funcNameRegex = /function (.{1,})\(/;
@@ -101,6 +105,10 @@ describe('fieldConverter', () => {
       expect(deriveComplexType(fields.gender)).not.to.equal(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.subDoc)).not.to.equal(ComplexTypes.SCALAR);
     });
+
+    it('schould derive MIXED mongoose type', () => {
+      expect(deriveComplexType(fields.someDynamic)).to.equal(ComplexTypes.MIXED);
+    });
   });
 
   describe('convertFieldToGraphQL()', () => {
@@ -191,6 +199,53 @@ describe('fieldConverter', () => {
     });
   });
 
+  describe('mixedToGraphQL()', () => {
+    let user;
+    const UserTC = composeWithMongoose(UserModel);
+
+    before('add test user document to mongoDB', (done) => {
+      user = new UserModel({
+        name: 'nodkz',
+        someDynamic: {
+          a: 123,
+          b: [1, 2],
+          c: { c: 1 },
+          d: null,
+          e: 'str',
+        },
+      });
+      user.save(done);
+    });
+
+    it('should produce GraphQLJSON', () => {
+      const someDynamicType = mixedToGraphQL(fields.someDynamic);
+      expect(someDynamicType).to.equal(GraphQLJSON);
+    });
+
+    it('should properly return data via graphql query', async () => {
+      const schema = new GraphQLSchema({
+        query: new GraphQLObjectType({
+          name: 'Query',
+          fields: {
+            user: UserTC.getResolver('findById').getFieldConfig(),
+          },
+        }),
+      });
+
+      const query = `{
+        user(_id: "${user._id}") {
+          name
+          someDynamic
+        }
+      }`;
+      const result = await graphql(schema, query);
+      expect(result).deep.property('data.user.name').to.equals(user.name);
+      expect(result)
+        .deep.property('data.user.someDynamic')
+        .deep.equals(user.someDynamic);
+    });
+  });
+
   describe('referenceToGraphQL()', () => {
     xit('', () => {
 

src/definition.js

@@ -8,7 +8,7 @@ export type connectionSortMapOpts = _connectionSortMapOpts;
 export type ObjectMap = { [optName: string]: any };
 
 export type ComplexTypesT =
- 'ARRAY' | 'EMBEDDED' | 'DOCUMENT_ARRAY' | 'ENUM' | 'REFERENCE' | 'SCALAR';
+ 'ARRAY' | 'EMBEDDED' | 'DOCUMENT_ARRAY' | 'ENUM' | 'REFERENCE' | 'MIXED' | 'SCALAR';
 
 export type MongooseModelSchemaT = {
   paths: {

src/fieldsConverter.js

@@ -19,6 +19,7 @@ import {
   GraphQLEnumType,
   GraphQLObjectType,
 } from 'graphql';
+import GraphQLJSON from 'graphql-type-json';
 import GraphQLMongoID from './types/mongoid';
 import typeStorage from './typeStorage';
 
@@ -39,6 +40,7 @@ export const ComplexTypes = {
   ENUM: 'ENUM',
   REFERENCE: 'REFERENCE',
   SCALAR: 'SCALAR',
+  MIXED: 'MIXED',
 };
 
 function _getFieldName(field: MongooseFieldT): string {
@@ -191,6 +193,7 @@ export function convertFieldToGraphQL(
     case ComplexTypes.ENUM: return enumToGraphQL(field, prefix);
     case ComplexTypes.REFERENCE: return referenceToGraphQL(field, prefix);
     case ComplexTypes.DOCUMENT_ARRAY: return documentArrayToGraphQL(field, prefix);
+    case ComplexTypes.MIXED: return mixedToGraphQL(field);
     default: return scalarToGraphQL(field);
   }
 }
@@ -212,6 +215,8 @@ export function deriveComplexType(field: MongooseFieldT): ComplexTypesT {
   } else if (field instanceof mongoose.Schema.Types.Array
     || objectPath.has(field, 'caster.instance')) {
     return ComplexTypes.ARRAY;
+  } else if (field instanceof mongoose.Schema.Types.Mixed) {
+    return ComplexTypes.MIXED;
   } else if (fieldType === 'ObjectID') {
     return ComplexTypes.REFERENCE;
   }
@@ -352,3 +357,14 @@ export function referenceToGraphQL(
   // this is mongo id field
   return scalarToGraphQL(field, prefix);
 }
+
+export function mixedToGraphQL(
+  field: MongooseFieldT
+): GraphQLOutputType {
+  if (!(field instanceof mongoose.Schema.Types.Mixed)) {
+    throw new Error('You provide incorrect mongoose field to `mixedToGraphQL()`. '
+    + 'Correct field should be instance of `mongoose.Schema.Types.Mixed`');
+  }
+
+  return GraphQLJSON;
+}