relay-compiler 0.0.0-main-bfcb5c59 → 0.0.0-main-4467ae84

package/core/IRVisitor.js.flow

@@ -1,150 +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
- * @format
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-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 {visit} = require('graphql');
-
-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

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

package/core/RelayCompilerScope.js.flow

@@ -1,199 +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 {
-  Argument,
-  ArgumentDefinition,
-  ArgumentValue,
-  FragmentSpread,
-  LocalArgumentDefinition,
-  Variable,
-} from './IR';
-import type {Schema} from './Schema';
-
-const {createUserError, eachWithCombinedError} = require('./CompilerError');
-/**
- * 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

@@ -1,118 +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 {File} from '../codegen/CodegenTypes';
-import type {
-  GraphQLTag,
-  GraphQLTagFinder,
-} from '../language/RelayLanguagePluginInterface';
-
-const getModuleName = require('../util/getModuleName');
-const RelayCompilerCache = require('../util/RelayCompilerCache');
-const graphql = require('graphql');
-const path = require('path');
-const util = require('util');
-
-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

@@ -1,55 +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 CodegenDirectory from '../codegen/CodegenDirectory';
-import type {Schema} from '../core/Schema';
-
-const SignedSource = require('signedsource');
-
-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

@@ -1,138 +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 {IRTransform} from './CompilerContext';
-
-const RelayFlowGenerator = require('../language/javascript/RelayFlowGenerator');
-const ApplyFragmentArgumentTransform = require('../transforms/ApplyFragmentArgumentTransform');
-const ClientExtensionsTransform = require('../transforms/ClientExtensionsTransform');
-const ConnectionTransform = require('../transforms/ConnectionTransform');
-const DeclarativeConnectionMutationTransform = require('../transforms/DeclarativeConnectionMutationTransform');
-const DeferStreamTransform = require('../transforms/DeferStreamTransform');
-const DisallowIdAsAlias = require('../transforms/DisallowIdAsAlias');
-const DisallowTypenameOnRoot = require('../transforms/DisallowTypenameOnRoot');
-const FieldHandleTransform = require('../transforms/FieldHandleTransform');
-const FilterCompilerDirectivesTransform = require('../transforms/FilterCompilerDirectivesTransform');
-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 ReactFlightComponentTransform = require('../transforms/ReactFlightComponentTransform');
-const RefetchableFragmentTransform = require('../transforms/RefetchableFragmentTransform');
-const RelayDirectiveTransform = require('../transforms/RelayDirectiveTransform');
-const RequiredFieldTransform = require('../transforms/RequiredFieldTransform');
-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 ValidateUnusedVariablesTransform = require('../transforms/ValidateUnusedVariablesTransform');
-
-// Transforms applied to the code used to process a query response.
-const relaySchemaExtensions: $ReadOnlyArray<string> = [
-  ConnectionTransform.SCHEMA_EXTENSION,
-  DeclarativeConnectionMutationTransform.SCHEMA_EXTENSION,
-  InlineDataFragmentTransform.SCHEMA_EXTENSION,
-  MatchTransform.SCHEMA_EXTENSION,
-  RequiredFieldTransform.SCHEMA_EXTENSION,
-  RefetchableFragmentTransform.SCHEMA_EXTENSION,
-  RelayDirectiveTransform.SCHEMA_EXTENSION,
-  RelayFlowGenerator.SCHEMA_EXTENSION,
-  TestOperationTransform.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,
-  ReactFlightComponentTransform.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}),
-  RequiredFieldTransform.transform,
-  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,
-  DeclarativeConnectionMutationTransform.transform,
-];
-
-// Transforms applied to the code used to process a query response.
-const relayCodegenTransforms: $ReadOnlyArray<IRTransform> = [
-  FilterCompilerDirectivesTransform.transform,
-  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,
-  GenerateTypeNameTransform.transform,
-  FlattenTransform.transformWithOptions({isForCodegen: true}),
-  SkipRedundantNodesTransform.transform,
-  TestOperationTransform.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,
-  GenerateTypeNameTransform.transform,
-  FlattenTransform.transformWithOptions({}),
-  SkipHandleFieldTransform.transform,
-  FilterDirectivesTransform.transform,
-  SkipUnusedVariablesTransform.transform,
-  ValidateRequiredArgumentsTransform.transform,
-];
-
-module.exports = {
-  commonTransforms: relayCommonTransforms,
-  codegenTransforms: relayCodegenTransforms,
-  fragmentTransforms: relayFragmentTransforms,
-  printTransforms: relayPrintTransforms,
-  queryTransforms: relayQueryTransforms,
-  schemaExtensions: relaySchemaExtensions,
-};