@ardatan/relay-compiler 12.0.0

package/lib/transforms/SkipRedundantNodesTransform.js

@@ -0,0 +1,255 @@
+/**
+ * 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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var IRTransformer = require('../core/IRTransformer');
+
+var IMap = require('immutable').Map;
+
+var partitionArray = require('../util/partitionArray');
+
+var getIdentifierForSelection = require('../core/getIdentifierForSelection');
+
+var invariant = require('invariant');
+
+/**
+ * A transform that removes redundant fields and fragment spreads. Redundancy is
+ * defined in this context as any selection that is guaranteed to already be
+ * fetched by an ancestor selection. This can occur in two cases:
+ *
+ * 1. Simple duplicates at the same level of the document can always be skipped:
+ *
+ * ```
+ * fragment Foo on FooType {
+ *   id
+ *   id
+ *   ...Bar
+ *   ...Bar
+ * }
+ * ```
+ *
+ * Becomes
+ *
+ * ```
+ * fragment Foo on FooType {
+ *   id
+ *   ...Bar
+ * }
+ * ```
+ *
+ * 2. Inline fragments and conditions introduce the possibility for duplication
+ * at different levels of the tree. Whenever a selection is fetched in a parent,
+ * it is redundant to also fetch it in a child:
+ *
+ * ```
+ * fragment Foo on FooType {
+ *   id
+ *   ... on OtherType {
+ *     id # 1
+ *   }
+ *   ... on FooType @include(if: $cond) {
+ *     id # 2
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```
+ * fragment Foo on FooType {
+ *   id
+ * }
+ * ```
+ *
+ * In this example:
+ * - 1 can be skipped because `id` is already fetched by the parent. Even
+ *   though the type is different (FooType/OtherType), the inline fragment
+ *   cannot match without the outer fragment matching so the outer `id` is
+ *   guaranteed to already be fetched.
+ * - 2 can be skipped for similar reasons: it doesn't matter if the condition
+ *   holds, `id` is already fetched by the parent regardless.
+ *
+ * This transform also handles more complicated cases in which selections are
+ * nested:
+ *
+ * ```
+ * fragment Foo on FooType {
+ *   a {
+ *     bb
+ *   }
+ *   ... on OtherType {
+ *     a {
+ *       bb # 1
+ *       cc
+ *     }
+ *   }
+ *  }
+ * ```
+ *
+ * Becomes
+ *
+ * ```
+ * fragment Foo on FooType {
+ *   a {
+ *     bb
+ *   }
+ *   ... on OtherType {
+ *     a {
+ *       cc
+ *     }
+ *   }
+ *  }
+ * ```
+ *
+ * 1 can be skipped because it is already fetched at the outer level.
+ */
+function skipRedundantNodesTransform(context) {
+  return IRTransformer.transform(context, {
+    Root: visitNode,
+    SplitOperation: visitNode,
+    Fragment: visitNode
+  });
+}
+
+var cache = new Map();
+
+function visitNode(node) {
+  cache = new Map(); // $FlowFixMe[incompatible-use]
+
+  var context = this.getContext();
+  return transformNode(context.getSchema(), node, new IMap()).node;
+}
+/**
+ * The most straightforward approach would be two passes: one to record the
+ * structure of the document, one to prune duplicates. This implementation uses
+ * a single pass. Selections are sorted with fields first, "conditionals"
+ * (inline fragments & conditions) last. This means that all fields that are
+ * guaranteed to be fetched are encountered prior to any duplicates that may be
+ * fetched within a conditional.
+ *
+ * Because selections fetched within a conditional are not guaranteed to be
+ * fetched in the parent, a fork of the selection map is created when entering a
+ * conditional. The sort ensures that guaranteed fields have already been seen
+ * prior to the clone.
+ */
+
+
+function transformNode(schema, node, selectionMap) {
+  // This will optimize a traversal of the same subselections.
+  // If it's the same node, and selectionMap is empty
+  // result of transformNode has to be the same.
+  var isEmptySelectionMap = selectionMap.size === 0;
+  var result;
+
+  if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
+    result = cache.get(node);
+
+    if (result != null) {
+      return result;
+    }
+  }
+
+  var selections = [];
+  sortSelections(node.selections).forEach(function (selection) {
+    var identifier = getIdentifierForSelection(schema, selection);
+
+    switch (selection.kind) {
+      case 'ScalarField':
+      case 'FragmentSpread':
+        {
+          if (!selectionMap.has(identifier)) {
+            selections.push(selection);
+            selectionMap = selectionMap.set(identifier, null);
+          }
+
+          break;
+        }
+
+      case 'Defer':
+      case 'Stream':
+      case 'ModuleImport':
+      case 'ClientExtension':
+      case 'InlineDataFragmentSpread':
+      case 'LinkedField':
+        {
+          var transformed = transformNode(schema, selection, selectionMap.get(identifier) || new IMap());
+
+          if (transformed.node) {
+            selections.push(transformed.node);
+            selectionMap = selectionMap.set(identifier, transformed.selectionMap);
+          }
+
+          break;
+        }
+
+      case 'InlineFragment':
+      case 'Condition':
+        {
+          // Fork the selection map to prevent conditional selections from
+          // affecting the outer "guaranteed" selections.
+          var _transformed = transformNode(schema, selection, selectionMap.get(identifier) || selectionMap);
+
+          if (_transformed.node) {
+            selections.push(_transformed.node);
+            selectionMap = selectionMap.set(identifier, _transformed.selectionMap);
+          }
+
+          break;
+        }
+
+      default:
+        selection;
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'SkipRedundantNodesTransform: Unexpected node kind `%s`.', selection.kind) : invariant(false) : void 0;
+    }
+  });
+  var nextNode = selections.length ? (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+    selections: selections
+  }) : null;
+  result = {
+    selectionMap: selectionMap,
+    node: nextNode
+  };
+
+  if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
+    cache.set(node, result);
+  } // $FlowFixMe[incompatible-return]
+
+
+  return result;
+}
+/**
+ * Sort inline fragments and conditions after other selections.
+ */
+
+
+function sortSelections(selections) {
+  var isScalarOrLinkedField = function isScalarOrLinkedField(selection) {
+    return selection.kind === 'ScalarField' || selection.kind === 'LinkedField';
+  };
+
+  var _partitionArray = partitionArray(selections, isScalarOrLinkedField),
+      scalarsAndLinkedFields = _partitionArray[0],
+      rest = _partitionArray[1];
+
+  return [].concat((0, _toConsumableArray2["default"])(scalarsAndLinkedFields), (0, _toConsumableArray2["default"])(rest));
+}
+
+module.exports = {
+  transform: skipRedundantNodesTransform
+};

package/lib/transforms/SkipSplitOperationTransform.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 IRTransformer = require('../core/IRTransformer');
+
+function skipNode() {
+  return null;
+}
+/**
+ * A transform that removes field `splitOperations`. Intended for use when e.g.
+ * printing queries to send to a GraphQL server.
+ */
+
+
+function skipSplitOperationTransform(context) {
+  return IRTransformer.transform(context, {
+    SplitOperation: skipNode
+  });
+}
+
+module.exports = {
+  transform: skipSplitOperationTransform
+};

package/lib/transforms/SkipUnreachableNodeTransform.js

@@ -0,0 +1,158 @@
+/**
+ * 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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var IRTransformer = require('../core/IRTransformer');
+
+var invariant = require('invariant');
+
+var FAIL = 'fail';
+var PASS = 'pass';
+var VARIABLE = 'variable';
+/**
+ * A tranform that removes unreachable IR nodes from all documents in a corpus.
+ * The following nodes are removed:
+ * - Any node with `@include(if: false)`
+ * - Any node with `@skip(if: true)`
+ * - Any node with empty `selections`
+ */
+
+function skipUnreachableNodeTransform(context) {
+  var fragments = new Map();
+  var nextContext = IRTransformer.transform(context, {
+    Root: function Root(node) {
+      return transformNode(context, fragments, node);
+    },
+    SplitOperation: function SplitOperation(node) {
+      return transformNode(context, fragments, node);
+    },
+    // Fragments are included below where referenced.
+    // Unreferenced fragments are not included.
+    Fragment: function Fragment(id) {
+      return null;
+    }
+  });
+  return Array.from(fragments.values()).reduce(function (ctx, fragment) {
+    return fragment ? ctx.add(fragment) : ctx;
+  }, nextContext);
+}
+
+function transformNode(context, fragments, node) {
+  var queue = (0, _toConsumableArray2["default"])(node.selections);
+  var selections;
+
+  while (queue.length) {
+    var selection = queue.shift();
+    var nextSelection = void 0;
+
+    switch (selection.kind) {
+      case 'Condition':
+        var match = testCondition(selection);
+
+        if (match === PASS) {
+          queue.unshift.apply(queue, (0, _toConsumableArray2["default"])(selection.selections));
+        } else if (match === VARIABLE) {
+          nextSelection = transformNode(context, fragments, selection);
+        }
+
+        break;
+
+      case 'FragmentSpread':
+        {
+          // Skip fragment spreads if the referenced fragment is empty
+          if (!fragments.has(selection.name)) {
+            var fragment = context.getFragment(selection.name);
+            var nextFragment = transformNode(context, fragments, fragment);
+            fragments.set(selection.name, nextFragment);
+          }
+
+          if (fragments.get(selection.name)) {
+            nextSelection = selection;
+          }
+
+          break;
+        }
+
+      case 'ClientExtension':
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+
+      case 'ModuleImport':
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+
+      case 'LinkedField':
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+
+      case 'InlineFragment':
+        // TODO combine with the LinkedField case when flow supports this
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+
+      case 'Defer':
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+
+      case 'Stream':
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+
+      case 'ScalarField':
+        nextSelection = selection;
+        break;
+
+      case 'InlineDataFragmentSpread':
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'SkipUnreachableNodeTransform: Did not expect an ' + 'InlineDataFragmentSpread here. Only expecting ' + 'InlineDataFragmentSpread in reader ASTs and this transform to ' + 'run only on normalization ASTs.') : invariant(false) : void 0;
+      // fallthrough
+
+      default:
+        selection.kind;
+        !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'SkipUnreachableNodeTransform: Unexpected selection kind `%s`.', selection.kind) : invariant(false) : void 0;
+    }
+
+    if (nextSelection) {
+      selections = selections || [];
+      selections.push(nextSelection);
+    }
+  }
+
+  if (selections) {
+    return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+      selections: selections
+    });
+  }
+
+  return null;
+}
+/**
+ * Determines whether a condition statically passes/fails or is unknown
+ * (variable).
+ */
+
+
+function testCondition(condition) {
+  if (condition.condition.kind === 'Variable') {
+    return VARIABLE;
+  }
+
+  return condition.condition.value === condition.passingValue ? PASS : FAIL;
+}
+
+module.exports = {
+  transform: skipUnreachableNodeTransform
+};

package/lib/transforms/SkipUnusedVariablesTransform.js

@@ -0,0 +1,74 @@
+/**
+ * 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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
+
+/**
+ * Refines the argument definitions for operations to remove unused arguments
+ * due to statically pruned conditional branches (e.g. because of overriding
+ * a variable used in `@include()` to be false).
+ */
+function skipUnusedVariablesTransform(context) {
+  var contextWithUsedArguments = inferRootArgumentDefinitions(context);
+  return context.withMutations(function (ctx) {
+    var nextContext = ctx;
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(nextContext.documents()),
+        _step;
+
+    try {
+      var _loop = function _loop() {
+        var node = _step.value;
+
+        if (node.kind !== 'Root') {
+          return "continue";
+        }
+
+        var usedArguments = new Set(contextWithUsedArguments.getRoot(node.name).argumentDefinitions.map(function (argDef) {
+          return argDef.name;
+        })); // Remove unused argument definitions
+
+        var usedArgumentDefinitions = node.argumentDefinitions.filter(function (argDef) {
+          return usedArguments.has(argDef.name);
+        });
+
+        if (usedArgumentDefinitions.length !== node.argumentDefinitions.length) {
+          nextContext = nextContext.replace((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+            argumentDefinitions: usedArgumentDefinitions
+          }));
+        }
+      };
+
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _ret = _loop();
+
+        if (_ret === "continue") continue;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return nextContext;
+  });
+}
+
+module.exports = {
+  transform: skipUnusedVariablesTransform
+};

package/lib/transforms/SplitModuleImportTransform.js

@@ -0,0 +1,85 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+var getNormalizationOperationName = require('../core/getNormalizationOperationName');
+
+/**
+ * This transform creates a SplitOperation root for every ModuleImport.
+ */
+function splitMatchTransform(context) {
+  var splitOperations = new Map();
+  var transformedContext = IRTransformer.transform(context, {
+    LinkedField: visitLinkedField,
+    InlineFragment: visitInlineFragment,
+    ModuleImport: visitModuleImport
+  }, function (node) {
+    return {
+      parentType: node.type,
+      splitOperations: splitOperations
+    };
+  });
+  return transformedContext.addAll(Array.from(splitOperations.values()));
+}
+
+function visitLinkedField(field, state) {
+  // $FlowFixMe[incompatible-use]
+  return this.traverse(field, {
+    parentType: field.type,
+    splitOperations: state.splitOperations
+  });
+}
+
+function visitInlineFragment(fragment, state) {
+  // $FlowFixMe[incompatible-use]
+  return this.traverse(fragment, {
+    parentType: fragment.typeCondition,
+    splitOperations: state.splitOperations
+  });
+}
+
+function visitModuleImport(node, state) {
+  // It's possible for the same fragment to be selected in multiple usages
+  // of @module: skip processing a node if its SplitOperation has already
+  // been generated
+  var normalizationName = getNormalizationOperationName(node.name);
+  var createdSplitOperation = state.splitOperations.get(normalizationName);
+
+  if (createdSplitOperation) {
+    createdSplitOperation.parentSources.add(node.sourceDocument);
+    return node;
+  } // $FlowFixMe[incompatible-use]
+
+
+  var transformedNode = this.traverse(node, state);
+  var splitOperation = {
+    kind: 'SplitOperation',
+    name: normalizationName,
+    selections: transformedNode.selections,
+    loc: {
+      kind: 'Derived',
+      source: node.loc
+    },
+    parentSources: new Set([node.sourceDocument]),
+    metadata: {
+      derivedFrom: transformedNode.name
+    },
+    type: state.parentType
+  };
+  state.splitOperations.set(normalizationName, splitOperation);
+  return transformedNode;
+}
+
+module.exports = {
+  transform: splitMatchTransform
+};