relay-compiler 8.0.0 → 10.0.1

package/transforms/query-generators/utils.js.flow

@@ -0,0 +1,76 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {
+  ArgumentDefinition,
+  Fragment,
+  FragmentSpread,
+  LocalArgumentDefinition,
+} from '../../core/IR';
+
+function buildFragmentSpread(fragment: Fragment): FragmentSpread {
+  const args = [];
+  for (const argDef of fragment.argumentDefinitions) {
+    if (argDef.kind !== 'LocalArgumentDefinition') {
+      continue;
+    }
+    args.push({
+      kind: 'Argument',
+      loc: {kind: 'Derived', source: argDef.loc},
+      name: argDef.name,
+      type: argDef.type,
+      value: {
+        kind: 'Variable',
+        loc: {kind: 'Derived', source: argDef.loc},
+        variableName: argDef.name,
+        type: argDef.type,
+      },
+    });
+  }
+  return {
+    args,
+    directives: [],
+    kind: 'FragmentSpread',
+    loc: {kind: 'Derived', source: fragment.loc},
+    metadata: null,
+    name: fragment.name,
+  };
+}
+
+function buildOperationArgumentDefinitions(
+  argumentDefinitions: $ReadOnlyArray<ArgumentDefinition>,
+): $ReadOnlyArray<LocalArgumentDefinition> {
+  const localArgumentDefinitions = argumentDefinitions.map(argDef => {
+    if (argDef.kind === 'LocalArgumentDefinition') {
+      return argDef;
+    } else {
+      return {
+        kind: 'LocalArgumentDefinition',
+        name: argDef.name,
+        type: argDef.type,
+        defaultValue: null,
+        loc: argDef.loc,
+      };
+    }
+  });
+  localArgumentDefinitions.sort((a, b) => {
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+  });
+  return localArgumentDefinitions;
+}
+
+module.exports = {
+  buildFragmentSpread,
+  buildOperationArgumentDefinitions,
+};

package/util/CodeMarker.js.flow

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * Marks a string of code as code to be replaced later.
+ */
+function moduleDependency(code: string): string {
+  return `@@MODULE_START@@${code}@@MODULE_END@@`;
+}
+
+/**
+ * After JSON.stringify'ing some code that contained parts marked with `mark()`,
+ * this post-processes the JSON to convert the marked code strings to raw code.
+ *
+ * Example:
+ *   CodeMarker.postProcess(
+ *     JSON.stringify({code: CodeMarker.mark('alert(1)')})
+ *   )
+ */
+function postProcess(json: string, printModule: string => string): string {
+  return json.replace(
+    /"@@MODULE_START@@(.*?)@@MODULE_END@@"/g,
+    (_, moduleName) => printModule(moduleName),
+  );
+}
+
+/**
+ * Transforms a value such that any transitive CodeMarker strings are replaced
+ * with the value of the named module in the given module map.
+ */
+function transform(node: mixed, moduleMap: {[string]: mixed, ...}): mixed {
+  if (node == null) {
+    return node;
+  } else if (Array.isArray(node)) {
+    return node.map(item => transform(item, moduleMap));
+  } else if (typeof node === 'object') {
+    const next = {};
+    Object.keys(node).forEach(key => {
+      next[key] = transform(node[key], moduleMap);
+    });
+    return next;
+  } else if (typeof node === 'string') {
+    const match = /^@@MODULE_START@@(.*?)@@MODULE_END@@$/.exec(node);
+    if (match != null) {
+      const moduleName = match[1];
+      if (moduleMap.hasOwnProperty(moduleName)) {
+        return moduleMap[moduleName];
+      } else {
+        throw new Error(
+          `Could not find a value for CodeMarker value '${moduleName}', ` +
+            'make sure to supply one in the module mapping.',
+        );
+      }
+    } else if (node.indexOf('@@MODULE_START') >= 0) {
+      throw new Error(`Found unprocessed CodeMarker value '${node}'.`);
+    }
+    return node;
+  } else {
+    // mixed
+    return node;
+  }
+}
+
+module.exports = {
+  moduleDependency,
+  postProcess,
+  transform,
+};

package/{lib/core/GraphQLIR.js → util/DefaultHandleKey.js.flow}

@@ -4,7 +4,14 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * 
+ * @flow strict
  * @format
  */
-'use strict';
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+module.exports = {
+  DEFAULT_HANDLE_KEY: '',
+};

package/util/RelayCompilerCache.js.flow

@@ -0,0 +1,88 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const Profiler = require('../core/GraphQLCompilerProfiler');
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+/**
+ * A file backed cache. Values are JSON encoded on disk, so only JSON
+ * serializable values should be used.
+ */
+class RelayCompilerCache<T> {
+  _name: string;
+  _cacheBreaker: string;
+  _dir: ?string = null;
+
+  /**
+   * @param name         Human readable identifier for the cache
+   * @param cacheBreaker This should be changed in order to invalidate existing
+   *                     caches.
+   */
+  constructor(name: string, cacheBreaker: string) {
+    this._name = name;
+    this._cacheBreaker = cacheBreaker;
+  }
+
+  _getFile(key: string): string {
+    if (this._dir == null) {
+      // Include username in the cache dir to avoid issues with directories being
+      // owned by a different user.
+      const username = os.userInfo().username;
+      const cacheID = crypto
+        .createHash('md5')
+        .update(this._cacheBreaker)
+        .update(username)
+        .digest('hex');
+      const dir = path.join(os.tmpdir(), `${this._name}-${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);
+  }
+
+  getOrCompute(key: string, compute: () => T): T {
+    return Profiler.run('RelayCompilerCache.getOrCompute', () => {
+      const cacheFile = this._getFile(key);
+      if (fs.existsSync(cacheFile)) {
+        try {
+          return JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        } catch {
+          // ignore
+        }
+      }
+      const value = compute();
+      try {
+        // $FlowFixMe[incompatible-call] JSON.stringify can return undefined
+        fs.writeFileSync(cacheFile, JSON.stringify(value), 'utf8');
+      } catch {
+        // ignore
+      }
+      return value;
+    });
+  }
+}
+
+module.exports = RelayCompilerCache;

package/util/Rollout.js.flow

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+let whitelistsByProject: ?Map<string, Set<string>> = null;
+
+/**
+ * This module helps gradually rolling out changes to the code generation by
+ * gradually enabling more buckets representing randomly distributed artifacts.
+ */
+function set(newWhitelistsByProject: Map<string, Set<string>>) {
+  whitelistsByProject = newWhitelistsByProject;
+}
+
+function check(project: string, key: string): boolean {
+  if (whitelistsByProject == null) {
+    return true;
+  }
+  const whitelist = whitelistsByProject.get(project);
+  if (whitelist == null) {
+    return true;
+  }
+  return whitelist.has(key);
+}
+
+module.exports = {
+  set,
+  check,
+};

package/util/TimeReporter.js.flow

@@ -0,0 +1,79 @@
+/**
+ * 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
+ * @flow strict-local
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {isPromise} = require('relay-runtime');
+
+import type {Reporter} from '../reporters/Reporter';
+
+function reportTime<T>(reporter: Reporter, message: string, fn: () => T): T {
+  return reportAndReturnTime(reporter, message, fn)[0];
+}
+
+function reportAndReturnTime<T>(
+  reporter: Reporter,
+  message: string,
+  fn: () => T,
+): [T, number] {
+  const startTime = Date.now();
+  const result = fn();
+  if (isPromise(result)) {
+    throw new Error(
+      'reportAndReturnTime: fn(...) returned an unexpected promise.' +
+        ' Please use `reportAndReturnAsyncTime` method instead.',
+    );
+  }
+  const elapsedTime = Date.now() - startTime;
+  reporter.reportTime(message, elapsedTime);
+  return [result, elapsedTime];
+}
+
+async function reportAndReturnAsyncTime<T>(
+  reporter: Reporter,
+  message: string,
+  fn: () => ?Promise<T>,
+): Promise<[T, number]> {
+  const startTime = Date.now();
+  const promise = fn();
+  if (!isPromise(promise)) {
+    throw new Error('reportAsyncTime: fn(...) expected to return a promise.');
+  }
+  const result = await promise;
+  const elapsedTime = Date.now() - startTime;
+  reporter.reportTime(message, elapsedTime);
+  return [result, elapsedTime];
+}
+
+async function reportAsyncTime<T>(
+  reporter: Reporter,
+  message: string,
+  fn: () => ?Promise<T>,
+): Promise<T> {
+  const startTime = Date.now();
+  const promise = fn();
+  if (!isPromise(promise)) {
+    throw new Error('reportAsyncTime: fn(...) expected to return a promise.');
+  }
+  const result = await promise;
+  const elapsedTime = Date.now() - startTime;
+  reporter.reportTime(message, elapsedTime);
+  return result;
+}
+
+module.exports = {
+  reportTime,
+  reportAndReturnTime,
+  reportAsyncTime,
+  reportAndReturnAsyncTime,
+};

package/util/areEqualOSS.js.flow

@@ -0,0 +1,123 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+'use strict';
+
+const aStackPool = [];
+const 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 areEqual(a: any, b: any): boolean {
+  const aStack = aStackPool.length ? aStackPool.pop() : [];
+  const bStack = bStackPool.length ? bStackPool.pop() : [];
+  const result = eq(a, b, aStack, bStack);
+  aStack.length = 0;
+  bStack.length = 0;
+  aStackPool.push(aStack);
+  bStackPool.push(bStack);
+  return result;
+}
+
+function eq(a: any, b: any, aStack: Array<any>, bStack: Array<any>): boolean {
+  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;
+  }
+  const objToStr = Object.prototype.toString;
+  const 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.
+  let length = aStack.length;
+  while (length--) {
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    }
+  }
+  aStack.push(a);
+  bStack.push(b);
+  let 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();
+    }
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
+    for (let 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
+        // areEqual. 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 = areEqual;

package/util/argumentContainsVariables.js.flow

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {ReaderArgument, NormalizationArgument} from 'relay-runtime';
+
+function argumentContainsVariables(
+  arg: ?(ReaderArgument | NormalizationArgument),
+): boolean {
+  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: empty);
+      return false;
+  }
+}
+
+module.exports = argumentContainsVariables;

package/util/dedupeJSONStringify.js.flow

@@ -0,0 +1,152 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @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: mixed): string {
+  const metadataForHash = new Map();
+  const metadataForVal = new WeakMap();
+  const varDefs = [];
+  collectMetadata(jsonValue);
+  collectDuplicates(jsonValue);
+  const code = printJSCode(false, '', jsonValue);
+  return varDefs.length === 0
+    ? code
+    : `(function(){\nvar ${varDefs.join(',\n')};\nreturn ${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): string {
+    if (value == null || typeof value !== 'object') {
+      // $FlowFixMe[incompatible-return] - JSON.stringify can return undefined
+      return JSON.stringify(value);
+    }
+    let hash;
+    if (Array.isArray(value)) {
+      hash = '[';
+      for (let i = 0; i < value.length; i++) {
+        hash += collectMetadata(value[i]) + ',';
+      }
+    } else {
+      hash = '{';
+      for (const k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          hash += k + ':' + collectMetadata(value[k]) + ',';
+        }
+      }
+    }
+    let metadata = metadataForHash.get(hash);
+    if (!metadata) {
+      metadata = ({value, hash, count: 0}: {|
+        value: mixed,
+        hash: string,
+        count: number,
+        varName?: string,
+      |});
+      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;
+    }
+    const 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 (let i = 0; i < value.length; i++) {
+        collectDuplicates(value[i]);
+      }
+    } else {
+      for (const 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): string {
+    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 !== '') {
+      const metadata = metadataForVal.get(value);
+      if (metadata && metadata.count > 1) {
+        let varName = metadata.varName;
+        if (varName == null) {
+          const refCode = printJSCode(true, '', value);
+          varName = metadata.varName = 'v' + varDefs.length;
+          varDefs.push(metadata.varName + ' = ' + refCode);
+        }
+        return '(' + varName + '/*: any*/)';
+      }
+    }
+    let str;
+    let isEmpty = true;
+    const 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 (let i = 0; i < value.length; i++) {
+        str +=
+          (isEmpty ? '\n' : ',\n') +
+          depth2 +
+          printJSCode(isDupedVar, depth2, value[i]);
+        isEmpty = false;
+      }
+      str += isEmpty ? ']' : `\n${depth}]`;
+    } else {
+      str = '{';
+      for (const 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${depth}}`;
+    }
+    return str;
+  }
+}
+
+module.exports = dedupeJSONStringify;