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

Author: TimMikeladze

examples/simple/src/index.ts

@@ -11,6 +11,11 @@ const PORT = 3000;
 const typeDefs = `
   type Item @model {
     name: String
+    subItem: SubItem
+  }
+
+  type SubItem {
+    name: String
   }
 
   type Query {
@@ -43,5 +48,3 @@ app.use('/graphql', bodyParser.json(), graphqlExpress({ schema, context }));
 app.get('/graphiql', graphiqlExpress({ endpointURL: '/graphql' }));
 
 app.listen(PORT);
-
-console.log(printSchema(schema));

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,90 @@
+import {
+  getNamedType,
+  GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLObjectType,
+  GraphQLSchema,
+} from 'graphql';
+import {
+  omitResolvers,
+} from './';
+
+export const toInputObjectName = (name: string): string => `${name}InputType`;
+
+export const isValidInputType = (type, schema: GraphQLSchema): boolean => {
+  if (type instanceof GraphQLList) {
+    return isValidInputType(getNamedType(type), schema);
+  }
+  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
+  // console.log(objectType);
+  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 or a GraphQLList then it is copied as is.
+  // If the field's type is a GraphQLObjectType or a GraphQLList
+  //  Get the type which the GraphQLList contains
+  //  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 (!isValidInputType(field.type, schema)) {
+        // Check if the input type already exists
+        const inputType = getInputType(field, schema);
+        if (inputType) {
+          field = {
+            name: inputType.name,
+            type: field.type instanceof GraphQLList ? new GraphQLList(inputType) : inputType,
+          };
+        } else {
+          // Input type does not exist so we need to create it
+          const fieldType = schema.getType(field.type.ofType || field.type.name); // `field.type.ofType` is used in case of a list type
+          const newInputType = addInputTypesForObjectType(fieldType as GraphQLObjectType, schema);
+          field = {
+            name: newInputType.name,
+            type: field.type instanceof GraphQLList ? new GraphQLList(newInputType) : 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,19 @@ describe('ModelDirective', () => {
   const typeDefs = `
   type Foo @model {
     name: String
+    children: Foo
+    parent: Bar
+  }
+
+  type Bar {
+    names: [String]
+    children: [Dummy]
+    parent: Foo
+  }
+
+  type Dummy {
+    names: [String]
+    parent: 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 {
+  names: [String]
+  children: [Dummy]
+  parent: Foo
+}
+
+input BarInputType {
+  names: [String]
+  children: [DummyInputType]
+  parent: FooInputType
+}
+
+type Dummy {
+  names: [String]
+  parent: Bar
+}
+
+input DummyInputType {
+  names: [String]
+  parent: BarInputType
+}
+
+type Foo {
   name: String
+  children: Foo
+  parent: Bar
 
   \\"\\"\\"Unique ID\\"\\"\\"
   id: ID
 }
 
 input FooInputType {
   name: String
+  children: FooInputType
+  parent: BarInputType
 
   \\"\\"\\"Unique ID\\"\\"\\"
   id: ID