Merge branch 'issue-15-input-types' into dev

Author: TimMikeladze

packages/graphql-model-directive/src/ModelDirective.ts

@@ -2,15 +2,14 @@ import {
   defaultFieldResolver,
   GraphQLBoolean,
   GraphQLID,
-  GraphQLInputObjectType,
   GraphQLList,
   GraphQLObjectType,
 } from 'graphql';
 import { SchemaDirectiveVisitor } from 'graphql-tools';
 import * as pluralize from 'pluralize';
 import {
+  addInputTypesForObjectType,
   generateFieldNames,
-  omitResolvers,
   Store,
 } from './';
 
@@ -70,14 +69,10 @@ export class ModelDirective extends SchemaDirectiveVisitor {
   }
 
   private addInputTypes(type: GraphQLObjectType) {
-    const names = generateFieldNames(type.name);
-
-    // Create an input type with identical fields as the current type.
-    // Since input type fields can't have resolvers we omit them.
-    this.schema.getTypeMap()[names.input.type] = new GraphQLInputObjectType({
-      name: names.input.type,
-      fields: () => omitResolvers(type.getFields()),
-    });
+    // Generate corresponding input types for the given type.
+    // Each field returning GraphQLObjectType in the given type will also
+    // have input types generated recursively.
+    addInputTypesForObjectType(type, this.schema);
   }
 
   private addMutations(type: GraphQLObjectType) {

packages/graphql-model-directive/src/addInputTypesForObjectType.ts

@@ -0,0 +1,84 @@
+import {
+  GraphQLInputObjectType,
+  GraphQLObjectType,
+  GraphQLSchema,
+} from 'graphql';
+import {
+  omitResolvers,
+} from './';
+
+export const toInputObjectName = (name: string): string => `${name}InputType`;
+
+export const isObjectType = (object, schema: GraphQLSchema): boolean => {
+  const type = schema.getType(object.type);
+  return type instanceof GraphQLObjectType;
+};
+
+export const getInputType = (object: any, schema: GraphQLSchema): GraphQLInputObjectType => {
+  const type = schema.getType(toInputObjectName(object.type.name));
+  return type as GraphQLInputObjectType;
+};
+
+export const addInputTypesForObjectType = (objectType: GraphQLObjectType, schema: GraphQLSchema) => {
+  // Fields of an input type cannot have resolvers
+  const fields = omitResolvers(objectType.getFields());
+
+  // Create the corresponding input type.
+  // For example, if given `type Foo` will create `input FooInputType`
+  let inputObjectType = new GraphQLInputObjectType({
+    name: toInputObjectName(objectType.name),
+    fields,
+  });
+
+  // Adds the newly created input type to the type map.
+  //
+  // Note: the GraphQLObjectType fields of the input type have not yet been replaced.
+  // However weneed a reference to the input type added to the type map for lookups during recursion.
+  schema.getTypeMap()[inputObjectType.name] = inputObjectType;
+
+  // Iterate over each field in the input type.
+  // If the field's type is not a GraphQLObjectType then it is copied as is.
+  // If the field's type is a GraphQLObjectType
+  //  Find (or create if not found) the corresponding input type
+  //  Replace the field's type with the input type
+  const inputObjectFields = Object
+    .keys(fields)
+    .reduce((res, key) => {
+      let field = fields[key];
+
+      if (isObjectType(field, schema)) {
+        // Check if the input type already exists
+        const inputType = getInputType(field, schema);
+        if (inputType) {
+          field = {
+            name: inputType.name,
+            type: inputType,
+          };
+        } else {
+          // Input type does not exist so we need to create it
+          const fieldType = schema.getType(field.type.name) as GraphQLObjectType;
+          const newInputType = addInputTypesForObjectType(fieldType, schema);
+          field = {
+            name: newInputType.name,
+            type: newInputType,
+          };
+        }
+      }
+
+      return {
+        ...res,
+        [key]: field,
+      };
+    }, {});
+
+  // Replace our original inputObjectType with new one containing the modified fields
+
+  inputObjectType = new GraphQLInputObjectType({
+    name: inputObjectType.name,
+    fields: inputObjectFields,
+  });
+
+  schema.getTypeMap()[inputObjectType.name] = inputObjectType;
+
+  return inputObjectType;
+};

packages/graphql-model-directive/src/index.ts

@@ -5,6 +5,7 @@ export * from './UniqueDirective';
 export * from './Store';
 export * from './generateFieldNames';
 export * from './omitResolvers';
+export * from './addInputTypesForObjectType';
 
 import { DefaultDirective } from './DefaultDirective';
 import { ModelDirective } from './ModelDirective';

packages/graphql-model-directive/test/ModelDirective.test.ts

@@ -21,6 +21,20 @@ describe('ModelDirective', () => {
   const typeDefs = `
   type Foo @model {
     name: String
+    relation: Foo
+    child: Bar
+  }
+
+  type Bar {
+    name: String
+    relation: Foo
+    child: Dummy
+    relation: Dummy
+  }
+
+  type Dummy {
+    name: String
+    relation: Bar
   }
   ${baseTypeDefs}
 `;

packages/graphql-model-directive/test/__snapshots__/ModelDirective.test.ts.snap

@@ -1,15 +1,41 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`ModelDirective produces the expected schema 1`] = `
-"type Foo {
+"type Bar {
   name: String
+  relation: Dummy
+  child: Dummy
+}
+
+input BarInputType {
+  name: String
+  relation: DummyInputType
+  child: DummyInputType
+}
+
+type Dummy {
+  name: String
+  relation: Bar
+}
+
+input DummyInputType {
+  name: String
+  relation: BarInputType
+}
+
+type Foo {
+  name: String
+  relation: Foo
+  child: Bar
 
   \\"\\"\\"Unique ID\\"\\"\\"
   id: ID
 }
 
 input FooInputType {
   name: String
+  relation: FooInputType
+  child: BarInputType
 
   \\"\\"\\"Unique ID\\"\\"\\"
   id: ID