relay-compiler 7.0.0 → 9.1.0

package/lib/runner/Artifacts.js

@@ -0,0 +1,327 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * 
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var crypto = require('crypto');
+
+var nullthrows = require('nullthrows');
+
+var _require = require('./GraphQLASTUtils'),
+    getName = _require.getName;
+
+function createEmptyState() {
+  return {
+    artifacts: new Map(),
+    metadata: new Map()
+  };
+}
+
+function serializeState(state) {
+  var json = [];
+
+  var _iterator = _createForOfIteratorHelper(state.artifacts),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+          name = _step$value[0],
+          artifacts = _step$value[1];
+      json.push([name, Array.from(artifacts).map(function (filename) {
+        var _state$metadata$get;
+
+        return [filename, (_state$metadata$get = state.metadata.get(filename)) !== null && _state$metadata$get !== void 0 ? _state$metadata$get : ''];
+      })]);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return json;
+}
+
+function deserializeState(json) {
+  var metadata = new Map();
+  var artifacts = new Map();
+  json.forEach(function (_ref) {
+    var name = _ref[0],
+        artifactArray = _ref[1];
+    var artifactsFiles = new Set();
+    artifactArray.forEach(function (_ref2) {
+      var filename = _ref2[0],
+          sha1hex = _ref2[1];
+      artifactsFiles.add(filename);
+      metadata.set(filename, sha1hex);
+    });
+    artifacts.set(name, artifactsFiles);
+  });
+  return {
+    artifacts: artifacts,
+    metadata: metadata
+  };
+}
+
+function updateState(state, changes, generatedArtifacts, filesystem, resolveFullPath) {
+  var nextState = {
+    artifacts: new Map(state.artifacts),
+    metadata: new Map(state.metadata)
+  };
+  var deletionCandidates = new Set();
+  var addedNames = new Set();
+
+  var _iterator2 = _createForOfIteratorHelper(changes.added),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var ast = _step2.value.ast;
+      addedNames.add(getName(ast));
+    } // For every removed AST node, delete the generated artifacts tracked for that
+    // node, unless the AST node was also added when the file was moved or the
+    // AST changed which shows up as added and removed in changes.
+
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  var _iterator3 = _createForOfIteratorHelper(changes.removed),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _ast = _step3.value.ast;
+      var name = getName(_ast);
+
+      if (addedNames.has(name)) {
+        // Update, we deal with that when iterating the added nodes.
+        continue;
+      }
+
+      var entry = nextState.artifacts.get(name);
+
+      if (entry == null) {
+        // No existing artifacts to delete
+        continue;
+      }
+
+      var _iterator7 = _createForOfIteratorHelper(entry.keys()),
+          _step7;
+
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var outdatedFile = _step7.value;
+          deletionCandidates.add(outdatedFile);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+
+      nextState.artifacts["delete"](name);
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  var _iterator4 = _createForOfIteratorHelper(generatedArtifacts.artifacts),
+      _step4;
+
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _step4$value = _step4.value,
+          _name = _step4$value[0],
+          artifacts = _step4$value[1];
+      var oldEntry = nextState.artifacts.get(_name);
+
+      if (oldEntry != null) {
+        var _iterator8 = _createForOfIteratorHelper(oldEntry),
+            _step8;
+
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var _outdatedFile = _step8.value;
+
+            if (!artifacts.has(_outdatedFile)) {
+              deletionCandidates.add(_outdatedFile);
+            }
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+      }
+
+      nextState.artifacts.set(_name, artifacts);
+
+      var _iterator9 = _createForOfIteratorHelper(artifacts.keys()),
+          _step9;
+
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _generatedArtifacts$m;
+
+          var filename = _step9.value;
+          nextState.metadata.set(filename, (_generatedArtifacts$m = generatedArtifacts.metadata.get(filename)) !== null && _generatedArtifacts$m !== void 0 ? _generatedArtifacts$m : '');
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+
+  if (deletionCandidates.size === 0) {
+    return nextState;
+  }
+
+  var nextGeneratedArtifacts = new Set();
+
+  var _iterator5 = _createForOfIteratorHelper(eachNameAndArtifact(nextState)),
+      _step5;
+
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _step5$value = _step5.value,
+          artifact = _step5$value[1];
+      nextGeneratedArtifacts.add(artifact);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+
+  var _iterator6 = _createForOfIteratorHelper(deletionCandidates),
+      _step6;
+
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var candidate = _step6.value;
+      var someoneElseArtifact = nextGeneratedArtifacts.has(candidate);
+
+      if (someoneElseArtifact) {
+        // Sometimes, there are artifacts that are generated by multiple files
+        // If this candidate is also generated by someone else in
+        // artifact map, we just skip it here
+        continue;
+      }
+
+      var candidatePath = resolveFullPath(candidate);
+
+      if (filesystem.existsSync(candidatePath)) {
+        filesystem.unlinkSync(candidatePath);
+        nextState.metadata["delete"](candidate);
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+
+  return nextState;
+}
+
+function producedFiles(dirs, artifactsMetadata) {
+  var result = new Map();
+  dirs.forEach(function (_ref3) {
+    var baseDir = _ref3.baseDir,
+        dir = _ref3.dir;
+    var _dir$changes = dir.changes,
+        deleted = _dir$changes.deleted,
+        updated = _dir$changes.updated,
+        created = _dir$changes.created,
+        unchanged = _dir$changes.unchanged;
+
+    if (deleted.length > 0) {
+      throw new Error('Did not expect to see a deletion entry here.');
+    }
+
+    [].concat((0, _toConsumableArray2["default"])(updated), (0, _toConsumableArray2["default"])(created)).forEach(function (filename) {
+      var name = dir.getPath(filename).substr(baseDir.length + 1);
+      var sha1hex = sha1(nullthrows(dir.read(filename)));
+      result.set(name, sha1hex);
+    });
+    unchanged.forEach(function (filename) {
+      var name = dir.getPath(filename).substr(baseDir.length + 1);
+      var sha1hex = artifactsMetadata.get(name);
+      result.set(name, sha1hex !== null && sha1hex !== void 0 ? sha1hex : sha1(nullthrows(dir.read(filename))));
+    });
+  });
+  return result;
+}
+
+function* eachNameAndArtifact(artifacts) {
+  var _iterator10 = _createForOfIteratorHelper(artifacts.artifacts),
+      _step10;
+
+  try {
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var _step10$value = _step10.value,
+          name = _step10$value[0],
+          artifactsForSource = _step10$value[1];
+
+      var _iterator11 = _createForOfIteratorHelper(artifactsForSource.keys()),
+          _step11;
+
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var artifactFile = _step11.value;
+          yield [name, artifactFile];
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+    }
+  } catch (err) {
+    _iterator10.e(err);
+  } finally {
+    _iterator10.f();
+  }
+}
+
+function sha1(content) {
+  return crypto.createHash('sha1').update(content).digest('hex');
+}
+
+module.exports = {
+  createEmptyState: createEmptyState,
+  serializeState: serializeState,
+  deserializeState: deserializeState,
+  updateState: updateState,
+  producedFiles: producedFiles,
+  eachNameAndArtifact: eachNameAndArtifact
+};

package/lib/runner/BufferedFilesystem.js

@@ -0,0 +1,265 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var fs = require('fs');
+
+var invariant = require("fbjs/lib/invariant");
+
+/**
+ * A filesystem wrapper that buffers file reads and writes until `commit()` is
+ * called.
+ */
+var BufferedFilesystem = /*#__PURE__*/function () {
+  function BufferedFilesystem() {
+    (0, _defineProperty2["default"])(this, "buffer", new Map());
+    (0, _defineProperty2["default"])(this, "committed", false);
+  }
+
+  var _proto = BufferedFilesystem.prototype;
+
+  _proto._assertNotComitted = function _assertNotComitted() {
+    !!this.committed ? process.env.NODE_ENV !== "production" ? invariant(false, 'BufferedFilesystem: no operations allowed after commit().') : invariant(false) : void 0;
+  };
+
+  _proto.commit = /*#__PURE__*/function () {
+    var _commit = _asyncToGenerator(function* (sourceControl) {
+      this._assertNotComitted();
+
+      this.committed = true;
+      var removed = [];
+      var added = [];
+
+      var _iterator = _createForOfIteratorHelper(this.buffer),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+              path = _step$value[0],
+              data = _step$value[1];
+
+          if (data == null) {
+            removed.push(path);
+            fs.unlinkSync(path);
+          } else {
+            var fileExisits = fs.existsSync(path);
+            var currentData = fileExisits ? fs.readFileSync(path, 'utf8') : null;
+
+            if (currentData !== data) {
+              added.push(path);
+              fs.writeFileSync(path, data, 'utf8');
+            }
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      if (sourceControl) {
+        yield sourceControl.addRemove(added, removed);
+      }
+    });
+
+    function commit(_x) {
+      return _commit.apply(this, arguments);
+    }
+
+    return commit;
+  }();
+
+  _proto.hasChanges = function hasChanges() {
+    this._assertNotComitted();
+
+    return this.buffer.size > 0;
+  };
+
+  _proto.getChangesSummary = function getChangesSummary() {
+    this._assertNotComitted();
+
+    var added = [];
+    var updated = [];
+    var removed = [];
+
+    var _iterator2 = _createForOfIteratorHelper(this.buffer),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _step2.value,
+            path = _step2$value[0],
+            data = _step2$value[1];
+
+        if (data == null) {
+          removed.push(path);
+        } else {
+          if (!fs.existsSync(path)) {
+            added.push(path);
+          } else {
+            updated.push(path);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return [added.length > 0 ? "Added:\n".concat(added.map(formatFilepath).join('')) : '', updated.length > 0 ? "Updated:\n".concat(updated.map(formatFilepath).join('')) : '', removed.length > 0 ? "Removed:\n".concat(removed.map(formatFilepath).join('')) : ''].filter(Boolean).join('\n');
+  };
+
+  _proto.getAddedRemovedFiles = function getAddedRemovedFiles() {
+    this._assertNotComitted();
+
+    var added = [];
+    var removed = [];
+
+    var _iterator3 = _createForOfIteratorHelper(this.buffer),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _step3$value = _step3.value,
+            path = _step3$value[0],
+            data = _step3$value[1];
+
+        if (data == null) {
+          removed.push(path);
+        } else {
+          if (!fs.existsSync(path)) {
+            added.push(path);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+
+    return {
+      added: added,
+      removed: removed
+    };
+  };
+
+  _proto.existsSync = function existsSync(path) {
+    this._assertNotComitted();
+
+    return this.buffer.has(path) ? Boolean(this.buffer.get(path)) : fs.existsSync(path);
+  };
+
+  _proto.mkdirSync = function mkdirSync(path) {
+    this._assertNotComitted();
+
+    fs.mkdirSync(path);
+  };
+
+  _proto.readdirSync = function readdirSync(path) {
+    this._assertNotComitted();
+
+    throw new Error('BufferedFilesystem: readdirSync is not implemented.');
+  };
+
+  _proto.readFileSync = function readFileSync(path, encoding) {
+    this._assertNotComitted();
+
+    if (this.buffer.has(path)) {
+      var data = this.buffer.get(path);
+      !(data != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'BufferedFilesystem: trying to read deleted file.') : invariant(false) : void 0;
+      return data;
+    }
+
+    return fs.readFileSync(path, encoding);
+  };
+
+  _proto.statSync = function statSync(path) {
+    this._assertNotComitted();
+
+    return fs.statSync(path);
+  };
+
+  _proto.unlinkSync = function unlinkSync(path) {
+    this._assertNotComitted();
+
+    this.buffer.set(path, null);
+  };
+
+  _proto.writeFileSync = function writeFileSync(filename, data, encoding) {
+    this._assertNotComitted();
+
+    this.buffer.set(filename, data);
+  };
+
+  _proto.changedFilesToJSON = function changedFilesToJSON() {
+    this._assertNotComitted();
+
+    var changed = [];
+    var removed = [];
+
+    var _iterator4 = _createForOfIteratorHelper(this.buffer),
+        _step4;
+
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _step4.value,
+            path = _step4$value[0],
+            data = _step4$value[1];
+
+        if (data == null) {
+          removed.push({
+            path: path
+          });
+        } else {
+          changed.push({
+            path: path,
+            data: data
+          });
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+
+    return {
+      removed: removed,
+      changed: changed
+    };
+  };
+
+  return BufferedFilesystem;
+}();
+
+function formatFilepath(filepath) {
+  var startIndex = filepath.length - 80;
+  var prefix = startIndex > 0 ? "\t - ".concat(filepath.substr(0, 8), "...") : '\t - ';
+  return prefix + filepath.substr(startIndex, filepath.length) + '\n';
+}
+
+module.exports = BufferedFilesystem;