relay-compiler 7.0.0 → 9.1.0

package/util/joinArgumentDefinitions.js.flow

@@ -0,0 +1,99 @@
+/**
+ * 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 {
+    throw createUserError(
+      'Cannot combine variables with incompatible types ' +
+        `${schema.getTypeString(prevArgDef.type)} and ${schema.getTypeString(
+          nextArgDef.type,
+        )} ` +
+        `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/transforms/ConnectionFieldTransform.js

@@ -1,275 +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 _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var IRTransformer = require('../core/GraphQLIRTransformer');
-
-var _require = require('../core/RelayCompilerError'),
-    createUserError = _require.createUserError;
-
-var _require2 = require('./ConnectionTransform'),
-    buildConnectionMetadata = _require2.buildConnectionMetadata;
-
-var _require3 = require('relay-runtime'),
-    ConnectionInterface = _require3.ConnectionInterface;
-
-var SCHEMA_EXTENSION = "\n  directive @connection_resolver(label: String!) on FIELD\n  directive @stream_connection_resolver(\n    label: String!\n    initial_count: Int!\n    if: Boolean = true\n  ) on FIELD\n";
-
-/**
- * This transform rewrites LinkedField nodes with @connection_resolver and
- * rewrites their edges/pageInfo selections to be wrapped in a Connection node.
- */
-function connectionFieldTransform(context) {
-  return IRTransformer.transform(context, {
-    Fragment: visitFragmentOrRoot,
-    LinkedField: visitLinkedField,
-    Root: visitFragmentOrRoot,
-    ScalarField: visitScalarField
-  }, function (node) {
-    return {
-      documentName: node.name,
-      labels: new Map(),
-      path: [],
-      connectionMetadata: []
-    };
-  });
-}
-
-function visitFragmentOrRoot(node, state) {
-  var transformedNode = this.traverse(node, state);
-  var connectionMetadata = state.connectionMetadata;
-
-  if (connectionMetadata.length) {
-    return (0, _objectSpread2["default"])({}, transformedNode, {
-      metadata: (0, _objectSpread2["default"])({}, transformedNode.metadata, {
-        connection: connectionMetadata
-      })
-    });
-  }
-
-  return transformedNode;
-}
-
-function visitLinkedField(field, state) {
-  var context = this.getContext();
-  var schema = context.getSchema();
-  var path = state.path.concat(field.alias);
-  var transformed = this.traverse(field, (0, _objectSpread2["default"])({}, state, {
-    path: path
-  }));
-  var connectionDirective = transformed.directives.find(function (directive) {
-    return directive.name === 'connection_resolver' || directive.name === 'stream_connection_resolver';
-  });
-
-  if (connectionDirective == null) {
-    return transformed;
-  }
-
-  if (schema.isList(schema.getNullableType(transformed.type))) {
-    throw createUserError("@connection_resolver fields must return a single value, not a list, found '" + "".concat(schema.getTypeString(transformed.type), "'"), [transformed.loc]);
-  }
-
-  var labelArg = connectionDirective.args.find(function (_ref4) {
-    var name = _ref4.name;
-    return name === 'label';
-  });
-  var label = getLiteralStringArgument(connectionDirective, 'label');
-
-  if (typeof label !== 'string' || label !== state.documentName && label.indexOf(state.documentName + '$') !== 0) {
-    var _ref;
-
-    throw createUserError('Invalid usage of @connection_resolver, expected a static string ' + "'label'. Labels may be the document name ('".concat(state.documentName, "') ") + "or be prefixed with the document name ('".concat(state.documentName, "$<name>')"), [(_ref = labelArg === null || labelArg === void 0 ? void 0 : labelArg.loc) !== null && _ref !== void 0 ? _ref : connectionDirective.loc]);
-  }
-
-  var previousDirective = state.labels.get(label);
-
-  if (previousDirective != null) {
-    var _ref2;
-
-    var prevLabelArg = previousDirective.args.find(function (_ref5) {
-      var name = _ref5.name;
-      return name === 'label';
-    });
-    var previousLocation = (_ref2 = prevLabelArg === null || prevLabelArg === void 0 ? void 0 : prevLabelArg.loc) !== null && _ref2 !== void 0 ? _ref2 : previousDirective.loc;
-
-    if (labelArg) {
-      throw createUserError('Invalid use of @connection_resolver, the provided label is ' + "not unique. Specify a unique 'label' as a literal string.", [labelArg === null || labelArg === void 0 ? void 0 : labelArg.loc, previousLocation]);
-    } else {
-      throw createUserError('Invalid use of @connection_resolver, could not generate a ' + "default label that is unique. Specify a unique 'label' " + 'as a literal string.', [connectionDirective.loc, previousLocation]);
-    }
-  }
-
-  state.labels.set(label, connectionDirective);
-  var stream = null;
-
-  if (connectionDirective.name === 'stream_connection_resolver') {
-    var initialCountArg = connectionDirective.args.find(function (arg) {
-      return arg.name === 'initial_count';
-    });
-    var ifArg = connectionDirective.args.find(function (arg) {
-      return arg.name === 'if';
-    });
-
-    if (initialCountArg == null || initialCountArg.value.kind === 'Literal' && !Number.isInteger(initialCountArg.value.value)) {
-      var _ref3;
-
-      throw createUserError("Invalid use of @connection_resolver, 'initial_count' is required " + "and must be an integer or variable of type 'Int!''.", [(_ref3 = initialCountArg === null || initialCountArg === void 0 ? void 0 : initialCountArg.loc) !== null && _ref3 !== void 0 ? _ref3 : connectionDirective.loc]);
-    }
-
-    stream = {
-      deferLabel: label,
-      initialCount: initialCountArg.value,
-      "if": ifArg != null ? ifArg.value : null,
-      streamLabel: label
-    };
-  }
-
-  var _ConnectionInterface$ = ConnectionInterface.get(),
-      EDGES = _ConnectionInterface$.EDGES,
-      PAGE_INFO = _ConnectionInterface$.PAGE_INFO;
-
-  var edgeField;
-  var pageInfoField;
-  var selections = [];
-  transformed.selections.forEach(function (selection) {
-    if (!(selection.kind === 'LinkedField' || selection.kind === 'ScalarField')) {
-      throw createUserError('Invalid use of @connection_resolver, selections on the connection ' + 'must be linked or scalar fields.', [selection.loc]);
-    }
-
-    if (selection.kind === 'LinkedField') {
-      if (selection.name === EDGES) {
-        edgeField = selection;
-      } else if (selection.name === PAGE_INFO) {
-        pageInfoField = selection;
-      } else {
-        selections.push(selection);
-      }
-    } else {
-      selections.push(selection);
-    }
-  });
-
-  if (edgeField == null || pageInfoField == null) {
-    throw createUserError("Invalid use of @connection_resolver, fields '".concat(EDGES, "' and ") + "'".concat(PAGE_INFO, "' must be  fetched."), [connectionDirective.loc]);
-  }
-
-  var connectionType = schema.getRawType(transformed.type);
-  var edgesFieldDef = schema.isObject(connectionType) ? schema.getFieldByName(schema.assertObjectType(connectionType), 'edges') : null;
-  var edgesType = edgesFieldDef != null ? schema.getRawType(schema.getFieldType(edgesFieldDef)) : null;
-  var nodeFieldDef = edgesType != null && schema.isObject(edgesType) ? schema.getFieldByName(schema.assertObjectType(edgesType), 'node') : null;
-  var nodeType = nodeFieldDef != null ? schema.getRawType(schema.getFieldType(nodeFieldDef)) : null;
-
-  if (edgesType == null || nodeType == null || !(schema.isObject(nodeType) || schema.isInterface(nodeType) || schema.isUnion(nodeType))) {
-    throw createUserError('Invalid usage of @connection_resolver, expected field to have shape ' + "'field { edges { node { ...} } }'.", [transformed.loc]);
-  }
-
-  edgeField = (0, _objectSpread2["default"])({}, edgeField, {
-    selections: [].concat((0, _toConsumableArray2["default"])(edgeField.selections), [{
-      alias: '__id',
-      args: [],
-      directives: [],
-      handles: null,
-      kind: 'ScalarField',
-      loc: edgeField.loc,
-      metadata: null,
-      name: '__id',
-      type: schema.assertScalarFieldType(schema.getNonNullType(schema.expectIdType()))
-    }, {
-      alias: 'node',
-      args: [],
-      connection: false,
-      directives: [],
-      handles: null,
-      kind: 'LinkedField',
-      loc: edgeField.loc,
-      metadata: null,
-      name: 'node',
-      selections: [{
-        alias: '__id',
-        args: [],
-        directives: [],
-        handles: null,
-        kind: 'ScalarField',
-        loc: edgeField.loc,
-        metadata: null,
-        name: '__id',
-        type: schema.assertScalarFieldType(schema.getNonNullType(schema.expectIdType()))
-      }],
-      type: schema.assertLinkedFieldType(nodeType)
-    }])
-  });
-  selections.push({
-    args: transformed.args,
-    kind: 'Connection',
-    label: label,
-    loc: transformed.loc,
-    name: transformed.name,
-    selections: [edgeField, pageInfoField],
-    stream: stream,
-    type: transformed.type
-  });
-  var connectionMetadata = buildConnectionMetadata(transformed, path, stream != null);
-  state.connectionMetadata.push(connectionMetadata);
-  return {
-    alias: transformed.alias,
-    args: transformed.args,
-    directives: transformed.directives.filter(function (directive) {
-      return directive !== connectionDirective;
-    }),
-    kind: 'ConnectionField',
-    loc: transformed.loc,
-    metadata: null,
-    name: transformed.name,
-    selections: selections,
-    type: transformed.type
-  };
-}
-
-function visitScalarField(field) {
-  var connectionDirective = field.directives.find(function (directive) {
-    return directive.name === 'connection_resolver';
-  });
-
-  if (connectionDirective != null) {
-    throw createUserError('The @connection_resolver direction is not supported on scalar fields, ' + 'only fields returning an object/interface/union', [connectionDirective.loc]);
-  }
-
-  return field;
-}
-
-function getLiteralStringArgument(directive, argName) {
-  var arg = directive.args.find(function (_ref6) {
-    var name = _ref6.name;
-    return name === argName;
-  });
-
-  if (arg == null) {
-    return null;
-  }
-
-  var value = arg.value.kind === 'Literal' ? arg.value.value : null;
-
-  if (value == null || typeof value !== 'string') {
-    throw createUserError("Expected the '".concat(argName, "' value to @").concat(directive.name, " to be a string literal if provided."), [arg.value.loc]);
-  }
-
-  return value;
-}
-
-module.exports = {
-  SCHEMA_EXTENSION: SCHEMA_EXTENSION,
-  transform: connectionFieldTransform
-};