@ardatan/relay-compiler 12.0.0

package/lib/transforms/TestOperationTransform.js

@@ -0,0 +1,145 @@
+/**
+ * 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 _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var IRTransformer = require('../core/IRTransformer');
+
+// The purpose of this directive is to add GraphQL type inform for fields in
+// the operation selection in order to use in in RelayMockPayloadGenerator
+// to generate better mock values, and expand the API of MockResolvers
+var SCHEMA_EXTENSION = 'directive @relay_test_operation on QUERY | MUTATION | SUBSCRIPTION';
+
+function testOperationDirective(context) {
+  return IRTransformer.transform(context, {
+    Fragment: function Fragment(node) {
+      return node;
+    },
+    Root: visitRoot,
+    SplitOperation: function SplitOperation(node) {
+      return node;
+    }
+  });
+}
+
+function getTypeDetails(schema, fieldType) {
+  var nullableType = schema.getNullableType(fieldType);
+  var isNullable = !schema.isNonNull(fieldType);
+  var isPlural = schema.isList(nullableType);
+  var type = schema.getRawType(nullableType);
+  return {
+    enumValues: schema.isEnum(type) ? schema.getEnumValues(schema.assertEnumType(type)) : null,
+    nullable: isNullable,
+    plural: isPlural,
+    type: schema.getTypeString(type)
+  };
+}
+
+function visitRoot(node) {
+  // $FlowFixMe[incompatible-use]
+  var schema = this.getContext().getSchema();
+  var testDirective = node.directives.find(function (directive) {
+    return directive.name === 'relay_test_operation';
+  });
+
+  if (testDirective == null) {
+    return node;
+  }
+
+  var queue = [{
+    selections: node.selections,
+    path: null
+  }];
+  var selectionsTypeInfo = {};
+
+  var _loop = function _loop() {
+    var _queue$pop = queue.pop(),
+        currentSelections = _queue$pop.selections,
+        path = _queue$pop.path;
+
+    currentSelections.forEach(function (selection) {
+      switch (selection.kind) {
+        case 'FragmentSpread':
+          // We don't expect to have fragment spreads at this point (it's operations only transform step)
+          break;
+
+        case 'ScalarField':
+          {
+            var nextPath = path === null ? selection.alias : "".concat(path, ".").concat(selection.alias);
+            selectionsTypeInfo[nextPath] = getTypeDetails(schema, selection.type);
+            break;
+          }
+
+        case 'LinkedField':
+          {
+            var _nextPath = path === null ? selection.alias : "".concat(path, ".").concat(selection.alias);
+
+            selectionsTypeInfo[_nextPath] = getTypeDetails(schema, selection.type);
+            queue.push({
+              selections: selection.selections,
+              path: _nextPath
+            });
+            break;
+          }
+
+        case 'Condition':
+        case 'Defer':
+        case 'InlineDataFragmentSpread':
+        case 'InlineFragment':
+        case 'ModuleImport':
+        case 'Stream':
+          queue.push({
+            selections: selection.selections,
+            path: path
+          });
+          break;
+
+        case 'ClientExtension':
+          // Clinet extensions are not part of the schema. We should not generate type info.
+          break;
+
+        default:
+          selection;
+          break;
+      }
+    });
+  };
+
+  while (queue.length > 0) {
+    _loop();
+  } // Sort selectionsTypeInfo
+
+
+  var keys = Object.keys(selectionsTypeInfo).sort(function (a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+  var sortedSelectionsTypeInfo = {};
+  keys.forEach(function (key) {
+    sortedSelectionsTypeInfo[key] = selectionsTypeInfo[key];
+  });
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+    directives: node.directives.filter(function (directive) {
+      return directive !== testDirective;
+    }),
+    metadata: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node.metadata || {}), {}, {
+      relayTestingSelectionTypeInfo: sortedSelectionsTypeInfo
+    })
+  });
+}
+
+module.exports = {
+  SCHEMA_EXTENSION: SCHEMA_EXTENSION,
+  transform: testOperationDirective
+};

package/lib/transforms/TransformUtils.js

@@ -0,0 +1,21 @@
+/**
+ * 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 hasUnaliasedSelection(field, fieldName) {
+  return field.selections.some(function (selection) {
+    return selection.kind === 'ScalarField' && selection.alias === fieldName && selection.name === fieldName;
+  });
+}
+
+module.exports = {
+  hasUnaliasedSelection: hasUnaliasedSelection
+};

package/lib/transforms/ValidateGlobalVariablesTransform.js

@@ -0,0 +1,91 @@
+/**
+ * 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 _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
+
+var _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError,
+    eachWithCombinedError = _require.eachWithCombinedError;
+
+/**
+ * Validates that all global variables used in operations are defined at the
+ * root. This isn't a real transform as it returns the original context, but
+ * has to happen before other transforms strip certain variable usages.
+ */
+function validateGlobalVariablesTransform(context) {
+  var contextWithUsedArguments = inferRootArgumentDefinitions(context);
+  eachWithCombinedError(context.documents(), function (node) {
+    if (node.kind !== 'Root') {
+      return;
+    }
+
+    var nodeWithUsedArguments = contextWithUsedArguments.getRoot(node.name);
+    var definedArguments = argumentDefinitionsToMap(node.argumentDefinitions);
+    var usedArguments = argumentDefinitionsToMap(nodeWithUsedArguments.argumentDefinitions); // All used arguments must be defined
+
+    var undefinedVariables = [];
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(usedArguments.values()),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var argDef = _step.value;
+
+        if (!definedArguments.has(argDef.name)) {
+          undefinedVariables.push(argDef);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    if (undefinedVariables.length !== 0) {
+      throw createUserError("Operation '".concat(node.name, "' references undefined variable(s):\n").concat(undefinedVariables.map(function (argDef) {
+        return "- $".concat(argDef.name, ": ").concat(context.getSchema().getTypeString(argDef.type));
+      }).join('\n'), "."), undefinedVariables.map(function (argDef) {
+        return argDef.loc;
+      }));
+    }
+  });
+  return context;
+}
+
+function argumentDefinitionsToMap(argDefs) {
+  var map = new Map();
+
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(argDefs),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var argDef = _step2.value;
+      map.set(argDef.name, argDef);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return map;
+}
+
+module.exports = {
+  transform: validateGlobalVariablesTransform
+};

package/lib/transforms/ValidateRequiredArgumentsTransform.js

@@ -0,0 +1,118 @@
+/**
+ * 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 _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var IRValidator = require('../core/IRValidator');
+
+var _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+var _require2 = require('../core/getFieldDefinition'),
+    getFieldDefinitionStrict = _require2.getFieldDefinitionStrict;
+
+/*
+ * Validate required arguments are provided after transforms filling in arguments
+ */
+function validateRequiredArguments(context) {
+  IRValidator.validate(context, {
+    Directive: visitDirective,
+    InlineFragment: visitInlineFragment,
+    LinkedField: visitField,
+    ScalarField: visitField // FragmentSpread validation is done in ApplyFragmentArgumentTransform
+
+  }, function (node) {
+    return {
+      rootNode: node,
+      parentType: node.type
+    };
+  });
+  return context;
+}
+
+function visitDirective(node, _ref) {
+  var rootNode = _ref.rootNode;
+  // $FlowFixMe[incompatible-use]
+  var context = this.getContext();
+  var directiveDef = context.getSchema().getDirective(node.name);
+
+  if (directiveDef == null) {
+    return;
+  }
+
+  validateRequiredArgumentsOnNode(context.getSchema(), node, directiveDef.args, rootNode);
+}
+
+function visitInlineFragment(fragment, _ref2) {
+  var rootNode = _ref2.rootNode;
+  // $FlowFixMe[incompatible-use]
+  this.traverse(fragment, {
+    rootNode: rootNode,
+    parentType: fragment.typeCondition
+  });
+}
+
+function visitField(node, _ref3) {
+  var parentType = _ref3.parentType,
+      rootNode = _ref3.rootNode;
+  // $FlowFixMe[incompatible-use]
+  var context = this.getContext();
+  var schema = context.getSchema();
+  var definition = getFieldDefinitionStrict(schema, parentType, node.name);
+
+  if (definition == null) {
+    var isLegacyFatInterface = node.directives.some(function (directive) {
+      return directive.name === 'fixme_fat_interface';
+    });
+
+    if (!isLegacyFatInterface) {
+      throw createUserError("Unknown field '".concat(node.name, "' on type ") + "'".concat(schema.getTypeString(parentType), "'."), [node.loc]);
+    }
+  } else {
+    validateRequiredArgumentsOnNode(schema, node, schema.getFieldConfig(definition).args, rootNode);
+  } // $FlowFixMe[incompatible-use]
+
+
+  this.traverse(node, {
+    rootNode: rootNode,
+    parentType: node.type
+  });
+}
+
+function validateRequiredArgumentsOnNode(schema, node, definitionArgs, rootNode) {
+  var nodeArgsSet = new Set(node.args.map(function (arg) {
+    return arg.name;
+  }));
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(definitionArgs),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var arg = _step.value;
+
+      if (arg.defaultValue == null && schema.isNonNull(arg.type) && !nodeArgsSet.has(arg.name)) {
+        throw createUserError("Required argument '".concat(arg.name, ": ").concat(schema.getTypeString(arg.type), "' ") + "is missing on '".concat(node.name, "' in '").concat(rootNode.name, "'."), [node.loc, rootNode.loc]);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+module.exports = {
+  transform: validateRequiredArguments
+};

package/lib/transforms/ValidateServerOnlyDirectivesTransform.js

@@ -0,0 +1,111 @@
+/**
+ * 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 _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var IRValidator = require('../core/IRValidator');
+
+var _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+var NODEKIND_DIRECTIVE_MAP = {
+  Defer: 'defer',
+  Stream: 'stream'
+};
+/*
+ * Validate that server-only directives are not used inside client fields
+ */
+
+function validateServerOnlyDirectives(context) {
+  IRValidator.validate(context, {
+    ClientExtension: visitClientExtension,
+    Defer: visitTransformedDirective,
+    Stream: visitTransformedDirective,
+    LinkedField: visitLinkedField,
+    ScalarField: stopVisit
+  }, function () {
+    return {
+      rootClientSelection: null
+    };
+  });
+  return context;
+} // If an empty visitor is defined, we no longer automatically visit child nodes
+// such as arguments.
+
+
+function stopVisit() {} // Only visits selections as an optimization to not look at arguments
+
+
+function visitLinkedField(node, state) {
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(node.selections),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var selection = _step.value;
+      // $FlowFixMe[incompatible-use]
+      this.visit(selection, state);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function visitClientExtension(node, state) {
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(node.selections),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var selection = _step2.value;
+      // $FlowFixMe[incompatible-use]
+      this.visit(selection, {
+        rootClientSelection: selection
+      });
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+}
+
+function visitTransformedDirective(node, state) {
+  if (state.rootClientSelection) {
+    throwError("@".concat(NODEKIND_DIRECTIVE_MAP[node.kind]), node.loc, state.rootClientSelection.loc);
+  } // directive used only on client fields
+
+
+  if (node.selections.every(function (sel) {
+    return sel.kind === 'ClientExtension';
+  })) {
+    var _clientExtension$sele;
+
+    var clientExtension = node.selections[0];
+    throwError("@".concat(NODEKIND_DIRECTIVE_MAP[node.kind]), node.loc, clientExtension && clientExtension.kind === 'ClientExtension' ? (_clientExtension$sele = clientExtension.selections[0]) === null || _clientExtension$sele === void 0 ? void 0 : _clientExtension$sele.loc : null);
+  } // $FlowFixMe[incompatible-use]
+
+
+  this.traverse(node, state);
+}
+
+function throwError(directiveName, directiveLoc, clientExtensionLoc) {
+  throw createUserError("Unexpected directive: ".concat(directiveName, ". ") + 'This directive can only be used on fields/fragments that are ' + 'fetched from the server schema, but it is used ' + 'inside a client-only selection.', clientExtensionLoc == null || directiveLoc === clientExtensionLoc ? [directiveLoc] : [directiveLoc, clientExtensionLoc]);
+}
+
+module.exports = {
+  transform: validateServerOnlyDirectives
+};

package/lib/transforms/ValidateUnusedVariablesTransform.js

@@ -0,0 +1,96 @@
+/**
+ * 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 _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
+
+var _require = require('../core/CompilerError'),
+    createUserError = _require.createUserError,
+    eachWithCombinedError = _require.eachWithCombinedError;
+
+var SCHEMA_EXTENSION = 'directive @DEPRECATED__relay_ignore_unused_variables_error on QUERY | MUTATION | SUBSCRIPTION';
+/**
+ * Validates that there are no unused variables in the operation.
+ * former `graphql-js`` NoUnusedVariablesRule
+ */
+
+function validateUnusedVariablesTransform(context) {
+  var contextWithUsedArguments = inferRootArgumentDefinitions(context);
+  eachWithCombinedError(context.documents(), function (node) {
+    if (node.kind !== 'Root') {
+      return;
+    }
+
+    var rootArgumentLocations = new Map(node.argumentDefinitions.map(function (arg) {
+      return [arg.name, arg.loc];
+    }));
+    var nodeWithUsedArguments = contextWithUsedArguments.getRoot(node.name);
+    var usedArguments = argumentDefinitionsToMap(nodeWithUsedArguments.argumentDefinitions);
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(usedArguments.keys()),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var usedArgumentName = _step.value;
+        rootArgumentLocations["delete"](usedArgumentName);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    var ignoreErrorDirective = node.directives.find(function (_ref) {
+      var name = _ref.name;
+      return name === 'DEPRECATED__relay_ignore_unused_variables_error';
+    });
+
+    if (rootArgumentLocations.size > 0 && !ignoreErrorDirective) {
+      var isPlural = rootArgumentLocations.size > 1;
+      throw createUserError("Variable".concat(isPlural ? 's' : '', " '$").concat(Array.from(rootArgumentLocations.keys()).join("', '$"), "' ").concat(isPlural ? 'are' : 'is', " never used in operation '").concat(node.name, "'."), Array.from(rootArgumentLocations.values()));
+    }
+
+    if (rootArgumentLocations.size === 0 && ignoreErrorDirective) {
+      throw createUserError("Invalid usage of '@DEPRECATED__relay_ignore_unused_variables_error.'" + "No unused variables found in the query '".concat(node.name, "'"), [ignoreErrorDirective.loc]);
+    }
+  });
+  return context;
+}
+
+function argumentDefinitionsToMap(argDefs) {
+  var map = new Map();
+
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(argDefs),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var argDef = _step2.value;
+      map.set(argDef.name, argDef);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return map;
+}
+
+module.exports = {
+  transform: validateUnusedVariablesTransform,
+  SCHEMA_EXTENSION: SCHEMA_EXTENSION
+};