relay-compiler 7.0.0 → 9.1.0

package/core/IRVisitor.js.flow

@@ -0,0 +1,150 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {visit} = require('graphql');
+
+import type {
+  Argument,
+  ClientExtension,
+  Condition,
+  Defer,
+  Directive,
+  Fragment,
+  FragmentSpread,
+  InlineDataFragmentSpread,
+  InlineFragment,
+  LinkedField,
+  Literal,
+  LocalArgumentDefinition,
+  ModuleImport,
+  Request,
+  Root,
+  RootArgumentDefinition,
+  ScalarField,
+  SplitOperation,
+  Stream,
+  Variable,
+} from './IR';
+
+const NodeKeys = {
+  Argument: ['value'],
+  ClientExtension: ['selections'],
+  Condition: ['condition', 'selections'],
+  Defer: ['selections', 'if'],
+  Directive: ['args'],
+  Fragment: ['argumentDefinitions', 'directives', 'selections'],
+  FragmentSpread: ['args', 'directives'],
+  InlineDataFragmentSpread: ['selections'],
+  InlineFragment: ['directives', 'selections'],
+  LinkedField: ['args', 'directives', 'selections'],
+  Literal: [],
+  LocalArgumentDefinition: [],
+  ModuleImport: ['selections'],
+  Request: ['fragment', 'root'],
+  Root: ['argumentDefinitions', 'directives', 'selections'],
+  RootArgumentDefinition: [],
+  ScalarField: ['args', 'directives'],
+  SplitOperation: ['selections'],
+  Stream: ['selections', 'if', 'initialCount'],
+  Variable: [],
+};
+
+export type VisitNode =
+  | Argument
+  | ClientExtension
+  | Condition
+  | Defer
+  | Directive
+  | Fragment
+  | FragmentSpread
+  | InlineDataFragmentSpread
+  | InlineFragment
+  | LinkedField
+  | Literal
+  | LocalArgumentDefinition
+  | ModuleImport
+  | Request
+  | Root
+  | RootArgumentDefinition
+  | ScalarField
+  | SplitOperation
+  | Stream
+  | Variable;
+
+type EnterLeave<T> = {|+enter?: T, +leave?: T|};
+
+export type VisitFn<T: VisitNode> = (
+  node: T, // node we're visiting
+  key?: $FlowFixMe, // index/key to node from parent array/object
+  parent?: ?(VisitNode | Array<VisitNode>), // Object immediately above node
+  path?: Array<$FlowFixMe>, // keys to get from root: [keyForChild, ..., keyForParent]
+  ancestors?: Array<VisitNode | Array<VisitNode>>, // [root, child1, ..., grandparent]
+  // Note: ancestors includes arrays which contain the visited node
+  // These correspond to array indices in `path`.
+) => $FlowFixMe;
+
+export type NodeVisitorObject<T: VisitNode> =
+  | EnterLeave<VisitFn<T>>
+  | VisitFn<T>;
+
+export type NodeVisitor =
+  | EnterLeave<{|
+      Argument?: VisitFn<Argument>,
+      ClientExtension?: VisitFn<ClientExtension>,
+      Condition?: VisitFn<Condition>,
+      Defer?: VisitFn<Defer>,
+      Directive?: VisitFn<Directive>,
+      Fragment?: VisitFn<Fragment>,
+      FragmentSpread?: VisitFn<FragmentSpread>,
+      InlineFragment?: VisitFn<InlineFragment>,
+      LinkedField?: VisitFn<LinkedField>,
+      Literal?: VisitFn<Literal>,
+      LocalArgumentDefinition?: VisitFn<LocalArgumentDefinition>,
+      ModuleImport?: VisitFn<ModuleImport>,
+      Request?: VisitFn<Request>,
+      Root?: VisitFn<Root>,
+      RootArgumentDefinition?: VisitFn<RootArgumentDefinition>,
+      ScalarField?: VisitFn<ScalarField>,
+      SplitOperation?: VisitFn<SplitOperation>,
+      Stream?: VisitFn<Stream>,
+      Variable?: VisitFn<Variable>,
+    |}>
+  | {|
+      Argument?: NodeVisitorObject<Argument>,
+      ClientExtension?: VisitFn<ClientExtension>,
+      Condition?: NodeVisitorObject<Condition>,
+      Defer?: NodeVisitorObject<Defer>,
+      Directive?: NodeVisitorObject<Directive>,
+      Fragment?: NodeVisitorObject<Fragment>,
+      FragmentSpread?: NodeVisitorObject<FragmentSpread>,
+      InlineDataFragmentSpread?: NodeVisitorObject<InlineDataFragmentSpread>,
+      InlineFragment?: NodeVisitorObject<InlineFragment>,
+      LinkedField?: NodeVisitorObject<LinkedField>,
+      Literal?: NodeVisitorObject<Literal>,
+      LocalArgumentDefinition?: NodeVisitorObject<LocalArgumentDefinition>,
+      ModuleImport?: NodeVisitorObject<ModuleImport>,
+      Request?: NodeVisitorObject<Request>,
+      Root?: NodeVisitorObject<Root>,
+      RootArgumentDefinition?: NodeVisitorObject<RootArgumentDefinition>,
+      ScalarField?: NodeVisitorObject<ScalarField>,
+      SplitOperation?: NodeVisitorObject<SplitOperation>,
+      Stream?: NodeVisitorObject<Stream>,
+      Variable?: NodeVisitorObject<Variable>,
+    |};
+
+function visitIR(root: VisitNode, visitor: NodeVisitor): $FlowFixMe {
+  return (visit: $FlowFixMe)(root, visitor, NodeKeys);
+}
+
+module.exports = {visit: visitIR};

package/core/JSModuleParser.js.flow

@@ -0,0 +1,24 @@
+/**
+ * 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 FindGraphQLTags = require('../language/javascript/FindGraphQLTags');
+const RelaySourceModuleParser = require('./RelaySourceModuleParser');
+
+import type {SourceModuleParser} from './RelaySourceModuleParser';
+
+const JSModuleParser: SourceModuleParser = RelaySourceModuleParser(
+  FindGraphQLTags.find,
+);
+
+module.exports = JSModuleParser;

package/core/RelayCompilerScope.js.flow

@@ -0,0 +1,199 @@
+/**
+ * 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 {createUserError, eachWithCombinedError} = require('./CompilerError');
+
+import type {
+  Argument,
+  ArgumentDefinition,
+  ArgumentValue,
+  FragmentSpread,
+  LocalArgumentDefinition,
+  Variable,
+} from './IR';
+import type {Schema} from './Schema';
+/**
+ * A scope is a mapping of the values for each argument defined by the nearest
+ * ancestor root or fragment of a given IR selection. A scope maps argument
+ * names to the argument's statically determined value, which can be either a
+ * variable or a literal.
+ *
+ * There are two categories of scopes: root scopes and fragment scopes.
+ *
+ * Root scopes apply to `Root` IR and their subselections, up until any fragment
+ * spreads. Root scopes have the property that any argument may be provided at
+ * runtime: even where a default value is defined, the compiler must consider
+ * the value to be variable. Therefore, root scopes are a mapping of argument
+ * name to variables of the same name:
+ *
+ *   Map {
+ *     foo: $foo
+ *   }
+ *
+ * Fragment scopes apply to `Fragment` IR nodes and their subselections, up
+ * until any fragment spreads. Fragment scopes differ from root scopes in
+ * several ways:
+ * - Arguments may be overridden by the including fragment spread.
+ * - Arguments may import values from the root scope.
+ * - All other arguments must have their default values, or be null.
+ *
+ * Fragment scopes are also a mapping of argument name to value, but the value
+ * may also be a literal:
+ *
+ *   Map {
+ *     foo: $foo
+ *     bar: 42
+ *   }
+ */
+export type Scope = {[key: string]: ArgumentValue, ...};
+
+/**
+ * Creates a scope for a `Root`, with each argument mapped to a variable of the
+ * same name. Example:
+ *
+ * Query:
+ * query Foo($id: ID, $size: Int = 42) { ... }
+ *
+ * Scope:
+ * {
+ *   id: $id,
+ *   size: $size,
+ * }
+ *
+ * Note that even though a default value is defined for $size, the scope must
+ * assume that this could be overridden at runtime. The value cannot be decided
+ * statically and therefore is set to a variable.
+ */
+function getRootScope(
+  definitions: $ReadOnlyArray<LocalArgumentDefinition>,
+): Scope {
+  const scope = {};
+  definitions.forEach(definition => {
+    scope[definition.name] = ({
+      kind: 'Variable',
+      loc: definition.loc,
+      variableName: definition.name,
+      type: definition.type,
+    }: Variable);
+  });
+  return scope;
+}
+
+/**
+ * Creates a scope for a `Fragment` by translating fragment spread arguments in
+ * the context of a parent scope into a new scope and validating them against
+ * the argument definitions.
+ *
+ *
+ * Parent Scope:
+ * {
+ *   active: $parentActive
+ * }
+ *
+ * Fragment Spread:
+ * ...Bar(size: 42, enabled: $active)
+ *
+ * Fragment:
+ * fragment Bar on Foo @argumentDefinitions(
+ *   id: {type: "ID"}
+ *   size: {type: "Int"}
+ *   enabled: {type: "Boolean}
+ *   scale: {type: "Int", imports: "pixelRatio"}
+ * )
+ *
+ * Scope:
+ * {
+ *   // No argument is provided for $id, it gets the default value which in this
+ *   // case is `null`:
+ *   id: null,
+ *
+ *   // The parent passes 42 as a literal value for $size:
+ *   size: 42,
+ *
+ *   // The parent passes a variable as the value of $enabled. This variable is
+ *   // resolved in the parent scope to the value $parentActive, which becomes
+ *   // the value of $enabled:
+ *   $enabled: $parentActive,
+ *
+ *   // $scale imports pixelRatio from the root scope. Since any argument in a
+ *   // root scope maps to a variable of the same name, that means the value of
+ *   // pixelRatio in the root is $pixelRatio:
+ *   $scale: $pixelRatio,
+ * }
+ */
+function getFragmentScope(
+  schema: Schema,
+  definitions: $ReadOnlyArray<ArgumentDefinition>,
+  args: $ReadOnlyArray<Argument>,
+  parentScope: Scope,
+  spread: FragmentSpread,
+): Scope {
+  const argMap = new Map();
+  args.forEach(arg => {
+    if (arg.value.kind === 'Literal') {
+      argMap.set(arg.name, arg.value);
+    } else if (arg.value.kind === 'Variable') {
+      argMap.set(arg.name, parentScope[arg.value.variableName]);
+    }
+  });
+
+  const fragmentScope = {};
+  eachWithCombinedError(definitions, definition => {
+    if (definition.kind === 'RootArgumentDefinition') {
+      if (argMap.has(definition.name)) {
+        const argNode = args.find(a => a.name === definition.name);
+        throw createUserError(
+          `Unexpected argument '${definition.name}' supplied to fragment '${spread.name}'. @arguments may only be provided for variables defined in the fragment's @argumentDefinitions.`,
+          [argNode?.loc ?? spread.loc],
+        );
+      }
+      fragmentScope[definition.name] = ({
+        kind: 'Variable',
+        loc: definition.loc,
+        variableName: definition.name,
+        type: definition.type,
+      }: Variable);
+    } else {
+      const arg = argMap.get(definition.name);
+      if (arg == null || (arg.kind === 'Literal' && arg.value == null)) {
+        // No variable or literal null was passed, fall back to default
+        // value.
+        if (
+          definition.defaultValue == null &&
+          schema.isNonNull(definition.type)
+        ) {
+          const argNode = args.find(a => a.name === definition.name);
+          throw createUserError(
+            `No value found for required argument '${
+              definition.name
+            }: ${schema.getTypeString(definition.type)}' on fragment '${
+              spread.name
+            }'.`,
+            [argNode?.loc ?? spread.loc],
+          );
+        }
+        fragmentScope[definition.name] = {
+          kind: 'Literal',
+          value: definition.defaultValue,
+        };
+      } else {
+        // Variable or non-null literal.
+        fragmentScope[definition.name] = arg;
+      }
+    }
+  });
+  return fragmentScope;
+}
+
+module.exports = {getFragmentScope, getRootScope};

package/core/RelayFindGraphQLTags.js.flow

@@ -0,0 +1,119 @@
+/**
+ * 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 RelayCompilerCache = require('../util/RelayCompilerCache');
+
+const getModuleName = require('../util/getModuleName');
+const graphql = require('graphql');
+const path = require('path');
+const util = require('util');
+
+import type {File} from '../codegen/CodegenTypes';
+import type {
+  GraphQLTag,
+  GraphQLTagFinder,
+} from '../language/RelayLanguagePluginInterface';
+
+const cache = new RelayCompilerCache('RelayFindGraphQLTags', 'v1');
+
+function memoizedFind(
+  tagFinder: GraphQLTagFinder,
+  text: string,
+  baseDir: string,
+  file: File,
+): $ReadOnlyArray<string> {
+  invariant(
+    file.exists,
+    'RelayFindGraphQLTags: Called with non-existent file `%s`',
+    file.relPath,
+  );
+  return cache.getOrCompute(
+    file.hash,
+    find.bind(null, tagFinder, text, path.join(baseDir, file.relPath)),
+  );
+}
+
+function find(
+  tagFinder: GraphQLTagFinder,
+  text: string,
+  absPath: string,
+): $ReadOnlyArray<string> {
+  const tags = tagFinder(text, absPath);
+  const moduleName = getModuleName(absPath);
+  tags.forEach(tag => validateTemplate(tag, moduleName, absPath));
+  return tags.map(tag => tag.template);
+}
+
+function validateTemplate(
+  {template, keyName, sourceLocationOffset}: GraphQLTag,
+  moduleName: string,
+  filePath: string,
+) {
+  const ast = graphql.parse(
+    new graphql.Source(template, filePath, sourceLocationOffset),
+  );
+  ast.definitions.forEach(def => {
+    if (def.kind === 'OperationDefinition') {
+      invariant(
+        def.name != null,
+        'RelayFindGraphQLTags: In module `%s`, an operation requires a name.',
+        moduleName,
+        def.kind,
+      );
+      const definitionName = def.name.value;
+      const operationNameParts = definitionName.match(
+        /^(.*)(Mutation|Query|Subscription)$/,
+      );
+      invariant(
+        operationNameParts && definitionName.startsWith(moduleName),
+        'RelayFindGraphQLTags: Operation names in graphql tags must be prefixed ' +
+          'with the module name and end in "Mutation", "Query", or ' +
+          '"Subscription". Got `%s` in module `%s`.',
+        definitionName,
+        moduleName,
+      );
+    } else if (def.kind === 'FragmentDefinition') {
+      const definitionName = def.name.value;
+      if (keyName != null) {
+        invariant(
+          definitionName === moduleName + '_' + keyName,
+          'RelayFindGraphQLTags: Container fragment names must be ' +
+            '`<ModuleName>_<propName>`. Got `%s`, expected `%s`.',
+          definitionName,
+          moduleName + '_' + keyName,
+        );
+      } else {
+        invariant(
+          definitionName.startsWith(moduleName),
+          'RelayFindGraphQLTags: Fragment names in graphql tags must be prefixed ' +
+            'with the module name. Got `%s` in module `%s`.',
+          definitionName,
+          moduleName,
+        );
+      }
+    }
+  });
+}
+
+// TODO: Not sure why this is defined here rather than imported, is it so that it doesn’t get stripped in prod?
+function invariant(condition, msg, ...args) {
+  if (!condition) {
+    throw new Error(util.format(msg, ...args));
+  }
+}
+
+module.exports = {
+  find, // Exported for testing only.
+  memoizedFind,
+};

package/core/RelayGraphQLEnumsGenerator.js.flow

@@ -0,0 +1,55 @@
+/**
+ * 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 SignedSource = require('signedsource');
+
+import type CodegenDirectory from '../codegen/CodegenDirectory';
+import type {Schema} from '../core/Schema';
+
+function writeForSchema(
+  schema: Schema,
+  licenseHeader: $ReadOnlyArray<string>,
+  codegenDir: CodegenDirectory,
+  getModuleName: (enumName: string) => string,
+): void {
+  const header =
+    '/**\n' +
+    licenseHeader.map(line => ` * ${line}\n`).join('') +
+    ' *\n' +
+    ` * ${SignedSource.getSigningToken()}\n` +
+    ' * @flow strict\n' +
+    ' */\n' +
+    '\n';
+
+  const enumTypes = schema.getTypes().filter(type => schema.isEnum(type));
+
+  for (const type of enumTypes) {
+    const enumType = schema.assertEnumType(type);
+    const name = schema.getTypeString(type);
+    const values = [...schema.getEnumValues(enumType)].sort();
+    const enumFileContent =
+      header +
+      `export type ${name} =\n  | '` +
+      values.join("'\n  | '") +
+      "'\n  | '%future added value';\n";
+    codegenDir.writeFile(
+      `${getModuleName(name)}.js`,
+      SignedSource.signFile(enumFileContent),
+    );
+  }
+}
+
+module.exports = {
+  writeForSchema,
+};

package/core/RelayIRTransforms.js.flow

@@ -0,0 +1,130 @@
+/**
+ * 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 ApplyFragmentArgumentTransform = require('../transforms/ApplyFragmentArgumentTransform');
+const ClientExtensionsTransform = require('../transforms/ClientExtensionsTransform');
+const ConnectionTransform = require('../transforms/ConnectionTransform');
+const DeferStreamTransform = require('../transforms/DeferStreamTransform');
+const DisallowIdAsAlias = require('../transforms/DisallowIdAsAlias');
+const DisallowTypenameOnRoot = require('../transforms/DisallowTypenameOnRoot');
+const FieldHandleTransform = require('../transforms/FieldHandleTransform');
+const FilterDirectivesTransform = require('../transforms/FilterDirectivesTransform');
+const FlattenTransform = require('../transforms/FlattenTransform');
+const GenerateIDFieldTransform = require('../transforms/GenerateIDFieldTransform');
+const GenerateTypeNameTransform = require('../transforms/GenerateTypeNameTransform');
+const InlineDataFragmentTransform = require('../transforms/InlineDataFragmentTransform');
+const InlineFragmentsTransform = require('../transforms/InlineFragmentsTransform');
+const MaskTransform = require('../transforms/MaskTransform');
+const MatchTransform = require('../transforms/MatchTransform');
+const RefetchableFragmentTransform = require('../transforms/RefetchableFragmentTransform');
+const RelayDirectiveTransform = require('../transforms/RelayDirectiveTransform');
+const RelayFlowGenerator = require('../language/javascript/RelayFlowGenerator');
+const SkipClientExtensionsTransform = require('../transforms/SkipClientExtensionsTransform');
+const SkipHandleFieldTransform = require('../transforms/SkipHandleFieldTransform');
+const SkipRedundantNodesTransform = require('../transforms/SkipRedundantNodesTransform');
+const SkipSplitOperationTransform = require('../transforms/SkipSplitOperationTransform');
+const SkipUnreachableNodeTransform = require('../transforms/SkipUnreachableNodeTransform');
+const SkipUnusedVariablesTransform = require('../transforms/SkipUnusedVariablesTransform');
+const SplitModuleImportTransform = require('../transforms/SplitModuleImportTransform');
+const TestOperationTransform = require('../transforms/TestOperationTransform');
+const ValidateGlobalVariablesTransform = require('../transforms/ValidateGlobalVariablesTransform');
+const ValidateRequiredArgumentsTransform = require('../transforms/ValidateRequiredArgumentsTransform');
+const ValidateServerOnlyDirectivesTransform = require('../transforms/ValidateServerOnlyDirectivesTransform');
+const ValidateUnusedVariablesTransform = require('../transforms/ValidateUnusedVariablesTransform');
+
+import type {IRTransform} from './CompilerContext';
+
+// Transforms applied to the code used to process a query response.
+const relaySchemaExtensions: $ReadOnlyArray<string> = [
+  ConnectionTransform.SCHEMA_EXTENSION,
+  MatchTransform.SCHEMA_EXTENSION,
+  RelayDirectiveTransform.SCHEMA_EXTENSION,
+  RefetchableFragmentTransform.SCHEMA_EXTENSION,
+  TestOperationTransform.SCHEMA_EXTENSION,
+  InlineDataFragmentTransform.SCHEMA_EXTENSION,
+  RelayFlowGenerator.SCHEMA_EXTENSION,
+  ValidateUnusedVariablesTransform.SCHEMA_EXTENSION,
+];
+
+// Transforms applied to both operations and fragments for both reading and
+// writing from the store.
+const relayCommonTransforms: $ReadOnlyArray<IRTransform> = [
+  DisallowIdAsAlias.transform,
+  ConnectionTransform.transform,
+  RelayDirectiveTransform.transform,
+  MaskTransform.transform,
+  MatchTransform.transform,
+  RefetchableFragmentTransform.transform,
+  DeferStreamTransform.transform,
+];
+
+// Transforms applied to fragments used for reading data from a store
+const relayFragmentTransforms: $ReadOnlyArray<IRTransform> = [
+  ClientExtensionsTransform.transform,
+  FieldHandleTransform.transform,
+  InlineDataFragmentTransform.transform,
+  FlattenTransform.transformWithOptions({isForCodegen: true}),
+  SkipRedundantNodesTransform.transform,
+];
+
+// Transforms applied to queries/mutations/subscriptions that are used for
+// fetching data from the server and parsing those responses.
+const relayQueryTransforms: $ReadOnlyArray<IRTransform> = [
+  SplitModuleImportTransform.transform,
+  DisallowTypenameOnRoot.transform,
+  ValidateUnusedVariablesTransform.transform,
+  ApplyFragmentArgumentTransform.transform,
+  ValidateGlobalVariablesTransform.transform,
+  GenerateIDFieldTransform.transform,
+  TestOperationTransform.transform,
+];
+
+// Transforms applied to the code used to process a query response.
+const relayCodegenTransforms: $ReadOnlyArray<IRTransform> = [
+  SkipUnreachableNodeTransform.transform,
+  InlineFragmentsTransform.transform,
+  // NOTE: For the codegen context, we make sure to run ClientExtensions
+  // transform after we've inlined fragment spreads (i.e. InlineFragmentsTransform)
+  // This will ensure that we don't generate nested ClientExtension nodes
+  ClientExtensionsTransform.transform,
+  FlattenTransform.transformWithOptions({isForCodegen: true}),
+  SkipRedundantNodesTransform.transform,
+  GenerateTypeNameTransform.transform,
+  ValidateServerOnlyDirectivesTransform.transform,
+];
+
+// Transforms applied before printing the query sent to the server.
+const relayPrintTransforms: $ReadOnlyArray<IRTransform> = [
+  SkipSplitOperationTransform.transform,
+  // NOTE: Skipping client extensions might leave empty selections, which we
+  // skip by running SkipUnreachableNodeTransform immediately after.
+  ClientExtensionsTransform.transform,
+  SkipClientExtensionsTransform.transform,
+  SkipUnreachableNodeTransform.transform,
+  FlattenTransform.transformWithOptions({}),
+  GenerateTypeNameTransform.transform,
+  SkipHandleFieldTransform.transform,
+  FilterDirectivesTransform.transform,
+  SkipUnusedVariablesTransform.transform,
+  ValidateRequiredArgumentsTransform.transform,
+];
+
+module.exports = {
+  commonTransforms: relayCommonTransforms,
+  codegenTransforms: relayCodegenTransforms,
+  fragmentTransforms: relayFragmentTransforms,
+  printTransforms: relayPrintTransforms,
+  queryTransforms: relayQueryTransforms,
+  schemaExtensions: relaySchemaExtensions,
+};