relay-compiler 9.0.0 → 10.1.0

package/transforms/GenerateTypeNameTransform.js.flow

@@ -0,0 +1,161 @@
+/**
+ * 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 generateAbstractTypeRefinementKey = require('../util/generateAbstractTypeRefinementKey');
+
+const {hasUnaliasedSelection} = require('./TransformUtils');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  Fragment,
+  InlineFragment,
+  LinkedField,
+  ScalarField,
+} from '../core/IR';
+import type {Schema} from '../core/Schema';
+
+const TYPENAME_KEY = '__typename';
+
+type State = {|
+  +typenameField: ScalarField,
+|};
+
+let cache = new Map();
+
+/**
+ * A transform that adds `__typename` field on any `LinkedField` of a union or
+ * interface type where there is no unaliased `__typename` selection.
+ */
+function generateTypeNameTransform(context: CompilerContext): CompilerContext {
+  cache = new Map();
+  const schema = context.getSchema();
+  const typenameField: ScalarField = {
+    kind: 'ScalarField',
+    alias: TYPENAME_KEY,
+    args: [],
+    directives: [],
+    handles: null,
+    loc: {kind: 'Generated'},
+    metadata: null,
+    name: TYPENAME_KEY,
+    type: schema.assertScalarFieldType(
+      schema.getNonNullType(schema.expectStringType()),
+    ),
+  };
+  return IRTransformer.transform(
+    context,
+    {
+      Fragment: visitFragment,
+      LinkedField: visitLinkedField,
+      InlineFragment: visitInlineFragment,
+    },
+    node => ({
+      typenameField,
+    }),
+  );
+}
+
+function visitFragment(fragment: Fragment, state: State): Fragment {
+  const schema: Schema = this.getContext().getSchema();
+  const rawType = schema.getRawType(fragment.type);
+  let transformedNode = (this.traverse(fragment, state): Fragment);
+  const isClientType = !schema.isServerType(rawType);
+  if (!isClientType && schema.isAbstractType(rawType)) {
+    const abstractKey = generateAbstractTypeRefinementKey(schema, rawType);
+    transformedNode = {
+      ...transformedNode,
+      selections: [
+        {
+          kind: 'ScalarField',
+          alias: abstractKey,
+          args: [],
+          directives: [],
+          handles: null,
+          loc: {kind: 'Generated'},
+          metadata: {abstractKey},
+          name: TYPENAME_KEY,
+          type: schema.assertScalarFieldType(
+            schema.getNonNullType(schema.expectStringType()),
+          ),
+        },
+        ...transformedNode.selections,
+      ],
+    };
+  }
+  return transformedNode;
+}
+
+function visitInlineFragment(
+  fragment: InlineFragment,
+  state: State,
+): InlineFragment {
+  const schema: Schema = this.getContext().getSchema();
+  let transformedNode = cache.get(fragment);
+  if (transformedNode != null && transformedNode.kind === 'InlineFragment') {
+    return transformedNode;
+  }
+  const rawType = schema.getRawType(fragment.typeCondition);
+  transformedNode = (this.traverse(fragment, state): InlineFragment);
+  const isClientType = !schema.isServerType(rawType);
+  if (!isClientType && schema.isAbstractType(rawType)) {
+    const abstractKey = generateAbstractTypeRefinementKey(schema, rawType);
+    transformedNode = {
+      ...transformedNode,
+      selections: [
+        {
+          kind: 'ScalarField',
+          alias: abstractKey,
+          args: [],
+          directives: [],
+          handles: null,
+          loc: {kind: 'Generated'},
+          metadata: {abstractKey},
+          name: TYPENAME_KEY,
+          type: schema.assertScalarFieldType(
+            schema.getNonNullType(schema.expectStringType()),
+          ),
+        },
+        ...transformedNode.selections,
+      ],
+    };
+  }
+  cache.set(fragment, transformedNode);
+  return transformedNode;
+}
+
+function visitLinkedField(field: LinkedField, state: State): LinkedField {
+  const schema: Schema = this.getContext().getSchema();
+  let transformedNode = cache.get(field);
+  if (transformedNode != null && transformedNode.kind === 'LinkedField') {
+    return transformedNode;
+  }
+  transformedNode = (this.traverse(field, state): LinkedField);
+  if (
+    schema.isAbstractType(schema.getRawType(transformedNode.type)) &&
+    !hasUnaliasedSelection(transformedNode, TYPENAME_KEY)
+  ) {
+    transformedNode = {
+      ...transformedNode,
+      selections: [state.typenameField, ...transformedNode.selections],
+    };
+  }
+  cache.set(field, transformedNode);
+  return transformedNode;
+}
+
+module.exports = {
+  transform: generateTypeNameTransform,
+};

package/transforms/InlineDataFragmentTransform.js.flow

@@ -0,0 +1,125 @@
+/**
+ * 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 {createUserError} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  Fragment,
+  FragmentSpread,
+  InlineDataFragmentSpread,
+} from '../core/IR';
+
+const SCHEMA_EXTENSION = `
+directive @inline on FRAGMENT_DEFINITION
+`;
+
+/**
+ * A transform that converts fragment spreads where the referenced fragment
+ * is annotated with @inline to a InlineDataFragmentSpread.
+ * InlineDataFragmentSpreads have the selections of the referenced fragment inlined.
+ */
+function inlineDataFragmentTransform(
+  context: CompilerContext,
+): CompilerContext {
+  return IRTransformer.transform(context, {
+    // $FlowFixMe[prop-missing] - this visitor intentionally changes node types
+    // $FlowFixMe[incompatible-call] - this visitor intentionally changes node types
+    FragmentSpread: visitFragmentSpread,
+    Fragment: visitFragment,
+  });
+}
+
+function visitFragment(fragment: Fragment): Fragment {
+  const transformedFragment = this.traverse(fragment);
+
+  const inlineDirective = transformedFragment.directives.find(
+    directive => directive.name === 'inline',
+  );
+  if (inlineDirective == null) {
+    return transformedFragment;
+  }
+  return {
+    ...transformedFragment,
+    directives: transformedFragment.directives.filter(
+      directive => directive !== inlineDirective,
+    ),
+    metadata: {
+      ...(transformedFragment.metadata || {}),
+      inlineData: true,
+    },
+  };
+}
+
+function visitFragmentSpread(
+  fragmentSpread: FragmentSpread,
+): FragmentSpread | InlineDataFragmentSpread {
+  const transformedFragmentSpread: FragmentSpread = this.traverse(
+    fragmentSpread,
+  );
+
+  const context: CompilerContext = this.getContext();
+  const fragment = context.get(transformedFragmentSpread.name);
+  if (
+    !fragment ||
+    fragment.kind !== 'Fragment' ||
+    !fragment.directives.some(directive => directive.name === 'inline')
+  ) {
+    return transformedFragmentSpread;
+  }
+
+  if (
+    fragment.argumentDefinitions.length > 0 ||
+    transformedFragmentSpread.args.length > 0
+  ) {
+    throw createUserError(
+      'Variables are not yet supported inside @inline fragments.',
+      [fragment.argumentDefinitions[0].loc],
+    );
+  }
+
+  if (transformedFragmentSpread.directives.length > 0) {
+    throw createUserError(
+      'Directives on fragment spreads for @inline fragments are not yet ' +
+        'supported',
+      [transformedFragmentSpread.loc],
+    );
+  }
+
+  const transformedFragment = (this.visit(fragment): Fragment);
+
+  return ({
+    kind: 'InlineDataFragmentSpread',
+    loc: transformedFragmentSpread.loc,
+    metadata: transformedFragmentSpread.metadata,
+    name: transformedFragmentSpread.name,
+    selections: [
+      {
+        directives: [],
+        kind: 'InlineFragment',
+        loc: {kind: 'Derived', source: transformedFragmentSpread.loc},
+        metadata: null,
+        selections: transformedFragment.selections,
+        typeCondition: transformedFragment.type,
+      },
+    ],
+  }: InlineDataFragmentSpread);
+}
+
+module.exports = {
+  SCHEMA_EXTENSION,
+  transform: inlineDataFragmentTransform,
+};

package/transforms/InlineFragmentsTransform.js.flow

@@ -0,0 +1,71 @@
+/**
+ * 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 {InlineFragment, Fragment, FragmentSpread} from '../core/IR';
+
+type FragmentVisitorCache = Map<FragmentSpread, FragmentSpread>;
+type FragmentVisitor = (fragmentSpread: FragmentSpread) => ?FragmentSpread;
+/**
+ * A transform that inlines all fragments and removes them.
+ */
+function inlineFragmentsTransform(context: CompilerContext): CompilerContext {
+  const visitFragmentSpread = fragmentSpreadVisitor(new Map());
+  return IRTransformer.transform(context, {
+    Fragment: visitFragment,
+    FragmentSpread: visitFragmentSpread,
+  });
+}
+
+function visitFragment(fragment: Fragment): null {
+  return null;
+}
+
+function fragmentSpreadVisitor(cache: FragmentVisitorCache): FragmentVisitor {
+  return function visitFragmentSpread(fragmentSpread: FragmentSpread) {
+    let traverseResult = cache.get(fragmentSpread);
+    if (traverseResult != null) {
+      return traverseResult;
+    }
+    invariant(
+      fragmentSpread.args.length === 0,
+      'InlineFragmentsTransform: Cannot flatten fragment spread `%s` with ' +
+        'arguments. Use the `ApplyFragmentArgumentTransform` before flattening',
+      fragmentSpread.name,
+    );
+    const fragment: Fragment = this.getContext().getFragment(
+      fragmentSpread.name,
+      fragmentSpread.loc,
+    );
+    const result: InlineFragment = {
+      kind: 'InlineFragment',
+      directives: fragmentSpread.directives,
+      loc: {kind: 'Derived', source: fragmentSpread.loc},
+      metadata: fragmentSpread.metadata,
+      selections: fragment.selections,
+      typeCondition: fragment.type,
+    };
+    traverseResult = this.traverse(result);
+    cache.set(fragmentSpread, traverseResult);
+    return traverseResult;
+  };
+}
+
+module.exports = {
+  transform: inlineFragmentsTransform,
+};

package/transforms/MaskTransform.js.flow

@@ -0,0 +1,126 @@
+/**
+ * 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');
+const joinArgumentDefinitions = require('../util/joinArgumentDefinitions');
+
+const {createUserError} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  Fragment,
+  FragmentSpread,
+  InlineFragment,
+  ArgumentDefinition,
+} from '../core/IR';
+
+type State = {reachableArguments: Array<ArgumentDefinition>, ...};
+
+/**
+ * A transform that inlines fragment spreads with the @relay(mask: false)
+ * directive.
+ */
+function maskTransform(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(
+    context,
+    {
+      FragmentSpread: visitFragmentSpread,
+      Fragment: visitFragment,
+    },
+    () => ({
+      reachableArguments: [],
+    }),
+  );
+}
+
+function visitFragment(fragment: Fragment, state: State): Fragment {
+  const result = this.traverse(fragment, state);
+  if (state.reachableArguments.length === 0) {
+    return result;
+  }
+  const joinedArgumentDefinitions = joinArgumentDefinitions(
+    this.getContext().getSchema(),
+    fragment,
+    state.reachableArguments,
+    '@relay(unmask: true)',
+  );
+  return {
+    ...result,
+    argumentDefinitions: joinedArgumentDefinitions,
+  };
+}
+
+function visitFragmentSpread(
+  fragmentSpread: FragmentSpread,
+  state: State,
+): FragmentSpread {
+  if (!isUnmaskedSpread(fragmentSpread)) {
+    return fragmentSpread;
+  }
+  invariant(
+    fragmentSpread.args.length === 0,
+    'MaskTransform: Cannot unmask fragment spread `%s` with ' +
+      'arguments. Use the `ApplyFragmentArgumentTransform` before flattening',
+    fragmentSpread.name,
+  );
+  const context = this.getContext();
+  const fragment: Fragment = context.getFragment(fragmentSpread.name);
+  const result: InlineFragment = {
+    kind: 'InlineFragment',
+    directives: fragmentSpread.directives,
+    loc: {kind: 'Derived', source: fragmentSpread.loc},
+    metadata: fragmentSpread.metadata,
+    selections: fragment.selections,
+    typeCondition: fragment.type,
+  };
+
+  if (fragment.directives.length > 0) {
+    throw new createUserError(
+      'Cannot use @relay(mask: false) on fragment spreads for fragments ' +
+        'with directives.',
+      [fragmentSpread.loc, fragment.directives[0].loc],
+    );
+  }
+
+  const localArgDef = fragment.argumentDefinitions.find(
+    argDef => argDef.kind === 'LocalArgumentDefinition',
+  );
+  if (localArgDef != null) {
+    throw createUserError(
+      'MaskTransform: Cannot use @relay(mask: false) on fragment spread ' +
+        'because the fragment definition uses @argumentDefinitions.',
+      [fragmentSpread.loc, localArgDef.loc],
+    );
+  }
+
+  // Note: defer validating arguments to the containing fragment in order
+  // to list all invalid variables/arguments instead of only one.
+  for (const argDef of fragment.argumentDefinitions) {
+    state.reachableArguments.push(argDef);
+  }
+  return this.traverse(result, state);
+}
+
+/**
+ * @private
+ */
+function isUnmaskedSpread(spread: FragmentSpread): boolean {
+  return Boolean(spread.metadata && spread.metadata.mask === false);
+}
+
+module.exports = {
+  transform: maskTransform,
+};