relay-compiler 1.3.0 → 1.5.0

package/lib/RelayFileWriter.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 RelayFileWriter
  * 
@@ -23,58 +21,66 @@ var _toConsumableArray3 = _interopRequireDefault(require('babel-runtime/helpers/
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
-var _require = require('./GraphQLSchemaUtils'),
-    isOperationDefinitionAST = _require.isOperationDefinitionAST;
+var _require = require('./GraphQLCompilerPublic'),
+    ASTConvert = _require.ASTConvert,
+    CodegenDirectory = _require.CodegenDirectory,
+    CompilerContext = _require.CompilerContext,
+    Profiler = _require.Profiler,
+    SchemaUtils = _require.SchemaUtils;
 
-var _require2 = require('./RelayCodeGenerator'),
-    generate = _require2.generate;
+var _require2 = require('immutable'),
+    ImmutableMap = _require2.Map;
 
-var _require3 = require('immutable'),
-    ImmutableMap = _require3.Map;
-
-/* eslint-disable no-console-disallow */
+var isExecutableDefinitionAST = SchemaUtils.isExecutableDefinitionAST;
 
 var RelayFileWriter = function () {
-  function RelayFileWriter(options) {
+  function RelayFileWriter(_ref) {
+    var config = _ref.config,
+        onlyValidate = _ref.onlyValidate,
+        baseDocuments = _ref.baseDocuments,
+        documents = _ref.documents,
+        schema = _ref.schema,
+        reporter = _ref.reporter,
+        sourceControl = _ref.sourceControl;
     (0, _classCallCheck3['default'])(this, RelayFileWriter);
-    var config = options.config,
-        onlyValidate = options.onlyValidate,
-        baseDocuments = options.baseDocuments,
-        documents = options.documents,
-        schema = options.schema;
 
     this._baseDocuments = baseDocuments || ImmutableMap();
     this._baseSchema = schema;
     this._config = config;
     this._documents = documents;
     this._onlyValidate = onlyValidate;
+    this._reporter = reporter;
+    this._sourceControl = sourceControl;
 
     validateConfig(this._config);
   }
 
-  RelayFileWriter.prototype.writeAll = (() => {
-    var _ref = (0, _asyncToGenerator3.default)(function* () {
-      var _this = this;
-
-      var tStart = Date.now();
+  RelayFileWriter.prototype.writeAll = function writeAll() {
+    var _this = this;
 
+    return Profiler.asyncContext('RelayFileWriter.writeAll', (0, _asyncToGenerator3.default)(function* () {
       // Can't convert to IR unless the schema already has Relay-local extensions
-      var transformedSchema = require('./ASTConvert').transformASTSchema(this._baseSchema, this._config.schemaExtensions);
-      var extendedSchema = require('./ASTConvert').extendASTSchema(transformedSchema, this._baseDocuments.merge(this._documents).valueSeq().toArray());
+      var transformedSchema = ASTConvert.transformASTSchema(_this._baseSchema, _this._config.schemaExtensions);
+      var extendedSchema = ASTConvert.extendASTSchema(transformedSchema, _this._baseDocuments.merge(_this._documents).valueSeq().toArray());
 
       // Build a context from all the documents
       var baseDefinitionNames = new Set();
-      this._baseDocuments.forEach(function (doc) {
+      _this._baseDocuments.forEach(function (doc) {
         doc.definitions.forEach(function (def) {
-          if (isOperationDefinitionAST(def) && def.name) {
+          if (isExecutableDefinitionAST(def) && def.name) {
             baseDefinitionNames.add(def.name.value);
           }
         });
       });
-      var definitionDirectories = new Map();
+      var definitionsMeta = new Map();
+      var getDefinitionMeta = function getDefinitionMeta(definitionName) {
+        var definitionMeta = definitionsMeta.get(definitionName);
+        require('fbjs/lib/invariant')(definitionMeta, 'RelayFileWriter: Could not determine source for definition: `%s`.', definitionName);
+        return definitionMeta;
+      };
       var allOutputDirectories = new Map();
       var addCodegenDir = function addCodegenDir(dirPath) {
-        var codegenDir = new (require('./CodegenDirectory'))(dirPath, {
+        var codegenDir = new CodegenDirectory(dirPath, {
           onlyValidate: _this._onlyValidate
         });
         allOutputDirectories.set(dirPath, codegenDir);
@@ -82,33 +88,38 @@ var RelayFileWriter = function () {
       };
 
       var configOutputDirectory = void 0;
-      if (this._config.outputDir) {
-        configOutputDirectory = addCodegenDir(this._config.outputDir);
-      } else {
-        this._documents.forEach(function (doc, filePath) {
-          doc.definitions.forEach(function (def) {
-            if (isOperationDefinitionAST(def) && def.name) {
-              definitionDirectories.set(def.name.value, require('path').join(_this._config.baseDir, require('path').dirname(filePath)));
-            }
-          });
-        });
+      if (_this._config.outputDir) {
+        configOutputDirectory = addCodegenDir(_this._config.outputDir);
       }
 
-      var definitions = require('./ASTConvert').convertASTDocumentsWithBase(extendedSchema, this._baseDocuments.valueSeq().toArray(), this._documents.valueSeq().toArray(),
+      _this._documents.forEach(function (doc, filePath) {
+        doc.definitions.forEach(function (def) {
+          if (def.name) {
+            definitionsMeta.set(def.name.value, {
+              dir: require('path').join(_this._config.baseDir, require('path').dirname(filePath)),
+              ast: def
+            });
+          }
+        });
+      });
+
       // Verify using local and global rules, can run global verifications here
       // because all files are processed together
-      [].concat((0, _toConsumableArray3['default'])(require('./RelayValidator').LOCAL_RULES), (0, _toConsumableArray3['default'])(require('./RelayValidator').GLOBAL_RULES)));
+      var validationRules = [].concat((0, _toConsumableArray3['default'])(require('./RelayValidator').LOCAL_RULES), (0, _toConsumableArray3['default'])(require('./RelayValidator').GLOBAL_RULES));
+      var customizedValidationRules = _this._config.validationRules;
+      if (customizedValidationRules) {
+        validationRules = [].concat((0, _toConsumableArray3['default'])(validationRules), (0, _toConsumableArray3['default'])(customizedValidationRules.LOCAL_RULES || []), (0, _toConsumableArray3['default'])(customizedValidationRules.GLOBAL_RULES || []));
+      }
 
-      var compilerContext = new (require('./RelayCompilerContext'))(extendedSchema);
-      var compiler = new (require('./RelayCompiler'))(this._baseSchema, compilerContext, this._config.compilerTransforms, generate);
+      var definitions = ASTConvert.convertASTDocumentsWithBase(extendedSchema, _this._baseDocuments.valueSeq().toArray(), _this._documents.valueSeq().toArray(), validationRules, require('./RelayParser').transform.bind(require('./RelayParser')));
+
+      var compilerContext = new CompilerContext(_this._baseSchema, extendedSchema).addAll(definitions);
 
       var getGeneratedDirectory = function getGeneratedDirectory(definitionName) {
         if (configOutputDirectory) {
           return configOutputDirectory;
         }
-        var definitionDir = definitionDirectories.get(definitionName);
-        require('fbjs/lib/invariant')(definitionDir, 'RelayFileWriter: Could not determine source directory for definition: %s', definitionName);
-        var generatedPath = require('path').join(definitionDir, '__generated__');
+        var generatedPath = require('path').join(getDefinitionMeta(definitionName).dir, '__generated__');
         var cachedDir = allOutputDirectories.get(generatedPath);
         if (!cachedDir) {
           cachedDir = addCodegenDir(generatedPath);
@@ -116,63 +127,86 @@ var RelayFileWriter = function () {
         return cachedDir;
       };
 
-      compiler.addDefinitions(definitions);
+      var transformedFlowContext = compilerContext.applyTransforms(require('./RelayFlowGenerator').flowTransforms, _this._reporter);
+      var transformedQueryContext = compilerContext.applyTransforms([].concat((0, _toConsumableArray3['default'])(_this._config.compilerTransforms.commonTransforms), (0, _toConsumableArray3['default'])(_this._config.compilerTransforms.queryTransforms)), _this._reporter);
+      var artifacts = require('./compileRelayArtifacts')(compilerContext, _this._config.compilerTransforms, _this._reporter);
+
+      var existingFragmentNames = new Set(definitions.map(function (definition) {
+        return definition.name;
+      }));
 
-      var transformedFlowContext = require('./RelayFlowGenerator').flowTransforms.reduce(function (ctx, transform) {
-        return transform(ctx, extendedSchema);
-      }, compiler.context());
-      var transformedQueryContext = compiler.transformedQueryContext();
-      var compiledDocumentMap = compiler.compile();
+      // TODO(T22651734): improve this to correctly account for fragments that
+      // have generated flow types.
+      baseDefinitionNames.forEach(function (baseDefinitionName) {
+        existingFragmentNames['delete'](baseDefinitionName);
+      });
 
-      var tCompiled = Date.now();
+      var formatModule = Profiler.instrument(_this._config.formatModule, 'RelayFileWriter:formatModule');
+
+      var persistQuery = _this._config.persistQuery ? Profiler.instrumentWait(_this._config.persistQuery, 'RelayFileWriter:persistQuery') : null;
 
-      var tGenerated = void 0;
       try {
-        yield Promise.all(transformedFlowContext.documents().map((() => {
-          var _ref2 = (0, _asyncToGenerator3.default)(function* (node) {
+        yield Promise.all(artifacts.map((() => {
+          var _ref3 = (0, _asyncToGenerator3.default)(function* (node) {
             if (baseDefinitionNames.has(node.name)) {
               // don't add definitions that were part of base context
               return;
             }
-            if (_this._config.fragmentsWithLegacyFlowTypes && _this._config.fragmentsWithLegacyFlowTypes.has(node.name)) {
-              var legacyFlowTypes = require('./printFlowTypes')(node);
-              if (legacyFlowTypes) {
-                require('./writeLegacyFlowFile')(getGeneratedDirectory(node.name), node.name, legacyFlowTypes, _this._config.platform);
-              }
+            if (node.metadata && node.metadata.deferred) {
+              // don't write deferred operations, the batch request is
+              // responsible for them
+              return;
             }
+            var relayRuntimeModule = _this._config.relayRuntimeModule || 'relay-runtime';
+
+            var flowNode = transformedFlowContext.get(node.name);
+            require('fbjs/lib/invariant')(flowNode, 'RelayFileWriter: did not compile flow types for: %s', node.name);
 
-            var flowTypes = require('./RelayFlowGenerator').generate(node, _this._config.customScalars, _this._config.inputFieldWhiteListForFlow);
+            var flowTypes = require('./RelayFlowGenerator').generate(flowNode, {
+              customScalars: _this._config.customScalars,
+              enumsHasteModule: _this._config.enumsHasteModule,
+              existingFragmentNames: existingFragmentNames,
+              inputFieldWhiteList: _this._config.inputFieldWhiteListForFlow,
+              relayRuntimeModule: relayRuntimeModule,
+              useHaste: _this._config.useHaste
+            });
 
-            var compiledNode = compiledDocumentMap.get(node.name);
-            require('fbjs/lib/invariant')(compiledNode, 'RelayCompiler: did not compile definition: %s', node.name);
-            yield require('./writeRelayGeneratedFile')(getGeneratedDirectory(compiledNode.name), getGeneratedNode(compiledNode), _this._config.formatModule, flowTypes, _this._config.persistQuery, _this._config.platform, _this._config.relayRuntimeModule || 'relay-runtime');
+            var sourceHash = Profiler.run('hashGraphQL', function () {
+              return md5(require('graphql').print(getDefinitionMeta(node.name).ast));
+            });
+
+            yield require('./writeRelayGeneratedFile')(getGeneratedDirectory(node.name), node, formatModule, flowTypes, persistQuery, _this._config.platform, relayRuntimeModule, sourceHash);
           });
 
           return function (_x) {
-            return _ref2.apply(this, arguments);
+            return _ref3.apply(this, arguments);
           };
         })()));
-        tGenerated = Date.now();
-
-        if (this._config.generateExtraFiles) {
-          var configDirectory = this._config.outputDir;
-          this._config.generateExtraFiles(function (dir) {
-            var outputDirectory = dir || configDirectory;
-            require('fbjs/lib/invariant')(outputDirectory, 'RelayFileWriter: cannot generate extra files without specifying ' + 'an outputDir in the config or passing it in.');
-            var outputDir = allOutputDirectories.get(outputDirectory);
-            if (!outputDir) {
-              outputDir = addCodegenDir(outputDirectory);
-            }
-            return outputDir;
-          }, transformedQueryContext, getGeneratedDirectory);
+
+        var _generateExtraFiles = _this._config.generateExtraFiles;
+        if (_generateExtraFiles) {
+          Profiler.run('RelayFileWriter:generateExtraFiles', function () {
+            var configDirectory = _this._config.outputDir;
+            _generateExtraFiles(function (dir) {
+              var outputDirectory = dir || configDirectory;
+              require('fbjs/lib/invariant')(outputDirectory, 'RelayFileWriter: cannot generate extra files without specifying ' + 'an outputDir in the config or passing it in.');
+              var outputDir = allOutputDirectories.get(outputDirectory);
+              if (!outputDir) {
+                outputDir = addCodegenDir(outputDirectory);
+              }
+              return outputDir;
+            }, transformedQueryContext, getGeneratedDirectory);
+          });
         }
 
         // clean output directories
         allOutputDirectories.forEach(function (dir) {
           dir.deleteExtraFiles();
         });
+        if (_this._sourceControl && !_this._onlyValidate) {
+          yield CodegenDirectory.sourceControlAddRemove(_this._sourceControl, Array.from(allOutputDirectories.values()));
+        }
       } catch (error) {
-        tGenerated = Date.now();
         var details = void 0;
         try {
           details = JSON.parse(error.message);
@@ -180,31 +214,18 @@ var RelayFileWriter = function () {
         if (details && details.name === 'GraphQL2Exception' && details.message) {
           throw new Error('GraphQL error writing modules:\n' + details.message);
         }
-        throw new Error('Error writing modules:\n' + error.toString());
+        throw new Error('Error writing modules:\n' + String(error.stack || error));
       }
 
-      var tExtra = Date.now();
-      console.log('Writer time: %s [%s compiling, %s generating, %s extra]', toSeconds(tStart, tExtra), toSeconds(tStart, tCompiled), toSeconds(tCompiled, tGenerated), toSeconds(tGenerated, tExtra));
       return allOutputDirectories;
-    });
-
-    function writeAll() {
-      return _ref.apply(this, arguments);
-    }
-
-    return writeAll;
-  })();
+    }));
+  };
 
   return RelayFileWriter;
 }();
 
-function getGeneratedNode(compiledNode) {
-  require('fbjs/lib/invariant')(typeof compiledNode === 'object' && compiledNode !== null && (compiledNode.kind === 'Fragment' || compiledNode.kind === 'Batch'), 'getGeneratedNode: Expected a GeneratedNode, got `%s`.', JSON.stringify(compiledNode));
-  return compiledNode;
-}
-
-function toSeconds(t0, t1) {
-  return ((t1 - t0) / 1000).toFixed(2) + 's';
+function md5(x) {
+  return require('crypto').createHash('md5').update(x, 'utf8').digest('hex');
 }
 
 function validateConfig(config) {

package/lib/RelayFlowBabelFactories.js

@@ -0,0 +1,113 @@
+/**
+ * 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 RelayFlowBabelFactories
+ * 
+ * @format
+ */
+
+'use strict';
+
+/**
+ * type NAME = any;
+ */
+function anyTypeAlias(name) {
+  return require('babel-types').typeAlias(require('babel-types').identifier(name), null, require('babel-types').anyTypeAnnotation());
+}
+
+/**
+ * {|
+ *   PROPS
+ * |}
+ */
+function exactObjectTypeAnnotation(props) {
+  var typeAnnotation = require('babel-types').objectTypeAnnotation(props);
+  typeAnnotation.exact = true;
+  return typeAnnotation;
+}
+
+/**
+ * export type NAME = TYPE
+ */
+function exportType(name, type) {
+  return require('babel-types').exportNamedDeclaration(require('babel-types').typeAlias(require('babel-types').identifier(name), null, type), [], null);
+}
+
+/**
+ * import type {NAMES[0], NAMES[1], ...} from 'MODULE';
+ */
+function importTypes(names, module) {
+  var importDeclaration = require('babel-types').importDeclaration(names.map(function (name) {
+    return require('babel-types').importSpecifier(require('babel-types').identifier(name), require('babel-types').identifier(name));
+  }), require('babel-types').stringLiteral(module));
+  importDeclaration.importKind = 'type';
+  return importDeclaration;
+}
+
+/**
+ * Create an intersection type if needed.
+ *
+ * TYPES[0] & TYPES[1] & ...
+ */
+function intersectionTypeAnnotation(types) {
+  require('fbjs/lib/invariant')(types.length > 0, 'RelayFlowBabelFactories: cannot create an intersection of 0 types');
+  return types.length === 1 ? types[0] : require('babel-types').intersectionTypeAnnotation(types);
+}
+
+function lineComments() {
+  for (var _len = arguments.length, lines = Array(_len), _key = 0; _key < _len; _key++) {
+    lines[_key] = arguments[_key];
+  }
+
+  return lines.map(function (line) {
+    return { type: 'CommentLine', value: ' ' + line };
+  });
+}
+
+/**
+ * $ReadOnlyArray<TYPE>
+ */
+function readOnlyArrayOfType(thing) {
+  return require('babel-types').genericTypeAnnotation(require('babel-types').identifier('$ReadOnlyArray'), require('babel-types').typeParameterInstantiation([thing]));
+}
+
+/**
+ * +KEY: VALUE
+ */
+function readOnlyObjectTypeProperty(key, value) {
+  var prop = require('babel-types').objectTypeProperty(require('babel-types').identifier(key), value);
+  prop.variance = 'plus';
+  return prop;
+}
+
+function stringLiteralTypeAnnotation(value) {
+  var annotation = require('babel-types').stringLiteralTypeAnnotation();
+  annotation.value = value;
+  return annotation;
+}
+
+/**
+ * Create a union type if needed.
+ *
+ * TYPES[0] | TYPES[1] | ...
+ */
+function unionTypeAnnotation(types) {
+  require('fbjs/lib/invariant')(types.length > 0, 'RelayFlowBabelFactories: cannot create a union of 0 types');
+  return types.length === 1 ? types[0] : require('babel-types').unionTypeAnnotation(types);
+}
+
+module.exports = {
+  anyTypeAlias: anyTypeAlias,
+  exactObjectTypeAnnotation: exactObjectTypeAnnotation,
+  exportType: exportType,
+  importTypes: importTypes,
+  intersectionTypeAnnotation: intersectionTypeAnnotation,
+  lineComments: lineComments,
+  readOnlyArrayOfType: readOnlyArrayOfType,
+  readOnlyObjectTypeProperty: readOnlyObjectTypeProperty,
+  stringLiteralTypeAnnotation: stringLiteralTypeAnnotation,
+  unionTypeAnnotation: unionTypeAnnotation
+};