Merge pull request #12 from marmelab/relationships

[RFR] Relationships

Author: Kmaschta

README.md

@@ -20,40 +20,16 @@ Your data file should be an object where the keys are the entity types. The valu
 ```json
 {
     "posts": [
-        {
-            "id": 1,
-            "title": "Lorem Ipsum",
-            "views": 254,
-            "user_id": 123,
-            "tag_id": "foo"
-        },
-        {
-            "id": 2,
-            "title": "Sic Dolor amet",
-            "views": 65,
-            "user_id": 456,
-            "tag_id": "bar"
-        },
+        { "id": 1, "title": "Lorem Ipsum", "views": 254, "user_id": 123 },
+        { "id": 2, "title": "Sic Dolor amet", "views": 65, "user_id": 456 },
     ],
     "users": [
-        {
-            "id": 123,
-            "name": "John Doe"
-        },
-        {
-            "id": 456,
-            "name": "Jane Doe"
-        }
+        { "id": 123, "name": "John Doe" },
+        { "id": 456, "name": "Jane Doe" }
     ],
-    "tags": [
-        {
-            "id": "foo",
-            "name": "Foo"
-        },
-        {
-            "id": "bar",
-            "name": "Bar"
-        }
+    "comments": [
+        { "id": 987, "post_id": 1, "body": "Consectetur adipiscing elit" },
+        { "id": 995, "post_id": 1, "body": "Nam molestie pellentesque dui" }
     ]
 }
 ```
@@ -67,16 +43,22 @@ json-graphql-server db.json
 Now you can query your data in graphql. For instance, to issue the following query:
 
 ```graphql
-query {
-    Customer(id: 1) {
+{
+    Post(id: 1) {
         id
-        first_name
-        last_name
+        title
+        views
+        User {
+            name
+        }
+        Comments {
+            body
+        }
     }
 }
 ```
 
-Go to http://localhost:3000/?query=query%20%7B%20Post(id%3A%201)%20%7Bid%20title%20views%20%7D%7D. You'll get the following result:
+Go to http://localhost:3000/?query=%7B%20Post%28id%3A%201%29%20%7B%20id%20title%20views%20User%20%7B%20name%20%7D%20Comments%20%7B%20body%20%7D%20%7D%20%7D. You'll get the following result:
 
 ```json
 {
@@ -85,12 +67,19 @@ Go to http://localhost:3000/?query=query%20%7B%20Post(id%3A%201)%20%7Bid%20title
             "id": "1",
             "title": "Lorem Ipsum",
             "views": 254,
+            "User": {
+                "name": "John Doe"
+            },
+            "Comments": [
+                { "body": "Consectetur adipiscing elit" },
+                { "body": "Nam molestie pellentesque dui" },
+            ]
         }
     }
 }
 ```
 
-The json-graphql-server accepts queries in GET and POST. Under the hood, it uses [Apollo's `graphql-server` module](http://dev.apollodata.com/tools/graphql-server/requests.html). Please refer to their documentations for details about passing variables, etc.
+The json-graphql-server accepts queries in GET and POST. Under the hood, it uses [the `express-graphql` module](https://github.com/graphql/express-graphql). Please refer to their documentations for details about passing variables, etc.
 
 Note that the server is [GraphiQL](https://github.com/skevy/graphiql-app/releases) enabled, so you can query your server using a full-featured graphical user interface, providing autosuggest, history, etc.
 
@@ -112,7 +101,8 @@ type Post {
     title: String!
     views: Int
     user_id: ID
-    tag_id: ID
+    User: User
+    Comments: [Comment]
 }
 type Query {
   Post(id: ID!): Post
@@ -173,7 +163,6 @@ Here is how you can use the queries and mutations generated for your data, using
     title
     views
     user_id
-    tag_id
   }
 }
             </pre>
@@ -186,8 +175,7 @@ Here is how you can use the queries and mutations generated for your data, using
         "id": 1,
         "title": "Lorem Ipsum",
         "views": 254,
-        "user_id": 123,
-        "tag_id": "foo"
+        "user_id": 123
     } 
   }
 }
@@ -246,7 +234,7 @@ Deploy with Heroku or Next.js.
 
 ## Roadmap
 
-* Handle relationships
+* Filtering in the `all*` queries
 * Client-side mocking (à la [FakeRest](https://github.com/marmelab/FakeRest))
 * CLI options (port, https, watch, delay, custom schema)
 
@@ -265,6 +253,3 @@ make format
 ## License
 
 Admin-on-rest is licensed under the [MIT Licence](https://github.com/marmelab/json-graphql-server/blob/master/LICENSE.md), sponsored and supported by [marmelab](http://marmelab.com).
-
-
-

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
@@ -109,8 +113,6 @@ export default data => {
                 args: {
                     page: { type: GraphQLInt },
                     perPage: { type: GraphQLInt },
-                    sortField: { type: GraphQLString },
-                    sortOrder: { type: GraphQLString },
                     filter: { type: GraphQLString },
                 },
             };
@@ -153,5 +155,34 @@ export default data => {
         }, {}),
     });
 
-    return new GraphQLSchema({ query: queryType, mutation: mutationType });
+    const schema = new GraphQLSchema({
+        query: queryType,
+        mutation: mutationType,
+    });
+
+    /**
+     * 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 += `
+extend type ${type} { ${relType}: ${relType} }
+extend type ${relType} { ${rel}: [${type}] }`;
+            });
+        return ext;
+    }, '');
+
+    return schemaExtension
+        ? extendSchema(schema, parse(schemaExtension))
+        : schema;
 };

src/introspection/getSchemaFromData.spec.js

@@ -38,29 +38,33 @@ const data = {
 
 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 },
+    }),
 });
+
 const UserType = new GraphQLObjectType({
     name: 'User',
-    fields: {
+    fields: () => ({
         id: { type: new GraphQLNonNull(GraphQLID) },
         name: { type: new GraphQLNonNull(GraphQLString) },
-    },
+        Posts: { type: new GraphQLList(PostType) },
+    }),
 });
 
+/*
 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 +101,28 @@ 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 one field per relationship', () => {
+    const typeMap = getSchemaFromData(data).getTypeMap();
+    expect(Object.keys(typeMap['Post'].getFields())).toContain('User');
+});
+
+test('creates one field per reverse relationship', () => {
+    const typeMap = getSchemaFromData(data).getTypeMap();
+    expect(Object.keys(typeMap['User'].getFields())).toContain('Posts');
 });
 
 test('creates three query fields per data type', () => {
@@ -117,7 +136,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 +169,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 +180,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 +213,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', () => {
@@ -305,7 +324,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/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
@@ -62,4 +63,4 @@ export default data =>
         .map(typeObject => new GraphQLObjectType(typeObject));
 
 export const getTypeNamesFromData = data =>
-    Object.keys(data).map(typeName => camelize(singularize(typeName)));
+    Object.keys(data).map(getTypeFromKey);

src/nameConverter.js

@@ -0,0 +1,59 @@
+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} 'Users'
+ */
+export const getRelationshipFromKey = key => camelize(key);
+
+/**
+ * 
+ * @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} key 'users'
+ * @return {String} 'user_id'
+ */
+export const getReverseRelatedField = key => `${singularize(key)}_id`;
+
+/**
+ * 
+ * @param {String} fieldName 'user_id'
+ * @return {String} 'User'
+ */
+export const getRelatedType = fieldName =>
+    getTypeFromKey(fieldName.substr(0, fieldName.length - 3));