relay-compiler 8.0.0 → 10.0.1

package/util/generateAbstractTypeRefinementKey.js.flow

@@ -0,0 +1,29 @@
+/**
+ * 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';
+
+const {createCompilerError} = require('../core/CompilerError');
+
+import type {Schema, TypeID} from '../core/Schema';
+
+function generateAbstractTypeRefinementKey(
+  schema: Schema,
+  type: TypeID,
+): string {
+  if (!schema.isAbstractType(type)) {
+    throw createCompilerError('Expected an abstract type');
+  }
+  return `__is${schema.getTypeString(type)}`;
+}
+
+module.exports = generateAbstractTypeRefinementKey;

package/util/getDefinitionNodeHash.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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 md5 = require('./md5');
+
+const {print} = require('graphql');
+
+import type {ExecutableDefinitionNode} from 'graphql';
+
+function getDefinitionNodeHash(node: ExecutableDefinitionNode): string {
+  return md5(print(node));
+}
+
+module.exports = getDefinitionNodeHash;

package/util/getModuleName.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';
+
+const path = require('path');
+
+function getModuleName(filePath: string): string {
+  // index.js -> index
+  // index.js.flow -> index.js
+  let 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
+  let 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, (match, next) =>
+    next.toUpperCase(),
+  );
+
+  return moduleName;
+}
+
+module.exports = getModuleName;

package/util/joinArgumentDefinitions.js.flow

@@ -0,0 +1,105 @@
+/**
+ * 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';
+
+const {createUserError} = require('../core/CompilerError');
+
+import type {ArgumentDefinition, Fragment} from '../core/IR';
+import type {Schema} from '../core/Schema';
+
+/**
+ * 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: Schema,
+  fragment: Fragment,
+  reachableArguments: $ReadOnlyArray<ArgumentDefinition>,
+  directiveName: string,
+): $ReadOnlyArray<ArgumentDefinition> {
+  const joinedArgumentDefinitions = new Map();
+  fragment.argumentDefinitions.forEach(prevArgDef => {
+    joinedArgumentDefinitions.set(prevArgDef.name, prevArgDef);
+  });
+  reachableArguments.forEach(nextArgDef => {
+    const prevArgDef = joinedArgumentDefinitions.get(nextArgDef.name);
+    const 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: Schema,
+  prevArgDef: ArgumentDefinition,
+  nextArgDef: ArgumentDefinition,
+  directiveName: string,
+): ArgumentDefinition {
+  if (prevArgDef.kind !== nextArgDef.kind) {
+    throw createUserError(
+      'Cannot combine global and local variables when applying ' +
+        `${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 ${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 {
+    const prevArgType =
+      prevArgDef.type != null
+        ? schema.getTypeString(prevArgDef.type)
+        : 'unknown';
+    const nextArgType =
+      nextArgDef.type != null
+        ? schema.getTypeString(nextArgDef.type)
+        : 'unknown';
+    throw createUserError(
+      'Cannot combine variables with incompatible types ' +
+        `${prevArgType} and ${nextArgType} ` +
+        `when applying ${directiveName}.`,
+      [prevArgDef.loc, nextArgDef.loc],
+    );
+  }
+}
+
+module.exports = joinArgumentDefinitions;

package/util/md5.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+function md5(str: string): string {
+  return require('crypto')
+    .createHash('md5')
+    .update(str, 'utf8')
+    .digest('hex');
+}
+
+module.exports = md5;

package/util/murmurHash.js.flow

@@ -0,0 +1,94 @@
+/**
+ * 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
+
+/**
+ * Based on implementations by Gary Court and Austin Appleby, 2011, MIT.
+ * @preserve-header
+ */
+
+'use strict';
+
+const BASE62 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+/**
+ * @param {string} key A UTF-16 or ASCII string
+ * @return {string} a base62 murmur hash
+ */
+function murmurHash(str: string): string {
+  /* eslint-disable no-bitwise */
+  const length = str.length;
+  const rem = length & 3;
+  const len = length ^ rem;
+
+  let h = 0;
+  let i = 0;
+  let k;
+
+  while (i !== len) {
+    const ch4 = str.charCodeAt(i + 3);
+
+    k =
+      str.charCodeAt(i) ^
+      (str.charCodeAt(i + 1) << 8) ^
+      (str.charCodeAt(i + 2) << 16) ^
+      ((ch4 & 0xff) << 24) ^
+      ((ch4 & 0xff00) >> 8);
+
+    i += 4;
+
+    k = (k * 0x2d51 + (k & 0xffff) * 0xcc9e0000) >>> 0;
+    k = (k << 15) | (k >>> 17);
+    k = (k * 0x3593 + (k & 0xffff) * 0x1b870000) >>> 0;
+    h ^= k;
+    h = (h << 13) | (h >>> 19);
+    h = (h * 5 + 0xe6546b64) >>> 0;
+  }
+
+  k = 0;
+  switch (rem) {
+    /* eslint-disable no-fallthrough */
+    case 3:
+      k ^= str.charCodeAt(len + 2) << 16;
+    case 2:
+      k ^= str.charCodeAt(len + 1) << 8;
+    case 1:
+      k ^= str.charCodeAt(len);
+
+      k = (k * 0x2d51 + (k & 0xffff) * 0xcc9e0000) >>> 0;
+      k = (k << 15) | (k >>> 17);
+      k = (k * 0x3593 + (k & 0xffff) * 0x1b870000) >>> 0;
+      h ^= k;
+  }
+
+  h ^= length;
+  h ^= h >>> 16;
+  h = (h * 0xca6b + (h & 0xffff) * 0x85eb0000) >>> 0;
+  h ^= h >>> 13;
+  h = (h * 0xae35 + (h & 0xffff) * 0xc2b20000) >>> 0;
+  h ^= h >>> 16;
+
+  h >>>= 0;
+
+  if (!h) {
+    return '0';
+  }
+
+  let s = '';
+  while (h) {
+    const d = h % 62;
+    s = BASE62[d] + s;
+    h = (h - d) / 62;
+  }
+  return s;
+}
+
+module.exports = murmurHash;

package/util/nullthrowsOSS.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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';
+
+function nullthrows<T>(
+  x: ?T,
+  message?: string = 'Got unexpected null or undefined',
+): T {
+  if (x == null) {
+    throw new Error(message);
+  }
+  return x;
+}
+
+module.exports = nullthrows;

package/util/orList.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const OR_LIST_MAX_LENGTH = 5;
+
+const {createCompilerError} = require('../core/CompilerError');
+
+function orList(items: $ReadOnlyArray<string>): string {
+  if (items.length === 0) {
+    throw createCompilerError('Expected an array of strings. Got empty array');
+  }
+
+  if (items.length === 1) {
+    return items[0];
+  }
+
+  if (items.length > OR_LIST_MAX_LENGTH) {
+    return items.slice(0, OR_LIST_MAX_LENGTH).join(', ') + ', ...';
+  }
+
+  const selected = items.slice();
+  const lastItem = selected.pop();
+  return selected.join(', ') + ' or ' + lastItem;
+}
+
+module.exports = orList;

package/util/partitionArray.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * Partitions an array given a predicate. All elements satisfying the predicate
+ * are part of the first returned array, and all elements that don't are in the
+ * second.
+ */
+function partitionArray<Tv>(
+  array: $ReadOnlyArray<Tv>,
+  predicate: (value: Tv) => boolean,
+): [$ReadOnlyArray<Tv>, $ReadOnlyArray<Tv>] {
+  const first = [];
+  const second = [];
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    if (predicate(item)) {
+      first.push(item);
+    } else {
+      second.push(item);
+    }
+  }
+  return [first, second];
+}
+
+module.exports = partitionArray;

package/lib/core/GraphQLCompilerContext.js

@@ -1,165 +0,0 @@
-/**
- * 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
- */
-'use strict';
-
-var Profiler = require('./GraphQLCompilerProfiler');
-
-var invariant = require("fbjs/lib/invariant");
-
-var _require = require('./RelayCompilerError'),
-    createUserError = _require.createUserError; // $FlowFixMe - immutable.js is not flow-typed
-
-
-var _require2 = require('immutable'),
-    ImmutableOrderedMap = _require2.OrderedMap;
-
-/**
- * An immutable representation of a corpus of documents being compiled together.
- * For each document, the context stores the IR and any validation errors.
- */
-var GraphQLCompilerContext =
-/*#__PURE__*/
-function () {
-  function GraphQLCompilerContext(schema) {
-    this._isMutable = false;
-    this._documents = new ImmutableOrderedMap();
-    this._withTransform = new WeakMap();
-    this._schema = schema;
-  }
-  /**
-   * Returns the documents for the context in the order they were added.
-   */
-
-
-  var _proto = GraphQLCompilerContext.prototype;
-
-  _proto.documents = function documents() {
-    return this._documents.toArray();
-  };
-
-  _proto.forEachDocument = function forEachDocument(fn) {
-    this._documents.forEach(fn);
-  };
-
-  _proto.replace = function replace(node) {
-    return this._update(this._documents.update(node.name, function (existing) {
-      !existing ? process.env.NODE_ENV !== "production" ? invariant(false, 'GraphQLCompilerContext: Expected to replace existing node %s, but ' + 'one was not found in the context.', node.name) : invariant(false) : void 0;
-      return node;
-    }));
-  };
-
-  _proto.add = function add(node) {
-    return this._update(this._documents.update(node.name, function (existing) {
-      !!existing ? process.env.NODE_ENV !== "production" ? invariant(false, 'GraphQLCompilerContext: Duplicate document named `%s`. GraphQL ' + 'fragments and roots must have unique names.', node.name) : invariant(false) : void 0;
-      return node;
-    }));
-  };
-
-  _proto.addAll = function addAll(nodes) {
-    return this.withMutations(function (mutable) {
-      return nodes.reduce(function (ctx, definition) {
-        return ctx.add(definition);
-      }, mutable);
-    });
-  }
-  /**
-   * Apply a list of compiler transforms and return a new compiler context.
-   */
-  ;
-
-  _proto.applyTransforms = function applyTransforms(transforms, reporter) {
-    var _this = this;
-
-    return Profiler.run('applyTransforms', function () {
-      return transforms.reduce(function (ctx, transform) {
-        return ctx.applyTransform(transform, reporter);
-      }, _this);
-    });
-  }
-  /**
-   * Applies a transform to this context, returning a new context.
-   *
-   * This is memoized such that applying the same sequence of transforms will
-   * not result in duplicated work.
-   */
-  ;
-
-  _proto.applyTransform = function applyTransform(transform, reporter) {
-    var transformed = this._withTransform.get(transform);
-
-    if (!transformed) {
-      var start = process.hrtime();
-      transformed = Profiler.instrument(transform)(this);
-      var delta = process.hrtime(start);
-      var deltaMs = Math.round((delta[0] * 1e9 + delta[1]) / 1e6);
-      reporter && reporter.reportTime(transform.name, deltaMs);
-
-      this._withTransform.set(transform, transformed);
-    }
-
-    return transformed;
-  };
-
-  _proto.get = function get(name) {
-    return this._documents.get(name);
-  };
-
-  _proto.getFragment = function getFragment(name, referencedFrom) {
-    var node = this._documents.get(name);
-
-    if (node == null) {
-      throw createUserError("Cannot find fragment '".concat(name, "'."), referencedFrom != null ? [referencedFrom] : null);
-    } else if (node.kind !== 'Fragment') {
-      throw createUserError("Cannot find fragment '".concat(name, "', a document with this name exists ") + 'but is not a fragment.', [node.loc, referencedFrom].filter(Boolean));
-    }
-
-    return node;
-  };
-
-  _proto.getRoot = function getRoot(name) {
-    var node = this._documents.get(name);
-
-    if (node == null) {
-      throw createUserError("Cannot find root '".concat(name, "'."));
-    } else if (node.kind !== 'Root') {
-      throw createUserError("Cannot find root '".concat(name, "', a document with this name exists but ") + 'is not a root.', [node.loc]);
-    }
-
-    return node;
-  };
-
-  _proto.remove = function remove(name) {
-    return this._update(this._documents["delete"](name));
-  };
-
-  _proto.withMutations = function withMutations(fn) {
-    var mutableCopy = this._update(this._documents.asMutable());
-
-    mutableCopy._isMutable = true;
-    var result = fn(mutableCopy);
-    result._isMutable = false;
-    result._documents = result._documents.asImmutable();
-    return this._documents === result._documents ? this : result;
-  };
-
-  _proto._update = function _update(documents) {
-    var context = this._isMutable ? this : new GraphQLCompilerContext(this.getSchema());
-    context._documents = documents;
-    return context;
-  };
-
-  _proto.getSchema = function getSchema() {
-    return this._schema;
-  };
-
-  return GraphQLCompilerContext;
-}();
-
-module.exports = GraphQLCompilerContext;