Add Relationship fields and resolvers

Author: fzaninotto

src/introspection/getFieldsFromEntities.js

@@ -19,7 +19,7 @@ import getValuesFromEntities from './getValuesFromEntities';
  *         "user_id": 456,
  *     },
  * ];
- * const types = getFieldsFromData(entities);
+ * const types = getFieldsFromEntities(entities);
  * // {
  * //    id: { type: graphql.GraphQLString },
  * //    title: { type: graphql.GraphQLString },

src/introspection/getSchemaFromData.js

@@ -7,10 +7,14 @@ import {
     GraphQLObjectType,
     GraphQLSchema,
     GraphQLString,
+    parse,
+    extendSchema,
 } from 'graphql';
 import { pluralize, camelize } from 'inflection';
 
 import getTypesFromData from './getTypesFromData';
+import { isRelationshipField } from '../relationships';
+import { getRelatedType } from '../nameConverter';
 
 /**
  * Get a GraphQL schema from data
@@ -153,5 +157,25 @@ export default data => {
         }, {}),
     });
 
-    return new GraphQLSchema({ query: queryType, mutation: mutationType });
+    let schema = new GraphQLSchema({
+        query: queryType,
+        mutation: mutationType,
+    });
+
+    // extend schema to add relationship fields
+    Object.values(typesByName).map(type => {
+        Object.keys(type.getFields())
+            .filter(isRelationshipField)
+            .map(fieldName => {
+                const relatedType = getRelatedType(fieldName);
+                schema = extendSchema(
+                    schema,
+                    parse(
+                        `extend type ${type} { ${relatedType}: ${relatedType}} `,
+                    ),
+                );
+            });
+    });
+
+    return schema;
 };

src/introspection/getSchemaFromData.spec.js

@@ -2,7 +2,6 @@ import {
     GraphQLBoolean,
     GraphQLID,
     GraphQLInt,
-    GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
     GraphQLString,
@@ -36,31 +35,34 @@ const data = {
     ],
 };
 
+const UserType = new GraphQLObjectType({
+    name: 'User',
+    fields: {
+        id: { type: new GraphQLNonNull(GraphQLID) },
+        name: { type: new GraphQLNonNull(GraphQLString) },
+    },
+});
+
 const PostType = new GraphQLObjectType({
     name: 'Post',
     fields: {
         id: { type: new GraphQLNonNull(GraphQLID) },
         title: { type: new GraphQLNonNull(GraphQLString) },
         views: { type: new GraphQLNonNull(GraphQLInt) },
         user_id: { type: new GraphQLNonNull(GraphQLID) },
-    },
-});
-const UserType = new GraphQLObjectType({
-    name: 'User',
-    fields: {
-        id: { type: new GraphQLNonNull(GraphQLID) },
-        name: { type: new GraphQLNonNull(GraphQLString) },
+        User: { type: UserType },
     },
 });
 
+/*
 const ListMetadataType = new GraphQLObjectType({
     name: 'ListMetadata',
     fields: {
         count: { type: GraphQLInt },
     },
 });
 
-const QueryType = new GraphQLObjectType({ // eslint-disable-line 
+const QueryType = new GraphQLObjectType({
     name: 'Query',
     fields: {
         getPost: {
@@ -97,13 +99,18 @@ const QueryType = new GraphQLObjectType({ // eslint-disable-line
         },
     },
 });
+*/
 
 test('creates one type per data type', () => {
     const typeMap = getSchemaFromData(data).getTypeMap();
     expect(typeMap['Post'].name).toEqual(PostType.name);
-    expect(typeMap['Post'].fields).toEqual(PostType.fields);
+    expect(Object.keys(typeMap['Post'].getFields())).toEqual(
+        Object.keys(PostType.getFields()),
+    );
     expect(typeMap['User'].name).toEqual(UserType.name);
-    expect(typeMap['User'].fields).toEqual(UserType.fields);
+    expect(Object.keys(typeMap['User'].getFields())).toEqual(
+        Object.keys(UserType.getFields()),
+    );
 });
 
 test('creates three query fields per data type', () => {
@@ -117,7 +124,7 @@ test('creates three query fields per data type', () => {
             type: new GraphQLNonNull(GraphQLID),
         },
     ]);
-    expect(queries['allPosts'].type).toMatchObject(new GraphQLList(PostType));
+    expect(queries['allPosts'].type.toString()).toEqual('[Post]');
     expect(queries['allPosts'].args).toEqual([
         {
             defaultValue: undefined,
@@ -150,7 +157,7 @@ test('creates three query fields per data type', () => {
             type: GraphQLString,
         },
     ]);
-    expect(queries['_allPostsMeta'].type).toMatchObject(ListMetadataType);
+    expect(queries['_allPostsMeta'].type.toString()).toEqual('ListMetadata');
 
     expect(queries['User'].type.name).toEqual(UserType.name);
     expect(queries['User'].args).toEqual([
@@ -161,7 +168,7 @@ test('creates three query fields per data type', () => {
             type: new GraphQLNonNull(GraphQLID),
         },
     ]);
-    expect(queries['allUsers'].type).toMatchObject(new GraphQLList(UserType));
+    expect(queries['allUsers'].type.toString()).toEqual('[User]');
     expect(queries['allUsers'].args).toEqual([
         {
             defaultValue: undefined,
@@ -194,7 +201,7 @@ test('creates three query fields per data type', () => {
             type: GraphQLString,
         },
     ]);
-    expect(queries['_allPostsMeta'].type).toMatchObject(ListMetadataType);
+    expect(queries['_allPostsMeta'].type.toString()).toEqual('ListMetadata');
 });
 
 test('creates three mutation fields per data type', () => {

src/introspection/getTypesFromData.js

@@ -2,6 +2,7 @@ import { GraphQLObjectType } from 'graphql';
 import { singularize, camelize } from 'inflection';
 
 import getFieldsFromEntities from './getFieldsFromEntities';
+import { getTypeFromKey } from '../nameConverter';
 
 /**
  * Get a list of GraphQLObjectType from data
@@ -61,6 +62,5 @@ export default data =>
         }))
         .map(typeObject => new GraphQLObjectType(typeObject));
 
-export const getTypeNameFromKey = key => camelize(singularize(key));
 export const getTypeNamesFromData = data =>
-    Object.keys(data).map(getTypeNameFromKey);
+    Object.keys(data).map(getTypeFromKey);

src/nameConverter.js

@@ -0,0 +1,45 @@
+import { camelize, pluralize, singularize } from 'inflection';
+
+/**
+ * A bit of vocabulary
+ * 
+ * Consider this data:
+ * {
+ *     posts: [
+ *          { id: 1, title: 'foo', user_id: 123 }
+ *     ],
+ *     users: [
+ *          { id: 123, name: 'John Doe' }
+ *     ]
+ * }
+ * 
+ * We'll use the following names:
+ * - key: the keys in the data map, e.g. 'posts', 'users'
+ * - type: for a key, the related type in the graphQL schema, e.g. 'posts' => 'Post', 'users' => 'User'
+ * - field: the keys in a record, e.g. 'id', 'foo', user_id'
+ * - relationship field: a key ending in '_id', e.g. 'user_id'
+ * - related key: for a relationship field, the related key, e.g. 'user_id' => 'users'
+ */
+
+/**
+ * 
+ * @param {String} fieldName 'users'
+ * @return {String} 'User'
+ */
+export const getTypeFromKey = key => camelize(singularize(key));
+
+/**
+ * 
+ * @param {String} fieldName 'user_id'
+ * @return {String} 'users'
+ */
+export const getRelatedKey = fieldName =>
+    pluralize(fieldName.substr(0, fieldName.length - 3));
+
+/**
+ * 
+ * @param {String} fieldName 'user_id'
+ * @return {String} 'User'
+ */
+export const getRelatedType = fieldName =>
+    getTypeFromKey(fieldName.substr(0, fieldName.length - 3));

src/relationships.js

@@ -0,0 +1 @@
+export const isRelationshipField = fieldName => fieldName.endsWith('_id');

src/resolver/Entity/index.js

@@ -0,0 +1,17 @@
+import getFieldsFromEntities from '../../introspection/getFieldsFromEntities';
+import { getRelatedKey, getRelatedType } from '../../nameConverter';
+import { isRelationshipField } from '../../relationships';
+
+export default (key, data) =>
+    Object.keys(getFieldsFromEntities(data[key]))
+        .filter(isRelationshipField)
+        .reduce(
+            (resolvers, fieldName) => ({
+                ...resolvers,
+                [getRelatedType(fieldName)]: entity =>
+                    data[getRelatedKey(fieldName)].find(
+                        relatedRecord => relatedRecord.id == entity[fieldName],
+                    ),
+            }),
+            {},
+        );

src/resolver/index.js

@@ -6,7 +6,8 @@ import single from './Query/single';
 import create from './Mutation/create';
 import update from './Mutation/update';
 import remove from './Mutation/remove';
-import { getTypeNameFromKey } from '../introspection/getTypesFromData';
+import entityResolver from './Entity';
+import { getTypeFromKey } from '../nameConverter';
 
 const getQueryResolvers = (entityName, data) => ({
     [`all${pluralize(entityName)}`]: all(data),
@@ -25,14 +26,21 @@ export default data => {
         Query: Object.keys(data).reduce(
             (resolvers, key) => ({
                 ...resolvers,
-                ...getQueryResolvers(getTypeNameFromKey(key), data[key]),
+                ...getQueryResolvers(getTypeFromKey(key), data[key]),
             }),
             {},
         ),
         Mutation: Object.keys(data).reduce(
             (resolvers, key) => ({
                 ...resolvers,
-                ...getMutationResolvers(getTypeNameFromKey(key), data[key]),
+                ...getMutationResolvers(getTypeFromKey(key), data[key]),
+            }),
+            {},
+        ),
+        ...Object.keys(data).reduce(
+            (resolvers, key) => ({
+                ...resolvers,
+                [getTypeFromKey(key)]: entityResolver(key, data),
             }),
             {},
         ),