@ardatan/relay-compiler 12.0.0

package/lib/util/RelayCompilerCache.js

@@ -0,0 +1,98 @@
+/**
+ * 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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var Profiler = require('../core/GraphQLCompilerProfiler');
+
+var crypto = require('crypto');
+
+var fs = require('fs');
+
+var os = require('os');
+
+var path = require('path');
+/**
+ * A file backed cache. Values are JSON encoded on disk, so only JSON
+ * serializable values should be used.
+ */
+
+
+var RelayCompilerCache = /*#__PURE__*/function () {
+  /**
+   * @param name         Human readable identifier for the cache
+   * @param cacheBreaker This should be changed in order to invalidate existing
+   *                     caches.
+   */
+  function RelayCompilerCache(name, cacheBreaker) {
+    (0, _defineProperty2["default"])(this, "_dir", null);
+    this._name = name;
+    this._cacheBreaker = cacheBreaker;
+  }
+
+  var _proto = RelayCompilerCache.prototype;
+
+  _proto._getFile = function _getFile(key) {
+    if (this._dir == null) {
+      // Include username in the cache dir to avoid issues with directories being
+      // owned by a different user.
+      var username = os.userInfo().username;
+      var cacheID = crypto.createHash('md5').update(this._cacheBreaker).update(username).digest('hex');
+      var dir = path.join(os.tmpdir(), "".concat(this._name, "-").concat(cacheID));
+
+      if (!fs.existsSync(dir)) {
+        try {
+          fs.mkdirSync(dir);
+        } catch (error) {
+          if (error.code !== 'EEXIST') {
+            throw error;
+          }
+        }
+      }
+
+      this._dir = dir;
+    }
+
+    return path.join(this._dir, key);
+  };
+
+  _proto.getOrCompute = function getOrCompute(key, compute) {
+    var _this = this;
+
+    return Profiler.run('RelayCompilerCache.getOrCompute', function () {
+      var cacheFile = _this._getFile(key);
+
+      if (fs.existsSync(cacheFile)) {
+        try {
+          return JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        } catch (_unused) {// ignore
+        }
+      }
+
+      var value = compute();
+
+      try {
+        // $FlowFixMe[incompatible-call] JSON.stringify can return undefined
+        fs.writeFileSync(cacheFile, JSON.stringify(value), 'utf8');
+      } catch (_unused2) {// ignore
+      }
+
+      return value;
+    });
+  };
+
+  return RelayCompilerCache;
+}();
+
+module.exports = RelayCompilerCache;

package/lib/util/Rollout.js

@@ -0,0 +1,40 @@
+/**
+ * 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 whitelistsByProject = null;
+/**
+ * This module helps gradually rolling out changes to the code generation by
+ * gradually enabling more buckets representing randomly distributed artifacts.
+ */
+
+function set(newWhitelistsByProject) {
+  whitelistsByProject = newWhitelistsByProject;
+}
+
+function check(project, key) {
+  if (whitelistsByProject == null) {
+    return true;
+  }
+
+  var whitelist = whitelistsByProject.get(project);
+
+  if (whitelist == null) {
+    return true;
+  }
+
+  return whitelist.has(key);
+}
+
+module.exports = {
+  set: set,
+  check: check
+};

package/lib/util/TimeReporter.js

@@ -0,0 +1,83 @@
+/**
+ * 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
+ * 
+ * @emails oncall+relay
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+
+var _require = require('relay-runtime'),
+    isPromise = _require.isPromise;
+
+function reportTime(reporter, message, fn) {
+  return reportAndReturnTime(reporter, message, fn)[0];
+}
+
+function reportAndReturnTime(reporter, message, fn) {
+  var startTime = Date.now();
+  var result = fn();
+
+  if (isPromise(result)) {
+    throw new Error('reportAndReturnTime: fn(...) returned an unexpected promise.' + ' Please use `reportAndReturnAsyncTime` method instead.');
+  }
+
+  var elapsedTime = Date.now() - startTime;
+  reporter.reportTime(message, elapsedTime);
+  return [result, elapsedTime];
+}
+
+function reportAndReturnAsyncTime(_x, _x2, _x3) {
+  return _reportAndReturnAsyncTime.apply(this, arguments);
+}
+
+function _reportAndReturnAsyncTime() {
+  _reportAndReturnAsyncTime = _asyncToGenerator(function* (reporter, message, fn) {
+    var startTime = Date.now();
+    var promise = fn();
+
+    if (!isPromise(promise)) {
+      throw new Error('reportAsyncTime: fn(...) expected to return a promise.');
+    }
+
+    var result = yield promise;
+    var elapsedTime = Date.now() - startTime;
+    reporter.reportTime(message, elapsedTime);
+    return [result, elapsedTime];
+  });
+  return _reportAndReturnAsyncTime.apply(this, arguments);
+}
+
+function reportAsyncTime(_x4, _x5, _x6) {
+  return _reportAsyncTime.apply(this, arguments);
+}
+
+function _reportAsyncTime() {
+  _reportAsyncTime = _asyncToGenerator(function* (reporter, message, fn) {
+    var startTime = Date.now();
+    var promise = fn();
+
+    if (!isPromise(promise)) {
+      throw new Error('reportAsyncTime: fn(...) expected to return a promise.');
+    }
+
+    var result = yield promise;
+    var elapsedTime = Date.now() - startTime;
+    reporter.reportTime(message, elapsedTime);
+    return result;
+  });
+  return _reportAsyncTime.apply(this, arguments);
+}
+
+module.exports = {
+  reportTime: reportTime,
+  reportAndReturnTime: reportAndReturnTime,
+  reportAsyncTime: reportAsyncTime,
+  reportAndReturnAsyncTime: reportAndReturnAsyncTime
+};

package/lib/util/areEqualArgValues.js

@@ -0,0 +1,135 @@
+/**
+ * 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
+ */
+// TODO: This is only used with `ArgumentValue` types, so it could be simpler.
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var aStackPool = [];
+var bStackPool = [];
+/**
+ * Checks if two values are equal. Values may be primitives, arrays, or objects.
+ * Returns true if both arguments have the same keys and values.
+ *
+ * @see http://underscorejs.org
+ * @copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+ * @license MIT
+ */
+
+function areEqualArgValues(a, b) {
+  var aStack = aStackPool.length ? aStackPool.pop() : [];
+  var bStack = bStackPool.length ? bStackPool.pop() : [];
+  var result = eq(a, b, aStack, bStack);
+  aStack.length = 0;
+  bStack.length = 0;
+  aStackPool.push(aStack);
+  bStackPool.push(bStack);
+  return result;
+}
+
+function eq(a, b, aStack, bStack) {
+  if (a === b) {
+    // Identical objects are equal. `0 === -0`, but they aren't identical.
+    return a !== 0 || 1 / a === 1 / b;
+  }
+
+  if (a == null || b == null) {
+    // a or b can be `null` or `undefined`
+    return false;
+  }
+
+  if (typeof a !== 'object' || typeof b !== 'object') {
+    return false;
+  } // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+
+
+  var objToStr = Object.prototype.toString;
+  var className = objToStr.call(a);
+
+  if (className !== objToStr.call(b)) {
+    return false;
+  }
+
+  switch (className) {
+    case '[object String]':
+      return a === String(b);
+
+    case '[object Number]':
+      return isNaN(a) || isNaN(b) ? false : a === Number(b);
+
+    case '[object Date]':
+    case '[object Boolean]':
+      return +a === +b;
+
+    case '[object RegExp]':
+      return a.source === b.source && a.global === b.global && a.multiline === b.multiline && a.ignoreCase === b.ignoreCase;
+  } // Assume equality for cyclic structures.
+
+
+  var length = aStack.length;
+
+  while (length--) {
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    }
+  }
+
+  aStack.push(a);
+  bStack.push(b);
+  var size = 0; // Recursively compare objects and arrays.
+
+  if (className === '[object Array]') {
+    size = a.length;
+
+    if (size !== b.length) {
+      return false;
+    } // Deep compare the contents, ignoring non-numeric properties.
+
+
+    while (size--) {
+      if (!eq(a[size], b[size], aStack, bStack)) {
+        return false;
+      }
+    }
+  } else {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+
+    if (a.hasOwnProperty('valueOf') && b.hasOwnProperty('valueOf')) {
+      return a.valueOf() === b.valueOf();
+    }
+
+    var keys = Object.keys(a);
+
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
+
+    for (var i = 0; i < keys.length; i++) {
+      if (keys[i] === '_owner') {
+        // HACK: Comparing deeply nested React trees is slow since you end up
+        // comparing the entire tree (all ancestors and all children) and
+        // likely not what you want if you're comparing two elements with
+        // areEqualArgValues. We bail out here for now.
+        continue;
+      }
+
+      if (!b.hasOwnProperty(keys[i]) || !eq(a[keys[i]], b[keys[i]], aStack, bStack)) {
+        return false;
+      }
+    }
+  }
+
+  aStack.pop();
+  bStack.pop();
+  return true;
+}
+
+module.exports = areEqualArgValues;

package/lib/util/argumentContainsVariables.js

@@ -0,0 +1,37 @@
+/**
+ * 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';
+
+function argumentContainsVariables(arg) {
+  if (arg == null) {
+    return false;
+  }
+
+  switch (arg.kind) {
+    case 'Variable':
+      return true;
+
+    case 'Literal':
+      return false;
+
+    case 'ListValue':
+      return arg.items.some(argumentContainsVariables);
+
+    case 'ObjectValue':
+      return arg.fields.some(argumentContainsVariables);
+
+    default:
+      arg.kind;
+      return false;
+  }
+}
+
+module.exports = argumentContainsVariables;

package/lib/util/dedupeJSONStringify.js

@@ -0,0 +1,160 @@
+/**
+ * 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';
+/**
+ * This function works similar to JSON.stringify except that for the case there
+ * are multiple common subtrees, it generates a string for a IIFE that re-uses
+ * the same objects for the duplicate subtrees.
+ */
+
+function dedupeJSONStringify(jsonValue) {
+  var metadataForHash = new Map();
+  var metadataForVal = new WeakMap();
+  var varDefs = [];
+  collectMetadata(jsonValue);
+  collectDuplicates(jsonValue);
+  var code = printJSCode(false, '', jsonValue);
+  return varDefs.length === 0 ? code : "(function(){\nvar ".concat(varDefs.join(',\n'), ";\nreturn ").concat(code, ";\n})()"); // Collect common metadata for each object in the value tree, ensuring that
+  // equivalent values have the *same reference* to the same metadata. Note that
+  // the hashes generated are not exactly JSON, but still identify equivalent
+  // values. Runs in linear time due to hashing in a bottom-up recursion.
+
+  function collectMetadata(value) {
+    if (value == null || typeof value !== 'object') {
+      // $FlowFixMe[incompatible-return] - JSON.stringify can return undefined
+      return JSON.stringify(value);
+    }
+
+    var hash;
+
+    if (Array.isArray(value)) {
+      hash = '[';
+
+      for (var i = 0; i < value.length; i++) {
+        hash += collectMetadata(value[i]) + ',';
+      }
+    } else {
+      hash = '{';
+
+      for (var k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          hash += k + ':' + collectMetadata(value[k]) + ',';
+        }
+      }
+    }
+
+    var metadata = metadataForHash.get(hash);
+
+    if (!metadata) {
+      metadata = {
+        value: value,
+        hash: hash,
+        count: 0
+      };
+      metadataForHash.set(hash, metadata);
+    }
+
+    metadataForVal.set(value, metadata);
+    return hash;
+  } // Using top-down recursion, linearly scan the JSON tree to determine which
+  // values should be deduplicated.
+
+
+  function collectDuplicates(value) {
+    if (value == null || typeof value !== 'object') {
+      return;
+    }
+
+    var metadata = metadataForVal.get(value); // Only consider duplicates with hashes longer than 2 (excludes [] and {}).
+
+    if (metadata && metadata.hash.length > 2) {
+      metadata.count++;
+
+      if (metadata.count > 1) {
+        return;
+      }
+    }
+
+    if (Array.isArray(value)) {
+      for (var i = 0; i < value.length; i++) {
+        collectDuplicates(value[i]);
+      }
+    } else {
+      for (var k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          collectDuplicates(value[k]);
+        }
+      }
+    }
+  } // Stringify JS, replacing duplicates with variable references.
+
+
+  function printJSCode(isDupedVar, depth, value) {
+    if (value == null || typeof value !== 'object') {
+      // $FlowFixMe[incompatible-return] : JSON.stringify can return undefined
+      return JSON.stringify(value);
+    } // Only use variable references at depth beyond the top level.
+
+
+    if (depth !== '') {
+      var metadata = metadataForVal.get(value);
+
+      if (metadata && metadata.count > 1) {
+        var varName = metadata.varName;
+
+        if (varName == null) {
+          var refCode = printJSCode(true, '', value);
+          varName = metadata.varName = 'v' + varDefs.length;
+          varDefs.push(metadata.varName + ' = ' + refCode);
+        }
+
+        return '(' + varName + '/*: any*/)';
+      }
+    }
+
+    var str;
+    var isEmpty = true;
+    var depth2 = depth + '  ';
+
+    if (Array.isArray(value)) {
+      // Empty arrays can only have one inferred flow type and then conflict if
+      // used in different places, this is unsound if we would write to them but
+      // this whole module is based on the idea of a read only JSON tree.
+      if (isDupedVar && value.length === 0) {
+        return '([]/*: any*/)';
+      }
+
+      str = '[';
+
+      for (var i = 0; i < value.length; i++) {
+        str += (isEmpty ? '\n' : ',\n') + depth2 + printJSCode(isDupedVar, depth2, value[i]);
+        isEmpty = false;
+      }
+
+      str += isEmpty ? ']' : "\n".concat(depth, "]");
+    } else {
+      str = '{';
+
+      for (var k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          str += (isEmpty ? '\n' : ',\n') + depth2 + JSON.stringify(k) + ': ' + printJSCode(isDupedVar, depth2, value[k]);
+          isEmpty = false;
+        }
+      }
+
+      str += isEmpty ? '}' : "\n".concat(depth, "}");
+    }
+
+    return str;
+  }
+}
+
+module.exports = dedupeJSONStringify;

package/lib/util/generateAbstractTypeRefinementKey.js

@@ -0,0 +1,24 @@
+/**
+ * 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 _require = require('../core/CompilerError'),
+    createCompilerError = _require.createCompilerError;
+
+function generateAbstractTypeRefinementKey(schema, type) {
+  if (!schema.isAbstractType(type)) {
+    throw createCompilerError('Expected an abstract type');
+  }
+
+  return "__is".concat(schema.getTypeString(type));
+}
+
+module.exports = generateAbstractTypeRefinementKey;

package/lib/util/getDefinitionNodeHash.js

@@ -0,0 +1,22 @@
+/**
+ * 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 md5 = require('./md5');
+
+var _require = require('graphql'),
+    print = _require.print;
+
+function getDefinitionNodeHash(node) {
+  return md5(print(node));
+}
+
+module.exports = getDefinitionNodeHash;

package/lib/util/getModuleName.js

@@ -0,0 +1,32 @@
+/**
+ * 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 path = require('path');
+
+function getModuleName(filePath) {
+  // index.js -> index
+  // index.js.flow -> index.js
+  var filename = path.basename(filePath, path.extname(filePath)); // index.js -> index (when extension has multiple segments)
+  // index.react -> index (when extension has multiple segments)
+
+  filename = filename.replace(/(\.(?!ios|android)[_a-zA-Z0-9\\-]+)+/g, ''); // /path/to/button/index.js -> button
+
+  var moduleName = filename === 'index' ? path.basename(path.dirname(filePath)) : filename; // foo-bar -> fooBar
+  // Relay compatibility mode splits on _, so we can't use that here.
+
+  moduleName = moduleName.replace(/[^a-zA-Z0-9]+(\w?)/g, function (match, next) {
+    return next.toUpperCase();
+  });
+  return moduleName;
+}
+
+module.exports = getModuleName;

package/lib/util/joinArgumentDefinitions.js

@@ -0,0 +1,66 @@
+/**
+ * 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 _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+/**
+ * Attempts to join the argument definitions for a root fragment
+ * and any unmasked fragment spreads reachable from that root fragment,
+ * returning a combined list of arguments or throwing if the same
+ * variable(s) are used in incompatible ways in different fragments.
+ */
+function joinArgumentDefinitions(schema, fragment, reachableArguments, directiveName) {
+  var joinedArgumentDefinitions = new Map();
+  fragment.argumentDefinitions.forEach(function (prevArgDef) {
+    joinedArgumentDefinitions.set(prevArgDef.name, prevArgDef);
+  });
+  reachableArguments.forEach(function (nextArgDef) {
+    var prevArgDef = joinedArgumentDefinitions.get(nextArgDef.name);
+    var joinedArgDef = prevArgDef == null ? nextArgDef : joinArgumentDefinition(schema, prevArgDef, nextArgDef, directiveName);
+    joinedArgumentDefinitions.set(joinedArgDef.name, joinedArgDef);
+  });
+  return Array.from(joinedArgumentDefinitions.values());
+}
+/**
+ * @private
+ *
+ * Attempts to join two argument definitions, returning a single argument
+ * definition that is compatible with both of the inputs:
+ * - If the kind, name, or defaultValue is different then the arguments
+ *   cannot be joined, indicated by returning null.
+ * - If either of next/prev is a subtype of the other, return the one
+ *   that is the subtype: a more narrow type can flow into a more general
+ *   type but not the inverse.
+ * - Otherwise there is no subtyping relation between prev/next, so return
+ *   null to indicate they cannot be joined.
+ */
+
+
+function joinArgumentDefinition(schema, prevArgDef, nextArgDef, directiveName) {
+  if (prevArgDef.kind !== nextArgDef.kind) {
+    throw createUserError('Cannot combine global and local variables when applying ' + "".concat(directiveName, "."), [prevArgDef.loc, nextArgDef.loc]);
+  } else if (prevArgDef.kind === 'LocalArgumentDefinition' && nextArgDef.kind === 'LocalArgumentDefinition' && prevArgDef.defaultValue !== nextArgDef.defaultValue) {
+    throw createUserError('Cannot combine local variables with different defaultValues when ' + "applying ".concat(directiveName, "."), [prevArgDef.loc, nextArgDef.loc]);
+  } else if (schema.isTypeSubTypeOf(nextArgDef.type, prevArgDef.type)) {
+    // prevArgDef is less strict than nextArgDef
+    return nextArgDef;
+  } else if (schema.isTypeSubTypeOf(prevArgDef.type, nextArgDef.type)) {
+    return prevArgDef;
+  } else {
+    var prevArgType = prevArgDef.type != null ? schema.getTypeString(prevArgDef.type) : 'unknown';
+    var nextArgType = nextArgDef.type != null ? schema.getTypeString(nextArgDef.type) : 'unknown';
+    throw createUserError('Cannot combine variables with incompatible types ' + "".concat(prevArgType, " and ").concat(nextArgType, " ") + "when applying ".concat(directiveName, "."), [prevArgDef.loc, nextArgDef.loc]);
+  }
+}
+
+module.exports = joinArgumentDefinitions;