relay-compiler 0.0.0-main-f0b65f0b → 0.0.0-main-e0026a71

package/transforms/FilterDirectivesTransform.js.flow

@@ -1,45 +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 {Directive} from '../core/IR';
-
-const IRTransformer = require('../core/IRTransformer');
-
-/**
- * A transform that removes any directives that were not present in the
- * server schema.
- */
-function filterDirectivesTransform(context: CompilerContext): CompilerContext {
-  const schemaDirectives = new Set(
-    context
-      .getSchema()
-      .getDirectives()
-      .filter(directive => !directive.isClient)
-      .map(schemaDirective => schemaDirective.name),
-  );
-  const visitDirective = (directive: Directive): ?Directive => {
-    if (schemaDirectives.has(directive.name)) {
-      return directive;
-    }
-    return null;
-  };
-  return IRTransformer.transform(context, {
-    Directive: visitDirective,
-  });
-}
-
-module.exports = {
-  transform: filterDirectivesTransform,
-};

package/transforms/FlattenTransform.js.flow

@@ -1,458 +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
- * @flow
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type CompilerContext from '../core/CompilerContext';
-import type {
-  Argument,
-  Field,
-  Handle,
-  InlineFragment,
-  LinkedField,
-  Node,
-  ScalarField,
-  Selection,
-} from '../core/IR';
-import type {Schema, TypeID} from '../core/Schema';
-
-const {createCompilerError, createUserError} = require('../core/CompilerError');
-const getIdentifierForSelection = require('../core/getIdentifierForSelection');
-const IRTransformer = require('../core/IRTransformer');
-const areEqualArgValues = require('../util/areEqualArgValues');
-
-export type FlattenOptions = {|+isForCodegen?: boolean|};
-
-type State = {|
-  +isForCodegen: boolean,
-  parentType: ?TypeID,
-|};
-
-/**
- * Transform that flattens inline fragments, fragment spreads, and conditionals.
- *
- * Inline fragments are inlined (replaced with their selections) when:
- * - The fragment type matches the type of its parent, and its `isForCodegen`,
- *   or if it's for printing, there is no directive on the inline fragment.
- */
-function flattenTransformImpl(
-  context: CompilerContext,
-  options?: FlattenOptions,
-): CompilerContext {
-  const state = {
-    isForCodegen: !!(options && options.isForCodegen),
-    parentType: null,
-  };
-  const visitorFn = memoizedFlattenSelection(new Map());
-  return IRTransformer.transform(
-    context,
-    {
-      Condition: visitorFn,
-      Defer: visitorFn,
-      Fragment: visitorFn,
-      InlineDataFragmentSpread: visitorFn,
-      InlineFragment: visitorFn,
-      LinkedField: visitorFn,
-      ModuleImport: visitorFn,
-      Root: visitorFn,
-      SplitOperation: visitorFn,
-    },
-    () => state,
-  );
-}
-
-function memoizedFlattenSelection(cache: Map<Node, Map<?TypeID, any>>) {
-  return function flattenSelectionsFn<T: Node>(node: T, state: State): T {
-    const context: CompilerContext = this.getContext();
-    let nodeCache = cache.get(node);
-    if (nodeCache == null) {
-      nodeCache = new Map();
-      cache.set(node, nodeCache);
-    }
-    // Determine the current type.
-    const parentType = state.parentType;
-    const result = nodeCache.get(parentType);
-    if (result != null) {
-      return result;
-    }
-
-    const type =
-      node.kind === 'LinkedField' ||
-      node.kind === 'Fragment' ||
-      node.kind === 'Root' ||
-      node.kind === 'SplitOperation'
-        ? node.type
-        : node.kind === 'InlineFragment'
-        ? node.typeCondition
-        : parentType;
-    if (type == null) {
-      throw createCompilerError('FlattenTransform: Expected a parent type.', [
-        node.loc,
-      ]);
-    }
-
-    // Flatten the selections in this node, creating a new node with flattened
-    // selections if possible, then deeply traverse the flattened node, while
-    // keeping track of the parent type.
-    const nextSelections = new Map();
-    const hasFlattened = flattenSelectionsInto(
-      context.getSchema(),
-      nextSelections,
-      node,
-      state,
-      type,
-    );
-    const flattenedNode = hasFlattened
-      ? {...node, selections: Array.from(nextSelections.values())}
-      : node;
-    state.parentType = type;
-    const deeplyFlattenedNode = this.traverse(flattenedNode, state);
-    state.parentType = parentType;
-    nodeCache.set(parentType, deeplyFlattenedNode);
-    return deeplyFlattenedNode;
-  };
-}
-
-/**
- * @private
- */
-function flattenSelectionsInto(
-  schema: Schema,
-  flattenedSelections: Map<string, Selection>,
-  node: Node,
-  state: State,
-  type: TypeID,
-): boolean {
-  let hasFlattened = false;
-  node.selections.forEach(selection => {
-    if (
-      selection.kind === 'InlineFragment' &&
-      shouldFlattenInlineFragment(schema, selection, state, type)
-    ) {
-      hasFlattened = true;
-      flattenSelectionsInto(
-        schema,
-        flattenedSelections,
-        selection,
-        state,
-        type,
-      );
-      return;
-    }
-    const nodeIdentifier = getIdentifierForSelection(schema, selection);
-    const flattenedSelection = flattenedSelections.get(nodeIdentifier);
-    // If this selection hasn't been seen before, keep track of it.
-    if (!flattenedSelection) {
-      flattenedSelections.set(nodeIdentifier, selection);
-      return;
-    }
-    // Otherwise a similar selection exists which should be merged.
-    hasFlattened = true;
-    if (flattenedSelection.kind === 'InlineFragment') {
-      if (selection.kind !== 'InlineFragment') {
-        throw createCompilerError(
-          `FlattenTransform: Expected an InlineFragment, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      flattenedSelections.set(nodeIdentifier, {
-        ...flattenedSelection,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          selection.typeCondition,
-        ),
-      });
-    } else if (flattenedSelection.kind === 'Condition') {
-      if (selection.kind !== 'Condition') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a Condition, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      flattenedSelections.set(nodeIdentifier, {
-        ...flattenedSelection,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          type,
-        ),
-      });
-    } else if (flattenedSelection.kind === 'ClientExtension') {
-      if (selection.kind !== 'ClientExtension') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a ClientExtension, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      flattenedSelections.set(nodeIdentifier, {
-        ...flattenedSelection,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          type,
-        ),
-      });
-    } else if (flattenedSelection.kind === 'FragmentSpread') {
-      // Ignore duplicate fragment spreads.
-    } else if (flattenedSelection.kind === 'ModuleImport') {
-      if (selection.kind !== 'ModuleImport') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a ModuleImport, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      if (
-        selection.name !== flattenedSelection.name ||
-        selection.module !== flattenedSelection.module ||
-        selection.key !== flattenedSelection.key
-      ) {
-        throw createUserError(
-          'Found conflicting @module selections: use a unique alias on the ' +
-            'parent fields.',
-          [selection.loc, flattenedSelection.loc],
-        );
-      }
-      flattenedSelections.set(nodeIdentifier, {
-        ...flattenedSelection,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          type,
-        ),
-      });
-    } else if (flattenedSelection.kind === 'Defer') {
-      if (selection.kind !== 'Defer') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a Defer, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      flattenedSelections.set(nodeIdentifier, {
-        kind: 'Defer',
-        ...flattenedSelection,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          type,
-        ),
-      });
-    } else if (flattenedSelection.kind === 'Stream') {
-      if (selection.kind !== 'Stream') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a Stream, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      flattenedSelections.set(nodeIdentifier, {
-        kind: 'Stream',
-        ...flattenedSelection,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          type,
-        ),
-      });
-    } else if (flattenedSelection.kind === 'LinkedField') {
-      if (selection.kind !== 'LinkedField') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a LinkedField, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      assertUniqueArgsForAlias(selection, flattenedSelection);
-      // NOTE: not using object spread here as this code is pretty hot
-      flattenedSelections.set(nodeIdentifier, {
-        kind: 'LinkedField',
-        alias: flattenedSelection.alias,
-        args: flattenedSelection.args,
-        connection: flattenedSelection.connection || selection.connection,
-        directives: flattenedSelection.directives,
-        handles: mergeHandles(flattenedSelection, selection),
-        loc: flattenedSelection.loc,
-        metadata: flattenedSelection.metadata,
-        name: flattenedSelection.name,
-        selections: mergeSelections(
-          schema,
-          flattenedSelection,
-          selection,
-          state,
-          selection.type,
-        ),
-        type: flattenedSelection.type,
-      });
-    } else if (flattenedSelection.kind === 'ScalarField') {
-      if (selection.kind !== 'ScalarField') {
-        throw createCompilerError(
-          `FlattenTransform: Expected a ScalarField, got a '${selection.kind}'`,
-          [selection.loc],
-        );
-      }
-      assertUniqueArgsForAlias(selection, flattenedSelection);
-      if (selection.handles && selection.handles.length > 0) {
-        flattenedSelections.set(nodeIdentifier, {
-          kind: 'ScalarField',
-          ...flattenedSelection,
-          handles: mergeHandles(selection, flattenedSelection),
-        });
-      }
-    } else if (flattenedSelection.kind === 'InlineDataFragmentSpread') {
-      throw createCompilerError(
-        'FlattenTransform: did not expect an InlineDataFragmentSpread node. ' +
-          'Only expecting InlineDataFragmentSpread in reader ASTs and this ' +
-          'transform to run only on normalization ASTs.',
-        [selection.loc],
-      );
-    } else {
-      (flattenedSelection.kind: empty);
-      throw createCompilerError(
-        `FlattenTransform: Unknown kind '${flattenedSelection.kind}'`,
-      );
-    }
-  });
-  return hasFlattened;
-}
-
-/**
- * @private
- */
-function mergeSelections(
-  schema: Schema,
-  nodeA: Node,
-  nodeB: Node,
-  state: State,
-  type: TypeID,
-): $ReadOnlyArray<Selection> {
-  const flattenedSelections = new Map();
-  flattenSelectionsInto(schema, flattenedSelections, nodeA, state, type);
-  flattenSelectionsInto(schema, flattenedSelections, nodeB, state, type);
-  return Array.from(flattenedSelections.values());
-}
-
-/**
- * @private
- * TODO(T19327202) This is redundant with OverlappingFieldsCanBeMergedRule once
- * it can be enabled.
- */
-function assertUniqueArgsForAlias(field: Field, otherField: Field): void {
-  if (!areEqualFields(field, otherField)) {
-    throw createUserError(
-      'Expected all fields on the same parent with the name or alias ' +
-        `'${field.alias}' to have the same name and arguments.`,
-      [field.loc, otherField.loc],
-    );
-  }
-}
-
-/**
- * @private
- */
-function shouldFlattenInlineFragment(
-  schema: Schema,
-  fragment: InlineFragment,
-  state: State,
-  type: TypeID,
-): boolean {
-  return (
-    schema.areEqualTypes(fragment.typeCondition, schema.getRawType(type)) &&
-    (state.isForCodegen || fragment.directives.length === 0)
-  );
-}
-
-/**
- * @private
- *
- * Verify that two fields are equal in all properties other than their
- * selections.
- */
-function areEqualFields(thisField: Field, thatField: Field): boolean {
-  return (
-    thisField.kind === thatField.kind &&
-    thisField.name === thatField.name &&
-    thisField.alias === thatField.alias &&
-    areEqualArgs(thisField.args, thatField.args)
-  );
-}
-
-/**
- * Verify that two sets of arguments are equivalent - same argument names
- * and values. Notably this ignores the types of arguments and values, which
- * may not always be inferred identically.
- */
-function areEqualArgs(
-  thisArgs: $ReadOnlyArray<Argument>,
-  thatArgs: $ReadOnlyArray<Argument>,
-): boolean {
-  return (
-    thisArgs.length === thatArgs.length &&
-    thisArgs.every((thisArg, index) => {
-      const thatArg = thatArgs[index];
-      return (
-        thisArg.name === thatArg.name &&
-        thisArg.value.kind === thatArg.value.kind &&
-        (thisArg.value: any).variableName ===
-          (thatArg.value: any).variableName &&
-        areEqualArgValues(
-          (thisArg.value: any).value,
-          (thatArg.value: any).value,
-        )
-      );
-    })
-  );
-}
-
-/**
- * @private
- */
-function mergeHandles<T: LinkedField | ScalarField>(
-  nodeA: T,
-  nodeB: T,
-): ?$ReadOnlyArray<Handle> {
-  if (!nodeA.handles) {
-    return nodeB.handles;
-  }
-  if (!nodeB.handles) {
-    return nodeA.handles;
-  }
-  const uniqueItems = new Map();
-  nodeA.handles
-    // $FlowFixMe[incompatible-use]
-    .concat(nodeB.handles)
-    // $FlowFixMe[incompatible-use]
-    .forEach(item => uniqueItems.set(item.name + item.key, item));
-  // $FlowFixMe[incompatible-return]
-  return Array.from(uniqueItems.values());
-}
-
-function transformWithOptions(
-  options: FlattenOptions,
-): (context: CompilerContext) => CompilerContext {
-  return function flattenTransform(context: CompilerContext): CompilerContext {
-    return flattenTransformImpl(context, options);
-  };
-}
-
-module.exports = {
-  transformWithOptions,
-};

package/transforms/GenerateIDFieldTransform.js.flow

@@ -1,151 +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, ScalarField} from '../core/IR';
-import type {CompositeTypeID} from '../core/Schema';
-
-const IRTransformer = require('../core/IRTransformer');
-const {generateIDField} = require('../core/SchemaUtils');
-const {hasUnaliasedSelection} = require('./TransformUtils');
-
-const ID = 'id';
-const NODE_TYPE = 'Node';
-
-type State = {|
-  idFieldForType: CompositeTypeID => ScalarField,
-  idFragmentForType: CompositeTypeID => InlineFragment,
-|};
-
-/**
- * A transform that adds an `id` field on any type that has an id field but
- * where there is no unaliased `id` selection.
- */
-function generateIDFieldTransform(context: CompilerContext): CompilerContext {
-  const schema = context.getSchema();
-
-  const typeToIDField = new Map();
-  function idFieldForType(type: CompositeTypeID): ScalarField {
-    let idField = typeToIDField.get(type);
-    if (idField == null) {
-      idField = generateIDField(schema, type);
-      typeToIDField.set(type, idField);
-    }
-    return idField;
-  }
-
-  const typeToIDFragment = new Map();
-  function idFragmentForType(type: CompositeTypeID): InlineFragment {
-    let fragment = typeToIDFragment.get(type);
-    if (fragment == null) {
-      fragment = {
-        kind: 'InlineFragment',
-        directives: [],
-        loc: {kind: 'Generated'},
-        metadata: null,
-        selections: [idFieldForType(type)],
-        typeCondition: type,
-      };
-      typeToIDFragment.set(type, fragment);
-    }
-    return fragment;
-  }
-
-  const state = {
-    idFieldForType,
-    idFragmentForType,
-  };
-  return IRTransformer.transform(
-    context,
-    {
-      LinkedField: visitLinkedField,
-    },
-    () => state,
-  );
-}
-
-function visitLinkedField(field: LinkedField, state: State): LinkedField {
-  const transformedNode = this.traverse(field, state);
-
-  // If the field already has an unaliased `id` field, do nothing
-  if (hasUnaliasedSelection(field, ID)) {
-    return transformedNode;
-  }
-
-  const context: CompilerContext = this.getContext();
-  const schema = context.getSchema();
-  const unmodifiedType = schema.assertCompositeType(
-    schema.getRawType(field.type),
-  );
-
-  // If the field type has an `id` subfield add an `id` selection
-  if (
-    schema.canHaveSelections(unmodifiedType) &&
-    schema.hasId(unmodifiedType)
-  ) {
-    return {
-      ...transformedNode,
-      selections: [
-        ...transformedNode.selections,
-        state.idFieldForType(unmodifiedType),
-      ],
-    };
-  }
-
-  // If the field type is abstract, then generate a `... on Node { id }`
-  // fragment if *any* concrete type implements Node. Then generate a
-  // `... on PossibleType { id }` for every concrete type that does *not*
-  // implement `Node`
-  const nodeType = schema.getTypeFromString(NODE_TYPE);
-  if (!nodeType) {
-    return transformedNode;
-  }
-
-  const nodeInterface = schema.assertInterfaceType(nodeType);
-
-  if (schema.isAbstractType(unmodifiedType)) {
-    const selections = [...transformedNode.selections];
-    if (schema.mayImplement(unmodifiedType, nodeInterface)) {
-      selections.push(state.idFragmentForType(nodeInterface));
-    }
-    Array.from(
-      schema
-        .getPossibleTypes(schema.assertAbstractType(unmodifiedType))
-        .values(),
-    )
-      .filter(
-        concreteType =>
-          !schema.implementsInterface(
-            schema.assertCompositeType(concreteType),
-            nodeInterface,
-          ) && schema.hasId(concreteType),
-      )
-      .sort((a, b) =>
-        schema.getTypeString(a) < schema.getTypeString(b) ? -1 : 1,
-      )
-      .forEach(concreteType => {
-        selections.push(state.idFragmentForType(concreteType));
-      });
-    return {
-      ...transformedNode,
-      selections,
-    };
-  }
-
-  return transformedNode;
-}
-
-module.exports = {
-  transform: generateIDFieldTransform,
-};