@ardatan/relay-compiler 12.0.0

package/transforms/SkipRedundantNodesTransform.js.flow

@@ -0,0 +1,259 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+import type CompilerContext from '../core/CompilerContext';
+const IMap = require('immutable').Map;
+const partitionArray = require('../util/partitionArray');
+const getIdentifierForSelection = require('../core/getIdentifierForSelection');
+const invariant = require('invariant');
+
+import type {Schema} from '../core/Schema';
+
+import type {Fragment, Node, Root, SplitOperation, Selection} from '../core/IR';
+
+/**
+ * A simplified representation of a document: keys in the map are unique
+ * identifiers for the selections of a node, values are either null (for scalars)
+ * or nested maps for items with subselections (linked fields, inline fragments,
+ * etc).
+ */
+// $FlowFixMe[value-as-type]
+type SelectionMap = IMap<string, ?SelectionMap>;
+
+/**
+ * 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: CompilerContext,
+): CompilerContext {
+  return IRTransformer.transform(context, {
+    Root: visitNode,
+    SplitOperation: visitNode,
+    Fragment: visitNode,
+  });
+}
+
+let cache = new Map();
+function visitNode<T: Fragment | Root | SplitOperation>(node: T): ?T {
+  cache = new Map();
+  // $FlowFixMe[incompatible-use]
+  const context: CompilerContext = 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<T: Node>(
+  schema: Schema,
+  node: T,
+  selectionMap: SelectionMap,
+): {
+  selectionMap: SelectionMap,
+  node: ?T,
+  ...
+} {
+  // 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.
+  const isEmptySelectionMap = selectionMap.size === 0;
+  let result;
+  if (isEmptySelectionMap) {
+    // $FlowFixMe[escaped-generic]
+    result = cache.get(node);
+    if (result != null) {
+      return result;
+    }
+  }
+  const selections = [];
+  sortSelections(node.selections).forEach(selection => {
+    const 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': {
+        const 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.
+        const transformed = transformNode(
+          schema,
+          selection,
+          selectionMap.get(identifier) || selectionMap,
+        );
+        if (transformed.node) {
+          selections.push(transformed.node);
+          selectionMap = selectionMap.set(identifier, transformed.selectionMap);
+        }
+        break;
+      }
+      default:
+        (selection: empty);
+        invariant(
+          false,
+          'SkipRedundantNodesTransform: Unexpected node kind `%s`.',
+          selection.kind,
+        );
+    }
+  });
+  const nextNode: any = selections.length ? {...node, selections} : null;
+  result = {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: $ReadOnlyArray<Selection>,
+): $ReadOnlyArray<Selection> {
+  const isScalarOrLinkedField = selection =>
+    selection.kind === 'ScalarField' || selection.kind === 'LinkedField';
+  const [scalarsAndLinkedFields, rest] = partitionArray(
+    selections,
+    isScalarOrLinkedField,
+  );
+  return [...scalarsAndLinkedFields, ...rest];
+}
+
+module.exports = {
+  transform: skipRedundantNodesTransform,
+};

package/transforms/SkipSplitOperationTransform.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-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const IRTransformer = require('../core/IRTransformer');
+
+import type CompilerContext from '../core/CompilerContext';
+
+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: CompilerContext,
+): CompilerContext {
+  return IRTransformer.transform(context, {
+    SplitOperation: skipNode,
+  });
+}
+
+module.exports = {
+  transform: skipSplitOperationTransform,
+};

package/transforms/SkipUnreachableNodeTransform.js.flow

@@ -0,0 +1,149 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+const invariant = require('invariant');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {Condition, Fragment, Node, Selection} from '../core/IR';
+
+type ConditionResult = 'fail' | 'pass' | 'variable';
+
+const FAIL = 'fail';
+const PASS = 'pass';
+const 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: CompilerContext,
+): CompilerContext {
+  const fragments: Map<string, ?Fragment> = new Map();
+  const nextContext = IRTransformer.transform(context, {
+    Root: node => transformNode(context, fragments, node),
+    SplitOperation: node => transformNode(context, fragments, node),
+    // Fragments are included below where referenced.
+    // Unreferenced fragments are not included.
+    Fragment: id => null,
+  });
+  return (Array.from(fragments.values()): Array<?Fragment>).reduce(
+    (ctx: CompilerContext, fragment) => (fragment ? ctx.add(fragment) : ctx),
+    nextContext,
+  );
+}
+
+function transformNode<T: Node>(
+  context: CompilerContext,
+  fragments: Map<string, ?Fragment>,
+  node: T,
+): ?T {
+  const queue: Array<Selection> = [...node.selections];
+  let selections;
+  while (queue.length) {
+    const selection: Selection = queue.shift();
+    let nextSelection;
+    switch (selection.kind) {
+      case 'Condition':
+        const match = testCondition(selection);
+        if (match === PASS) {
+          queue.unshift(...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)) {
+          const fragment = context.getFragment(selection.name);
+          const 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':
+        invariant(
+          false,
+          'SkipUnreachableNodeTransform: Did not expect an ' +
+            'InlineDataFragmentSpread here. Only expecting ' +
+            'InlineDataFragmentSpread in reader ASTs and this transform to ' +
+            'run only on normalization ASTs.',
+        );
+      // fallthrough
+      default:
+        (selection.kind: empty);
+        invariant(
+          false,
+          'SkipUnreachableNodeTransform: Unexpected selection kind `%s`.',
+          selection.kind,
+        );
+    }
+    if (nextSelection) {
+      selections = selections || [];
+      selections.push(nextSelection);
+    }
+  }
+  if (selections) {
+    return ({
+      ...node,
+      selections,
+    }: $FlowIssue);
+  }
+  return null;
+}
+
+/**
+ * Determines whether a condition statically passes/fails or is unknown
+ * (variable).
+ */
+function testCondition(condition: Condition): ConditionResult {
+  if (condition.condition.kind === 'Variable') {
+    return VARIABLE;
+  }
+  return condition.condition.value === condition.passingValue ? PASS : FAIL;
+}
+
+module.exports = {
+  transform: skipUnreachableNodeTransform,
+};

package/transforms/SkipUnusedVariablesTransform.js.flow

@@ -0,0 +1,59 @@
+/**
+ * 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 inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {Root} from '../core/IR';
+
+/**
+ * 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: CompilerContext,
+): CompilerContext {
+  const contextWithUsedArguments = inferRootArgumentDefinitions(context);
+  return context.withMutations(ctx => {
+    let nextContext = ctx;
+    for (const node of nextContext.documents()) {
+      if (node.kind !== 'Root') {
+        continue;
+      }
+      const usedArguments = new Set(
+        contextWithUsedArguments
+          .getRoot(node.name)
+          .argumentDefinitions.map(argDef => argDef.name),
+      );
+      // Remove unused argument definitions
+      const usedArgumentDefinitions = node.argumentDefinitions.filter(argDef =>
+        usedArguments.has(argDef.name),
+      );
+      if (usedArgumentDefinitions.length !== node.argumentDefinitions.length) {
+        nextContext = nextContext.replace(
+          ({
+            ...node,
+            argumentDefinitions: usedArgumentDefinitions,
+          }: Root),
+        );
+      }
+    }
+    return nextContext;
+  });
+}
+
+module.exports = {
+  transform: skipUnusedVariablesTransform,
+};

package/transforms/SplitModuleImportTransform.js.flow

@@ -0,0 +1,101 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+const getNormalizationOperationName = require('../core/getNormalizationOperationName');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  LinkedField,
+  InlineFragment,
+  ModuleImport,
+  SplitOperation,
+} from '../core/IR';
+import type {CompositeTypeID} from '../core/Schema';
+
+type State = {|
+  parentType: CompositeTypeID,
+  splitOperations: Map<string, SplitOperation>,
+|};
+
+/**
+ * This transform creates a SplitOperation root for every ModuleImport.
+ */
+function splitMatchTransform(context: CompilerContext): CompilerContext {
+  const splitOperations = new Map();
+  const transformedContext = IRTransformer.transform(
+    context,
+    {
+      LinkedField: visitLinkedField,
+      InlineFragment: visitInlineFragment,
+      ModuleImport: visitModuleImport,
+    },
+    node => ({
+      parentType: node.type,
+      splitOperations,
+    }),
+  );
+  return transformedContext.addAll(Array.from(splitOperations.values()));
+}
+
+function visitLinkedField(field: LinkedField, state: State): LinkedField {
+  // $FlowFixMe[incompatible-use]
+  return this.traverse(field, {
+    parentType: field.type,
+    splitOperations: state.splitOperations,
+  });
+}
+
+function visitInlineFragment(
+  fragment: InlineFragment,
+  state: State,
+): InlineFragment {
+  // $FlowFixMe[incompatible-use]
+  return this.traverse(fragment, {
+    parentType: fragment.typeCondition,
+    splitOperations: state.splitOperations,
+  });
+}
+
+function visitModuleImport(node: ModuleImport, state: State): ModuleImport {
+  // 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
+  const normalizationName = getNormalizationOperationName(node.name);
+  const createdSplitOperation = state.splitOperations.get(normalizationName);
+  if (createdSplitOperation) {
+    createdSplitOperation.parentSources.add(node.sourceDocument);
+    return node;
+  }
+  // $FlowFixMe[incompatible-use]
+  const transformedNode = this.traverse(node, state);
+  const splitOperation: 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,
+};