Fix Tests

Author: fzaninotto

src/introspection/getSchemaFromData.js

@@ -171,19 +171,20 @@ export default data => {
      *     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');
+    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 += `
+extend type ${type} { ${relType}: ${relType} }
+extend type ${relType} { ${rel}: [${type}] }`;
+            });
+        return ext;
+    }, '');
 
-    return extendSchema(schema, parse(schemaExtension));
+    return schemaExtension
+        ? extendSchema(schema, parse(schemaExtension))
+        : schema;
 };

src/introspection/getSchemaFromData.spec.js

@@ -2,6 +2,7 @@ import {
     GraphQLBoolean,
     GraphQLID,
     GraphQLInt,
+    GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
     GraphQLString,
@@ -37,21 +38,22 @@ const data = {
 
 const UserType = new GraphQLObjectType({
     name: 'User',
-    fields: {
+    fields: () => ({
         id: { type: new GraphQLNonNull(GraphQLID) },
         name: { type: new GraphQLNonNull(GraphQLString) },
-    },
+        Posts: { type: new GraphQLList(PostType) },
+    }),
 });
 
 const PostType = new GraphQLObjectType({
     name: 'Post',
-    fields: {
+    fields: () => ({
         id: { type: new GraphQLNonNull(GraphQLID) },
         title: { type: new GraphQLNonNull(GraphQLString) },
         views: { type: new GraphQLNonNull(GraphQLInt) },
         user_id: { type: new GraphQLNonNull(GraphQLID) },
         User: { type: UserType },
-    },
+    }),
 });
 
 /*
@@ -312,7 +314,7 @@ test('creates three mutation fields per data type', () => {
 
 test('pluralizes and capitalizes correctly', () => {
     const data = {
-        foot: [{ id: 1, size: 42 }, { id: 2, size: 39 }],
+        feet: [{ id: 1, size: 42 }, { id: 2, size: 39 }],
         categories: [{ id: 1, name: 'foo' }],
     };
     const queries = getSchemaFromData(data).getQueryType().getFields();

src/resolver/Entity/index.js

@@ -15,79 +15,68 @@ import { isRelationshipField } from '../../relationships';
  * 
  *     {
  *         posts: [
- *              { id: 1, title: 'foo', user_id: 123 }
+ *              { id: 1, title: 'Hello, world', user_id: 123 }
  *         ],
  *         users: [
  *              { id: 123, name: 'John Doe' }
  *         ]
+ *         comments: [
+ *              { id: 4646, post_id: 1, body: 'Nice post!' }
+ *         ]
  *     }
  * 
- * There is one relationship field here, posts.user_id.
- * The generated GraphQL schema is:
+ * There are two relationship fields here, posts.user_id and comments.post_id.
+ * The generated GraphQL schema for posts is:
  * 
  *     type Post {
  *         id: ID!
  *         title: String
  *         user_id: ID
  *         User: User
- *     }
- *     type User {
- *         id: ID!
- *         name: String
- *         Posts: [Post]
+ *         Comments: [Comment]
  *     }
  * 
- * This method generates resolvers for Post.User and User.Posts
+ * When called for the posts entity, this method generates resolvers 
+ * for Post.User and Post.Comments
  * 
- * @param {String} key The entity key in the data map, e.g. "posts"
+ * @param {String} entityName 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)
+ *             User: (post) => users.find(user => user.id == post.user_id),
+ *             Comments: (post) => comments.filter(comment => comment.post_id = post.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) => ({
-                ...resolvers,
-                [getRelatedType(fieldName)]: entity =>
-                    data[getRelatedKey(fieldName)].find(
-                        relatedRecord => relatedRecord.id == entity[fieldName],
-                    ),
-            }),
-            {},
-        );
-    const relatedField = getReverseRelatedField(key); // 'posts' => 'post_id'
+export default (entityName, data) => {
+    const entityFields = Object.keys(getFieldsFromEntities(data[entityName]));
+    const manyToOneResolvers = entityFields.filter(isRelationshipField).reduce(
+        (resolvers, fieldName) => ({
+            ...resolvers,
+            [getRelatedType(fieldName)]: entity =>
+                data[getRelatedKey(fieldName)].find(
+                    relatedRecord => relatedRecord.id == entity[fieldName],
+                ),
+        }),
+        {},
+    );
+    const relatedField = getReverseRelatedField(entityName); // '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,
-                    ),
-            }),
-            {},
-        );
+    const entities = Object.keys(data);
+    const oneToManyResolvers = entities.filter(hasReverseRelationship).reduce(
+        (resolvers, entityName) => ({
+            ...resolvers,
+            [getRelationshipFromKey(entityName)]: entity =>
+                data[entityName].filter(
+                    record => record[relatedField] == entity.id,
+                ),
+        }),
+        {},
+    );
 
     return {
         ...manyToOneResolvers,