relay-compiler 9.0.0 → 9.1.0

package/transforms/InlineDataFragmentTransform.js.flow

@@ -0,0 +1,124 @@
+/**
+ * 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 - 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,
+};