Add one-to-many relationship support

Author: fzaninotto

src/introspection/getSchemaFromData.js

@@ -157,25 +157,33 @@ export default data => {
         }, {}),
     });
 
-    let schema = new GraphQLSchema({
+    const 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}} `,
-                    ),
-                );
-            });
-    });
+    /**
+     * extend schema to add relationship fields
+     * 
+     * @example
+     * If the `post` key contains a 'user_id' field, then
+     * add one-to-many and many-to-one type extensions:
+     *     extend type Post { User: User }
+     *     extend type User { Posts: [Post] }
+     */
+    const schemaExtension = Object.values(typesByName)
+        .reduce((ext, type) => {
+            Object.keys(type.getFields())
+                .filter(isRelationshipField)
+                .map(fieldName => {
+                    const relType = getRelatedType(fieldName);
+                    const rel = pluralize(type.toString());
+                    ext.push(`extend type ${type} { ${relType}: ${relType} }`);
+                    ext.push(`extend type ${relType} { ${rel}: [${type}] }`);
+                });
+            return ext;
+        }, [])
+        .join('\n');
 
-    return schema;
+    return extendSchema(schema, parse(schemaExtension));
 };

src/nameConverter.js

@@ -21,6 +21,13 @@ import { camelize, pluralize, singularize } from 'inflection';
  * - related key: for a relationship field, the related key, e.g. 'user_id' => 'users'
  */
 
+/**
+ * 
+ * @param {String} fieldName 'users'
+ * @return {String} 'Users'
+ */
+export const getRelationshipFromKey = key => camelize(key);
+
 /**
  * 
  * @param {String} fieldName 'users'
@@ -36,6 +43,13 @@ export const getTypeFromKey = key => camelize(singularize(key));
 export const getRelatedKey = fieldName =>
     pluralize(fieldName.substr(0, fieldName.length - 3));
 
+/**
+ * 
+ * @param {String} key 'users'
+ * @return {String} 'user_id'
+ */
+export const getReverseRelatedField = key => `${singularize(key)}_id`;
+
 /**
  * 
  * @param {String} fieldName 'user_id'

src/resolver/Entity/index.js

@@ -1,9 +1,67 @@
 import getFieldsFromEntities from '../../introspection/getFieldsFromEntities';
-import { getRelatedKey, getRelatedType } from '../../nameConverter';
+import {
+    getRelatedKey,
+    getRelatedType,
+    getRelationshipFromKey,
+    getReverseRelatedField,
+} from '../../nameConverter';
 import { isRelationshipField } from '../../relationships';
 
-export default (key, data) =>
-    Object.keys(getFieldsFromEntities(data[key]))
+/**
+ * Add resolvers for relationship fields
+ * 
+ * @example
+ * Consider this data:
+ * 
+ *     {
+ *         posts: [
+ *              { id: 1, title: 'foo', user_id: 123 }
+ *         ],
+ *         users: [
+ *              { id: 123, name: 'John Doe' }
+ *         ]
+ *     }
+ * 
+ * There is one relationship field here, posts.user_id.
+ * The generated GraphQL schema is:
+ * 
+ *     type Post {
+ *         id: ID!
+ *         title: String
+ *         user_id: ID
+ *         User: User
+ *     }
+ *     type User {
+ *         id: ID!
+ *         name: String
+ *         Posts: [Post]
+ *     }
+ * 
+ * This method generates resolvers for Post.User and User.Posts
+ * 
+ * @param {String} key The entity key in the data map, e.g. "posts"
+ * @param {Object} data The entire data map, e.g. { posts: [], users: [] }
+ * 
+ * @return {Object} resolvers, e.g. 
+ * 
+ *     {
+ *         Post: {
+ *             User: (post) => users.find(user => user.id == post.user_id)
+ *         },
+ *     }
+ * 
+ * when called with the "posts" key, and
+ * 
+ *     {
+ *         User: {
+ *             Posts: (user) => posts.filter(post => post.user_id == user.id)
+ *         }
+ *     }
+ * 
+ * when called with the "users" key
+ */
+export default (key, data) => {
+    const manyToOneResolvers = Object.keys(getFieldsFromEntities(data[key]))
         .filter(isRelationshipField)
         .reduce(
             (resolvers, fieldName) => ({
@@ -15,3 +73,24 @@ export default (key, data) =>
             }),
             {},
         );
+    const relatedField = getReverseRelatedField(key); // 'posts' => 'post_id'
+    const hasReverseRelationship = entityName =>
+        getFieldsFromEntities(data[entityName]).hasOwnProperty(relatedField);
+    const oneToManyResolvers = Object.keys(data)
+        .filter(hasReverseRelationship)
+        .reduce(
+            (resolvers, entityName) => ({
+                ...resolvers,
+                [getRelationshipFromKey(entityName)]: entity =>
+                    data[entityName].filter(
+                        record => record[relatedField] == entity.id,
+                    ),
+            }),
+            {},
+        );
+
+    return {
+        ...manyToOneResolvers,
+        ...oneToManyResolvers,
+    };
+};