relay-compiler 1.3.0 → 1.5.0

package/lib/RelayFlowGenerator.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule RelayFlowGenerator
  * 
@@ -19,40 +17,40 @@ var _toConsumableArray3 = _interopRequireDefault(require('babel-runtime/helpers/
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
-var babelGenerator = require('babel-generator')['default'];
-
-var _require = require('graphql'),
-    GraphQLEnumType = _require.GraphQLEnumType,
-    GraphQLInputType = _require.GraphQLInputType,
-    GraphQLInputObjectType = _require.GraphQLInputObjectType,
-    GraphQLInterfaceType = _require.GraphQLInterfaceType,
-    GraphQLList = _require.GraphQLList,
-    GraphQLNonNull = _require.GraphQLNonNull,
-    GraphQLObjectType = _require.GraphQLObjectType,
-    GraphQLScalarType = _require.GraphQLScalarType,
-    GraphQLType = _require.GraphQLType,
-    GraphQLUnionType = _require.GraphQLUnionType;
-
-var _require2 = require('./GraphQLSchemaUtils'),
-    isAbstractType = _require2.isAbstractType;
-
-var printBabel = function printBabel(ast) {
-  return babelGenerator(ast).code;
-};
-
-function generate(node, customScalars, inputFieldWhiteList) {
-  var defaultedCustomScalars = customScalars || {};
-  var output = [];
-  if (node.kind === 'Root' && node.operation !== 'query') {
-    var inputAST = generateInputVariablesType(node, defaultedCustomScalars, inputFieldWhiteList);
-    output.push(printBabel(inputAST));
-  }
-  var responseAST = require('./RelayIRVisitor').visit(node, createVisitor(defaultedCustomScalars));
-  output.push(printBabel(responseAST));
-  return output.join('\n\n');
+var _require = require('./RelayFlowBabelFactories'),
+    anyTypeAlias = _require.anyTypeAlias,
+    exactObjectTypeAnnotation = _require.exactObjectTypeAnnotation,
+    exportType = _require.exportType,
+    importTypes = _require.importTypes,
+    intersectionTypeAnnotation = _require.intersectionTypeAnnotation,
+    lineComments = _require.lineComments,
+    readOnlyArrayOfType = _require.readOnlyArrayOfType,
+    readOnlyObjectTypeProperty = _require.readOnlyObjectTypeProperty,
+    stringLiteralTypeAnnotation = _require.stringLiteralTypeAnnotation,
+    unionTypeAnnotation = _require.unionTypeAnnotation;
+
+var _require2 = require('./RelayFlowTypeTransformers'),
+    transformScalarType = _require2.transformScalarType,
+    transformInputType = _require2.transformInputType;
+
+var _require3 = require('graphql'),
+    GraphQLNonNull = _require3.GraphQLNonNull;
+
+var _require4 = require('./GraphQLCompilerPublic'),
+    FlattenTransform = _require4.FlattenTransform,
+    IRVisitor = _require4.IRVisitor,
+    Profiler = _require4.Profiler,
+    SchemaUtils = _require4.SchemaUtils;
+
+var isAbstractType = SchemaUtils.isAbstractType;
+
+
+function generate(node, options) {
+  var ast = IRVisitor.visit(node, createVisitor(options));
+  return require('./PatchedBabelGenerator').generate(ast);
 }
 
-function makeProp(_ref, customScalars, concreteType) {
+function makeProp(_ref, state, concreteType) {
   var key = _ref.key,
       schemaName = _ref.schemaName,
       value = _ref.value,
@@ -61,7 +59,7 @@ function makeProp(_ref, customScalars, concreteType) {
       nodeSelections = _ref.nodeSelections;
 
   if (nodeType) {
-    value = transformScalarField(nodeType, customScalars, selectionsToBabel([Array.from(nodeSelections.values())], customScalars));
+    value = transformScalarType(nodeType, state, selectionsToBabel([Array.from(require('fbjs/lib/nullthrows')(nodeSelections).values())], state));
   }
   if (schemaName === '__typename' && concreteType) {
     value = stringLiteralTypeAnnotation(concreteType);
@@ -83,7 +81,7 @@ var onlySelectsTypename = function onlySelectsTypename(selections) {
   return selections.every(isTypenameSelection);
 };
 
-function selectionsToBabel(selections, customScalars) {
+function selectionsToBabel(selections, state, refTypeName) {
   var baseFields = new Map();
   var byConcreteType = {};
 
@@ -105,59 +103,42 @@ function selectionsToBabel(selections, customScalars) {
   if (Object.keys(byConcreteType).length && onlySelectsTypename(Array.from(baseFields.values())) && (hasTypenameSelection(Array.from(baseFields.values())) || Object.keys(byConcreteType).every(function (type) {
     return hasTypenameSelection(byConcreteType[type]);
   }))) {
-    var _loop = function _loop(concreteType) {
-      types.push(exactObjectTypeAnnotation([].concat((0, _toConsumableArray3['default'])(Array.from(baseFields.values()).map(function (selection) {
-        return makeProp(selection, customScalars, concreteType);
-      })), (0, _toConsumableArray3['default'])(byConcreteType[concreteType].map(function (selection) {
-        return makeProp(selection, customScalars, concreteType);
-      })))));
+    var _loop = function _loop(_concreteType) {
+      types.push(groupRefs([].concat((0, _toConsumableArray3['default'])(Array.from(baseFields.values())), (0, _toConsumableArray3['default'])(byConcreteType[_concreteType]))).map(function (selection) {
+        return makeProp(selection, state, _concreteType);
+      }));
     };
 
-    for (var concreteType in byConcreteType) {
-      _loop(concreteType);
+    for (var _concreteType in byConcreteType) {
+      _loop(_concreteType);
     }
     // It might be some other type then the listed concrete types. Ideally, we
     // would set the type to diff(string, set of listed concrete types), but
     // this doesn't exist in Flow at the time.
     var otherProp = readOnlyObjectTypeProperty('__typename', stringLiteralTypeAnnotation('%other'));
     otherProp.leadingComments = lineComments("This will never be '%other', but we need some", 'value in case none of the concrete values match.');
-    types.push(exactObjectTypeAnnotation([otherProp]));
+    types.push([otherProp]);
   } else {
     var selectionMap = selectionsToMap(Array.from(baseFields.values()));
-    for (var concreteType in byConcreteType) {
-      selectionMap = mergeSelections(selectionMap, selectionsToMap(byConcreteType[concreteType].map(function (sel) {
+    for (var _concreteType2 in byConcreteType) {
+      selectionMap = mergeSelections(selectionMap, selectionsToMap(byConcreteType[_concreteType2].map(function (sel) {
         return (0, _extends3['default'])({}, sel, {
           conditional: true
         });
       })));
     }
-    var selectionMapValues = Array.from(selectionMap.values()).map(function (sel) {
-      return isTypenameSelection(sel) && sel.concreteType ? makeProp((0, _extends3['default'])({}, sel, { conditional: false }), customScalars, sel.concreteType) : makeProp(sel, customScalars);
+    var selectionMapValues = groupRefs(Array.from(selectionMap.values())).map(function (sel) {
+      return isTypenameSelection(sel) && sel.concreteType ? makeProp((0, _extends3['default'])({}, sel, { conditional: false }), state, sel.concreteType) : makeProp(sel, state);
     });
-    types.push(exactObjectTypeAnnotation(selectionMapValues));
-  }
-
-  if (!types.length) {
-    return exactObjectTypeAnnotation([]);
-  }
-
-  return types.length > 1 ? require('babel-types').unionTypeAnnotation(types) : types[0];
-}
-
-function lineComments() {
-  for (var _len = arguments.length, lines = Array(_len), _key = 0; _key < _len; _key++) {
-    lines[_key] = arguments[_key];
+    types.push(selectionMapValues);
   }
 
-  return lines.map(function (line) {
-    return { type: 'CommentLine', value: ' ' + line };
-  });
-}
-
-function stringLiteralTypeAnnotation(value) {
-  var annotation = require('babel-types').stringLiteralTypeAnnotation();
-  annotation.value = value;
-  return annotation;
+  return unionTypeAnnotation(types.map(function (props) {
+    if (refTypeName) {
+      props.push(readOnlyObjectTypeProperty('$refType', require('babel-types').identifier(refTypeName)));
+    }
+    return exactObjectTypeAnnotation(props);
+  }));
 }
 
 function mergeSelection(a, b) {
@@ -167,7 +148,7 @@ function mergeSelection(a, b) {
     });
   }
   return (0, _extends3['default'])({}, a, {
-    nodeSelections: a.nodeSelections ? mergeSelections(a.nodeSelections, b.nodeSelections) : null,
+    nodeSelections: a.nodeSelections ? mergeSelections(a.nodeSelections, require('fbjs/lib/nullthrows')(b.nodeSelections)) : null,
     conditional: a.conditional && b.conditional
   });
 }
@@ -181,10 +162,10 @@ function mergeSelections(a, b) {
   try {
     for (var _iterator = a.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
       var _step$value = _step.value,
-          key = _step$value[0],
-          value = _step$value[1];
+          _key = _step$value[0],
+          _value = _step$value[1];
 
-      merged.set(key, value);
+      merged.set(_key, _value);
     }
   } catch (err) {
     _didIteratorError = true;
@@ -208,10 +189,10 @@ function mergeSelections(a, b) {
   try {
     for (var _iterator2 = b.entries()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
       var _step2$value = _step2.value,
-          key = _step2$value[0],
-          value = _step2$value[1];
+          _key2 = _step2$value[0],
+          _value2 = _step2$value[1];
 
-      merged.set(key, mergeSelection(a.get(key), value));
+      merged.set(_key2, mergeSelection(a.get(_key2), _value2));
     }
   } catch (err) {
     _didIteratorError2 = true;
@@ -231,30 +212,29 @@ function mergeSelections(a, b) {
   return merged;
 }
 
-function isPlural(_ref2) {
-  var directives = _ref2.directives;
-
-  var relayDirective = directives.find(function (_ref3) {
-    var name = _ref3.name;
-    return name === 'relay';
-  });
-
-  if (relayDirective) {
-    return !!relayDirective.args.find(function (_ref4) {
-      var name = _ref4.name,
-          value = _ref4.value;
-      return name === 'plural' && value.value;
-    });
-  } else {
-    return false;
-  }
+function isPlural(node) {
+  return Boolean(node.metadata && node.metadata.plural);
 }
 
-function createVisitor(customScalars) {
+function createVisitor(options) {
+  var state = {
+    customScalars: options.customScalars,
+    enumsHasteModule: options.enumsHasteModule,
+    existingFragmentNames: options.existingFragmentNames,
+    generatedFragments: new Set(),
+    inputFieldWhiteList: options.inputFieldWhiteList,
+    relayRuntimeModule: options.relayRuntimeModule,
+    usedEnums: {},
+    usedFragments: new Set(),
+    useHaste: options.useHaste
+  };
+
   return {
     leave: {
       Root: function Root(node) {
-        return require('babel-types').exportNamedDeclaration(require('babel-types').typeAlias(require('babel-types').identifier(node.name + 'Response'), null, selectionsToBabel(node.selections, customScalars)), [], null);
+        var inputVariablesType = generateInputVariablesType(node, state);
+        var responseType = exportType(node.name + 'Response', selectionsToBabel(node.selections, state));
+        return require('babel-types').program([].concat((0, _toConsumableArray3['default'])(getFragmentImports(state)), (0, _toConsumableArray3['default'])(getEnumDefinitions(state)), [inputVariablesType, responseType]));
       },
       Fragment: function Fragment(node) {
         var selections = flattenArray(node.selections);
@@ -269,10 +249,12 @@ function createVisitor(customScalars) {
           }
           return [selection];
         });
-        var baseType = selectionsToBabel(selections, customScalars);
-        var type = isPlural(node) ? arrayOfType(baseType) : baseType;
-
-        return require('babel-types').exportNamedDeclaration(require('babel-types').typeAlias(require('babel-types').identifier(node.name), null, type), [], null);
+        state.generatedFragments.add(node.name);
+        var refTypeName = getRefTypeName(node.name);
+        var refType = require('babel-types').expressionStatement(require('babel-types').identifier('declare export opaque type ' + refTypeName + ': FragmentReference'));
+        var baseType = selectionsToBabel(selections, state, refTypeName);
+        var type = isPlural(node) ? readOnlyArrayOfType(baseType) : baseType;
+        return require('babel-types').program([].concat((0, _toConsumableArray3['default'])(getFragmentImports(state)), (0, _toConsumableArray3['default'])(getEnumDefinitions(state)), [importTypes(['FragmentReference'], state.relayRuntimeModule), refType, exportType(node.name, type)]));
       },
       InlineFragment: function InlineFragment(node) {
         var typeCondition = node.typeCondition;
@@ -295,7 +277,7 @@ function createVisitor(customScalars) {
         return [{
           key: node.alias || node.name,
           schemaName: node.name,
-          value: transformScalarField(node.type, customScalars)
+          value: transformScalarType(node.type, state)
         }];
       },
       LinkedField: function LinkedField(node) {
@@ -307,7 +289,11 @@ function createVisitor(customScalars) {
         }];
       },
       FragmentSpread: function FragmentSpread(node) {
-        return [];
+        state.usedFragments.add(node.name);
+        return [{
+          key: '__fragments_' + node.name,
+          ref: node.name
+        }];
       }
     }
   };
@@ -330,117 +316,111 @@ function flattenArray(arrayOfArrays) {
   return result;
 }
 
-function transformScalarField(type, customScalars, objectProps) {
-  if (type instanceof GraphQLNonNull) {
-    return transformNonNullableScalarField(type.ofType, objectProps, customScalars);
-  } else {
-    return require('babel-types').nullableTypeAnnotation(transformNonNullableScalarField(type, objectProps, customScalars));
-  }
-}
-
-function arrayOfType(thing) {
-  return require('babel-types').genericTypeAnnotation(require('babel-types').identifier('$ReadOnlyArray'), require('babel-types').typeParameterInstantiation([thing]));
-}
-
-function exactObjectTypeAnnotation(props) {
-  var typeAnnotation = require('babel-types').objectTypeAnnotation(props);
-  typeAnnotation.exact = true;
-  return typeAnnotation;
-}
-
-function readOnlyObjectTypeProperty(key, value) {
-  var prop = require('babel-types').objectTypeProperty(require('babel-types').identifier(key), value);
-  prop.variance = 'plus';
-  return prop;
+function generateInputVariablesType(node, state) {
+  return exportType(node.name + 'Variables', exactObjectTypeAnnotation(node.argumentDefinitions.map(function (arg) {
+    var property = require('babel-types').objectTypeProperty(require('babel-types').identifier(arg.name), transformInputType(arg.type, state));
+    if (!(arg.type instanceof GraphQLNonNull)) {
+      property.optional = true;
+    }
+    return property;
+  })));
 }
 
-function transformGraphQLScalarType(type, customScalars) {
-  switch (customScalars[type.name] || type.name) {
-    case 'ID':
-    case 'String':
-    case 'Url':
-      return require('babel-types').stringTypeAnnotation();
-    case 'Float':
-    case 'Int':
-      return require('babel-types').numberTypeAnnotation();
-    case 'Boolean':
-      return require('babel-types').booleanTypeAnnotation();
-    default:
-      return require('babel-types').anyTypeAnnotation();
+function groupRefs(props) {
+  var result = [];
+  var refs = [];
+  props.forEach(function (prop) {
+    if (prop.ref) {
+      refs.push(prop.ref);
+    } else {
+      result.push(prop);
+    }
+  });
+  if (refs.length > 0) {
+    var _value3 = intersectionTypeAnnotation(refs.map(function (ref) {
+      return require('babel-types').identifier(getRefTypeName(ref));
+    }));
+    result.push({
+      key: '$fragmentRefs',
+      conditional: false,
+      value: _value3
+    });
   }
+  return result;
 }
 
-function transformGraphQLEnumType(type) {
-  // TODO create a flow type for enums
-  return require('babel-types').unionTypeAnnotation(type.getValues().map(function (_ref5) {
-    var value = _ref5.value;
-    return stringLiteralTypeAnnotation(value);
-  }));
-}
-
-function transformNonNullableScalarField(type, objectProps, customScalars) {
-  if (type instanceof GraphQLList) {
-    return arrayOfType(transformScalarField(type.ofType, customScalars, objectProps));
-  } else if (type instanceof GraphQLObjectType || type instanceof GraphQLUnionType || type instanceof GraphQLInterfaceType) {
-    return objectProps;
-  } else if (type instanceof GraphQLScalarType) {
-    return transformGraphQLScalarType(type, customScalars);
-  } else if (type instanceof GraphQLEnumType) {
-    return transformGraphQLEnumType(type);
-  } else {
-    throw new Error('Could not convert from GraphQL type ' + type.toString());
-  }
-}
+function getFragmentImports(state) {
+  var imports = [];
+  if (state.usedFragments.size > 0) {
+    var _usedFragments = Array.from(state.usedFragments).sort();
+    var _iteratorNormalCompletion3 = true;
+    var _didIteratorError3 = false;
+    var _iteratorError3 = undefined;
 
-function transformNonNullableInputType(type, customScalars, inputFieldWhiteList) {
-  if (type instanceof GraphQLList) {
-    return arrayOfType(transformInputType(type.ofType, customScalars, inputFieldWhiteList));
-  } else if (type instanceof GraphQLScalarType) {
-    return transformGraphQLScalarType(type, customScalars);
-  } else if (type instanceof GraphQLEnumType) {
-    return transformGraphQLEnumType(type);
-  } else if (type instanceof GraphQLInputObjectType) {
-    var fields = type.getFields();
-    var props = Object.keys(fields).map(function (key) {
-      return fields[key];
-    }).filter(function (field) {
-      return !inputFieldWhiteList || inputFieldWhiteList.indexOf(field.name) < 0;
-    }).map(function (field) {
-      var property = require('babel-types').objectTypeProperty(require('babel-types').identifier(field.name), transformInputType(field.type, customScalars, inputFieldWhiteList));
-      if (!(field.type instanceof GraphQLNonNull)) {
-        property.optional = true;
+    try {
+      for (var _iterator3 = _usedFragments[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+        var usedFragment = _step3.value;
+
+        var refTypeName = getRefTypeName(usedFragment);
+        if (!state.generatedFragments.has(usedFragment)) {
+          if (state.useHaste && state.existingFragmentNames.has(usedFragment)) {
+            // TODO(T22653277) support non-haste environments when importing
+            // fragments
+            imports.push(importTypes([refTypeName], usedFragment + '.graphql'));
+          } else {
+            imports.push(anyTypeAlias(refTypeName));
+          }
+        }
       }
-      return property;
-    });
-    return require('babel-types').objectTypeAnnotation(props);
-  } else {
-    throw new Error('Could not convert from GraphQL type ' + type.toString());
+    } catch (err) {
+      _didIteratorError3 = true;
+      _iteratorError3 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion3 && _iterator3['return']) {
+          _iterator3['return']();
+        }
+      } finally {
+        if (_didIteratorError3) {
+          throw _iteratorError3;
+        }
+      }
+    }
   }
+  return imports;
 }
 
-function transformInputType(type, customScalars, inputFieldWhiteList) {
-  if (type instanceof GraphQLNonNull) {
-    return transformNonNullableInputType(type.ofType, customScalars, inputFieldWhiteList);
-  } else {
-    return require('babel-types').nullableTypeAnnotation(transformNonNullableInputType(type, customScalars, inputFieldWhiteList));
+function getEnumDefinitions(_ref2) {
+  var enumsHasteModule = _ref2.enumsHasteModule,
+      usedEnums = _ref2.usedEnums;
+
+  var enumNames = Object.keys(usedEnums).sort();
+  if (enumNames.length === 0) {
+    return [];
+  }
+  if (enumsHasteModule) {
+    return [importTypes(enumNames, enumsHasteModule)];
   }
+  return enumNames.map(function (name) {
+    var values = usedEnums[name].getValues().map(function (_ref3) {
+      var value = _ref3.value;
+      return value;
+    });
+    values.sort();
+    values.push('%future added value');
+    return exportType(name, require('babel-types').unionTypeAnnotation(values.map(function (value) {
+      return stringLiteralTypeAnnotation(value);
+    })));
+  });
 }
 
-function generateInputVariablesType(node, customScalars, inputFieldWhiteList) {
-  return require('babel-types').exportNamedDeclaration(require('babel-types').typeAlias(require('babel-types').identifier(node.name + 'Variables'), null, exactObjectTypeAnnotation(node.argumentDefinitions.map(function (arg) {
-    var property = require('babel-types').objectTypeProperty(require('babel-types').identifier(arg.name), transformInputType(arg.type, customScalars, inputFieldWhiteList));
-    if (!(arg.type instanceof GraphQLNonNull)) {
-      property.optional = true;
-    }
-    return property;
-  }))), [], null);
+function getRefTypeName(name) {
+  return name + '$ref';
 }
 
-var FLOW_TRANSFORMS = [function (ctx) {
-  return require('./RelayFlattenTransform').transform(ctx, {});
-}];
+var FLOW_TRANSFORMS = [require('./RelayRelayDirectiveTransform').transform, require('./RelayMaskTransform').transform, FlattenTransform.transformWithOptions({})];
 
 module.exports = {
-  generate: generate,
+  generate: Profiler.instrument(generate, 'RelayFlowGenerator.generate'),
   flowTransforms: FLOW_TRANSFORMS
 };

package/lib/RelayFlowTypeTransformers.js

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule RelayFlowTypeTransformers
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _require = require('./RelayFlowBabelFactories'),
+    readOnlyArrayOfType = _require.readOnlyArrayOfType;
+
+var _require2 = require('graphql'),
+    GraphQLEnumType = _require2.GraphQLEnumType,
+    GraphQLInputType = _require2.GraphQLInputType,
+    GraphQLInputObjectType = _require2.GraphQLInputObjectType,
+    GraphQLInterfaceType = _require2.GraphQLInterfaceType,
+    GraphQLList = _require2.GraphQLList,
+    GraphQLNonNull = _require2.GraphQLNonNull,
+    GraphQLObjectType = _require2.GraphQLObjectType,
+    GraphQLScalarType = _require2.GraphQLScalarType,
+    GraphQLType = _require2.GraphQLType,
+    GraphQLUnionType = _require2.GraphQLUnionType;
+
+function transformScalarType(type, state, objectProps) {
+  if (type instanceof GraphQLNonNull) {
+    return transformNonNullableScalarType(type.ofType, state, objectProps);
+  } else {
+    return require('babel-types').nullableTypeAnnotation(transformNonNullableScalarType(type, state, objectProps));
+  }
+}
+
+function transformNonNullableScalarType(type, state, objectProps) {
+  if (type instanceof GraphQLList) {
+    return readOnlyArrayOfType(transformScalarType(type.ofType, state, objectProps));
+  } else if (type instanceof GraphQLObjectType || type instanceof GraphQLUnionType || type instanceof GraphQLInterfaceType) {
+    return objectProps;
+  } else if (type instanceof GraphQLScalarType) {
+    return transformGraphQLScalarType(type, state);
+  } else if (type instanceof GraphQLEnumType) {
+    return transformGraphQLEnumType(type, state);
+  } else {
+    throw new Error('Could not convert from GraphQL type ' + type.toString());
+  }
+}
+
+function transformGraphQLScalarType(type, state) {
+  switch (state.customScalars[type.name] || type.name) {
+    case 'ID':
+    case 'String':
+    case 'Url':
+      return require('babel-types').stringTypeAnnotation();
+    case 'Float':
+    case 'Int':
+      return require('babel-types').numberTypeAnnotation();
+    case 'Boolean':
+      return require('babel-types').booleanTypeAnnotation();
+    default:
+      return require('babel-types').anyTypeAnnotation();
+  }
+}
+
+function transformGraphQLEnumType(type, state) {
+  state.usedEnums[type.name] = type;
+  return require('babel-types').genericTypeAnnotation(require('babel-types').identifier(type.name));
+}
+
+function transformInputType(type, state) {
+  if (type instanceof GraphQLNonNull) {
+    return transformNonNullableInputType(type.ofType, state);
+  } else {
+    return require('babel-types').nullableTypeAnnotation(transformNonNullableInputType(type, state));
+  }
+}
+
+function transformNonNullableInputType(type, state) {
+  if (type instanceof GraphQLList) {
+    return readOnlyArrayOfType(transformInputType(type.ofType, state));
+  } else if (type instanceof GraphQLScalarType) {
+    return transformGraphQLScalarType(type, state);
+  } else if (type instanceof GraphQLEnumType) {
+    return transformGraphQLEnumType(type, state);
+  } else if (type instanceof GraphQLInputObjectType) {
+    var fields = type.getFields();
+    var props = Object.keys(fields).map(function (key) {
+      return fields[key];
+    }).filter(function (field) {
+      return state.inputFieldWhiteList.indexOf(field.name) < 0;
+    }).map(function (field) {
+      var property = require('babel-types').objectTypeProperty(require('babel-types').identifier(field.name), transformInputType(field.type, state));
+      if (!(field.type instanceof GraphQLNonNull)) {
+        property.optional = true;
+      }
+      return property;
+    });
+    return require('babel-types').objectTypeAnnotation(props);
+  } else {
+    throw new Error('Could not convert from GraphQL type ' + type.toString());
+  }
+}
+
+module.exports = {
+  transformInputType: transformInputType,
+  transformScalarType: transformScalarType
+};