relay-compiler 0.0.0-main-4d287de9 → 0.0.0-main-9a79039d

package/transforms/SkipRedundantNodesTransform.js.flow

@@ -1,255 +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.
- *
- * @flow
- * @format
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type CompilerContext from '../core/CompilerContext';
-import type {Fragment, Node, Root, Selection, SplitOperation} from '../core/IR';
-import type {Schema} from '../core/Schema';
-
-const getIdentifierForSelection = require('../core/getIdentifierForSelection');
-const IRTransformer = require('../core/IRTransformer');
-const partitionArray = require('../util/partitionArray');
-const IMap = require('immutable').Map;
-const invariant = require('invariant');
-
-/**
- * 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();
-  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);
-  }
-  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

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

package/transforms/SkipUnreachableNodeTransform.js.flow

@@ -1,148 +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.
- *
- * @flow strict-local
- * @format
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type CompilerContext from '../core/CompilerContext';
-import type {Condition, Fragment, Node, Selection} from '../core/IR';
-
-const IRTransformer = require('../core/IRTransformer');
-const invariant = require('invariant');
-
-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

@@ -1,59 +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.
- *
- * @flow strict-local
- * @format
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type CompilerContext from '../core/CompilerContext';
-import type {Root} from '../core/IR';
-
-const 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: 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

@@ -1,97 +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.
- *
- * @flow strict-local
- * @format
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type CompilerContext from '../core/CompilerContext';
-import type {
-  InlineFragment,
-  LinkedField,
-  ModuleImport,
-  SplitOperation,
-} from '../core/IR';
-import type {CompositeTypeID} from '../core/Schema';
-
-const getNormalizationOperationName = require('../core/getNormalizationOperationName');
-const IRTransformer = require('../core/IRTransformer');
-
-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 {
-  return this.traverse(field, {
-    parentType: field.type,
-    splitOperations: state.splitOperations,
-  });
-}
-
-function visitInlineFragment(
-  fragment: InlineFragment,
-  state: State,
-): InlineFragment {
-  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;
-  }
-  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,
-};