[relay-compiler] Upgrade to suport version 8 (#41740)

* Upgrade to suport version 8

* Change version

* Merge branch 'update-relay-compiler-v8' of github.com:thicodes/DefinitelyTyped into feat/relay-8

* solve lint problems

* upgrade versions of typescript to 3.4

Co-authored-by: Renan Machado <renan.mav@hotmail.com>

types/relay-compiler/index.d.ts

@@ -1,24 +1,26 @@
-// Type definitions for relay-compiler 7.0
+// Type definitions for relay-compiler 8.0
 // Project: https://relay.dev
 // Definitions by: n1ru4l <https://github.com/n1ru4l>
 //                 Eloy Durán <https://github.com/alloy>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 3.0
+// TypeScript Version: 3.4
 
 import * as ASTConvert from './lib/core/ASTConvert';
+import { CompilerContext } from './lib/core/CompilerContext';
 import * as Parser from './lib/core/RelayParser';
-import * as Printer from './lib/core/GraphQLIRPrinter';
+import * as Printer from './lib/core/IRPrinter';
 import * as IRTransforms from './lib/core/RelayIRTransforms';
-import * as IRVisitor from './lib/core/GraphQLIRVisitor';
+import * as IRVisitor from './lib/core/IRVisitor';
 import * as SchemaUtils from './lib/core/GraphQLSchemaUtils';
 
-import ConsoleReporter = require('./lib/reporters/GraphQLConsoleReporter');
-import MultiReporter = require('./lib/reporters/GraphQLMultiReporter');
+import ConsoleReporter = require('./lib/reporters/ConsoleReporter');
+import MultiReporter = require('./lib/reporters/MultiReporter');
 
 declare var transformASTSchema: typeof ASTConvert.transformASTSchema;
 
 export {
     ASTConvert,
+    CompilerContext,
     ConsoleReporter,
     IRTransforms,
     IRVisitor,
@@ -30,7 +32,6 @@ export {
 };
 
 export { main as relayCompiler } from './lib/bin/RelayCompilerMain';
-export { GraphQLCompilerContext } from './lib/core/GraphQLCompilerContext';
 export { FormatModule, TypeGenerator } from './lib/language/RelayLanguagePluginInterface';
 export {
     Argument,
@@ -59,18 +60,11 @@ export {
     Root,
     RootArgumentDefinition,
     ScalarField,
-    ScalarFieldType,
     Selection,
     SplitOperation,
     Variable,
-} from './lib/core/GraphQLIR';
+} from './lib/core/IR';
 
 export { createUserError } from './lib/core/RelayCompilerError';
 
-export {
-    EnumTypeID,
-    FieldID,
-    ScalarTypeID,
-    Schema,
-    TypeID,
-} from './lib/core/Schema';
+export { EnumTypeID, FieldID, ScalarTypeID, Schema, TypeID } from './lib/core/Schema';

types/relay-compiler/lib/core/ASTConvert.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql';
 export function transformASTSchema(
   schema: GraphQLSchema,
-  transforms: string[],
+  schemaExtensions: string[],
 ): GraphQLSchema;

types/relay-compiler/lib/core/CompilerContext.d.ts

@@ -0,0 +1,34 @@
+import { Root, Fragment, SplitOperation, Location } from './IR';
+import { Schema } from './Schema';
+import { Reporter } from '../reporters/Reporter';
+
+export type IRTransform = (
+  context: CompilerContext,
+) => CompilerContext;
+
+export type CompilerContextDocument = Fragment | Root | SplitOperation;
+
+export class CompilerContext {
+  constructor(schema: Schema);
+  documents(): CompilerContextDocument[];
+  forEachDocument(fn: (doc: CompilerContextDocument) => void): void;
+  replace(node: CompilerContextDocument): CompilerContext;
+  add(node: CompilerContextDocument): CompilerContext;
+  addAll(nodes: ReadonlyArray<CompilerContextDocument>): CompilerContext;
+  applyTransforms(
+    transforms: ReadonlyArray<IRTransform>,
+    reporter?: Reporter,
+  ): CompilerContext;
+  applyTransform(
+    transform: IRTransform,
+    reporter?: Reporter,
+  ): CompilerContext;
+  get(name: string): CompilerContextDocument | undefined;
+  getFragment(name: string, referencedFrom?: Location): Fragment;
+  getRoot(name: string): Root;
+  remove(name: string): CompilerContext;
+  withMutations(
+    fn: (context: CompilerContext) => CompilerContext,
+  ): CompilerContext;
+  getSchema(): Schema;
+}

types/relay-compiler/lib/core/GraphQLCompilerContext.d.ts

@@ -1,38 +0,0 @@
-import { GraphQLSchema } from 'graphql';
-import { Root, Fragment, SplitOperation, Location } from './GraphQLIR';
-import { GraphQLReporter } from '../reporters/GraphQLReporter';
-
-export type IRTransform = (
-  context: GraphQLCompilerContext,
-) => GraphQLCompilerContext;
-export type IRValidation = (contect: GraphQLCompilerContext) => void;
-
-export type CompilerContextDocument = Fragment | Root | SplitOperation;
-
-export class GraphQLCompilerContext {
-  constructor(serverSchema: GraphQLSchema, clientSchema?: GraphQLSchema);
-  documents(): ReadonlyArray<CompilerContextDocument>;
-  forEachDocument(fn: (doc: CompilerContextDocument) => void): void;
-  replace(node: CompilerContextDocument): GraphQLCompilerContext;
-  add(node: CompilerContextDocument): GraphQLCompilerContext;
-  addAll(nodes: ReadonlyArray<CompilerContextDocument>): GraphQLCompilerContext;
-  applyTransforms(
-    transforms: ReadonlyArray<IRTransform>,
-    reporter?: GraphQLReporter,
-  ): GraphQLCompilerContext;
-  applyTransform(
-    transform: IRTransform,
-    reporter?: GraphQLReporter,
-  ): GraphQLCompilerContext;
-  applyValidations(
-    validations: ReadonlyArray<IRValidation>,
-    reporter?: GraphQLReporter,
-  ): void;
-  get(name: string): CompilerContextDocument | undefined;
-  getFragment(name: string, referencedFrom?: Location): Fragment;
-  getRoot(name: string): Root;
-  remove(name: string): GraphQLCompilerContext;
-  withMutations(
-    fn: (context: GraphQLCompilerContext) => GraphQLCompilerContext,
-  ): GraphQLCompilerContext;
-}

types/relay-compiler/lib/core/GraphQLIRPrinter.d.ts

@@ -1,2 +0,0 @@
-import { CompilerContextDocument } from './GraphQLCompilerContext';
-export function print(node: CompilerContextDocument): string;

types/relay-compiler/lib/core/IR.d.ts

@@ -1,12 +1,11 @@
 import {
-    Source,
-    GraphQLInputType,
-    GraphQLOutputType,
-    GraphQLCompositeType,
-    GraphQLLeafType,
-    GraphQLList,
-    GraphQLNonNull,
-} from 'graphql';
+    LinkedFieldTypeID,
+    ScalarFieldTypeID,
+    CompositeTypeID,
+    InputTypeID,
+    TypeID,
+} from './Schema';
+import { Source } from 'graphql';
 import { TypeReferenceNode } from 'typescript';
 
 export type Metadata = { [key: string]: unknown } | undefined;
@@ -37,7 +36,7 @@ export interface Argument {
     loc: Location;
     metadata: Metadata;
     name: string;
-    type?: GraphQLInputType;
+    type?: InputTypeID;
     value: ArgumentValue;
 }
 
@@ -54,12 +53,6 @@ export interface Condition {
     selections: ReadonlyArray<Selection>;
 }
 
-export interface Connection {
-    key: string;
-    conditional: boolean;
-    value: TypeReferenceNode;
-}
-
 export interface Directive {
     args: ReadonlyArray<Argument>;
     kind: 'Directive';
@@ -68,7 +61,7 @@ export interface Directive {
     name: string;
 }
 
-export type Field = LinkedField | ScalarField | ConnectionField;
+export type Field = LinkedField | ScalarField;
 
 export interface Fragment {
     argumentDefinitions: ReadonlyArray<ArgumentDefinition>;
@@ -78,7 +71,7 @@ export interface Fragment {
     metadata: Metadata;
     name: string;
     selections: ReadonlyArray<Selection>;
-    type: GraphQLCompositeType;
+    type: CompositeTypeID;
 }
 
 export interface FragmentSpread {
@@ -93,7 +86,12 @@ export interface FragmentSpread {
 export interface Defer {
     kind: 'Defer';
     loc: Location;
-    metadata: Metadata;
+    metadata:
+        | {
+            fragmentTypeCondition: string;
+          }
+        | null
+        | undefined;
     selections: ReadonlyArray<Selection>;
     label: string;
     if: ArgumentValue | null;
@@ -107,6 +105,7 @@ export interface Stream {
     label: string;
     if: ArgumentValue | null;
     initialCount: ArgumentValue;
+    useCustomizedBatch: ArgumentValue | null;
 }
 
 export interface InlineDataFragmentSpread {
@@ -122,7 +121,6 @@ export type IR =
     | ClientExtension
     | Condition
     | Defer
-    | ConnectionField
     | Directive
     | Fragment
     | FragmentSpread
@@ -146,9 +144,8 @@ export type IR =
 export interface RootArgumentDefinition {
     kind: 'RootArgumentDefinition';
     loc: Location;
-    metadata: Metadata;
     name: string;
-    type: GraphQLInputType;
+    type: InputTypeID;
 }
 
 export interface InlineFragment {
@@ -157,14 +154,14 @@ export interface InlineFragment {
     loc: Location;
     metadata: Metadata;
     selections: ReadonlyArray<Selection>;
-    typeCondition: GraphQLCompositeType;
+    typeCondition: CompositeTypeID;
 }
 
 export interface Handle {
     name: string;
     key: string;
     dynamicKey: Variable | null;
-    filters?: Readonly<string>;
+    filters?: ReadonlyArray<string>;
 }
 
 export interface ClientExtension {
@@ -174,23 +171,10 @@ export interface ClientExtension {
     selections: ReadonlyArray<Selection>;
 }
 
-export interface ConnectionField {
-    alias: string;
-    args: ReadonlyArray<Argument>;
-    directives: ReadonlyArray<Directive>;
-    kind: 'ConnectionField';
-    label: string;
-    loc: Location;
-    metadata: Metadata;
-    name: string;
-    resolver: string;
-    selections: ReadonlyArray<Selection>;
-    type: GraphQLOutputType;
-}
-
 export interface LinkedField {
     alias: string;
     args: ReadonlyArray<Argument>;
+    connection: boolean;
     directives: ReadonlyArray<Directive>;
     handles?: ReadonlyArray<Handle>;
     kind: 'LinkedField';
@@ -198,7 +182,13 @@ export interface LinkedField {
     metadata: Metadata;
     name: string;
     selections: ReadonlyArray<Selection>;
-    type: GraphQLOutputType;
+    type: LinkedFieldTypeID;
+}
+
+export interface ListValue {
+    kind: 'ListValue';
+    items: ReadonlyArray<ArgumentValue>;
+    loc: Location;
 }
 
 export interface ListValue {
@@ -211,7 +201,6 @@ export interface ListValue {
 export interface Literal {
     kind: 'Literal';
     loc: Location;
-    metadata: Metadata;
     value: unknown;
 }
 
@@ -221,7 +210,7 @@ export interface LocalArgumentDefinition {
     loc: Location;
     metadata: Metadata;
     name: string;
-    type: GraphQLInputType;
+    type: InputTypeID;
 }
 
 export interface ModuleImport {
@@ -238,7 +227,6 @@ export type Node =
     | ClientExtension
     | Condition
     | Defer
-    | ConnectionField
     | Fragment
     | InlineDataFragmentSpread
     | InlineFragment
@@ -251,7 +239,6 @@ export type Node =
 export interface ObjectFieldValue {
     kind: 'ObjectFieldValue';
     loc: Location;
-    metadata: Metadata;
     name: string;
     value: ArgumentValue;
 }
@@ -260,7 +247,6 @@ export interface ObjectValue {
     kind: 'ObjectValue';
     fields: ReadonlyArray<ObjectFieldValue>;
     loc: Location;
-    metadata: Metadata;
 }
 
 export interface Request {
@@ -283,18 +269,9 @@ export interface Root {
     name: string;
     operation: 'query' | 'mutation' | 'subscription';
     selections: Readonly<Selection>;
-    type: GraphQLCompositeType;
+    type: CompositeTypeID;
 }
 
-// workaround for circular reference
-// tslint:disable-next-line:no-empty-interface
-export interface ScalarFieldTypeGraphQLList extends GraphQLList<ScalarFieldType> {}
-
-export type ScalarFieldType =
-    | GraphQLLeafType
-    | ScalarFieldTypeGraphQLList
-    | GraphQLNonNull<GraphQLLeafType | ScalarFieldTypeGraphQLList>;
-
 export interface ScalarField {
     alias: string;
     args: ReadonlyArray<Argument>;
@@ -304,14 +281,13 @@ export interface ScalarField {
     loc: Location;
     metadata: Metadata;
     name: string;
-    type: ScalarFieldType;
+    type: ScalarFieldTypeID;
 }
 
 export type Selection =
     | ClientExtension
     | Condition
     | Defer
-    | ConnectionField
     | FragmentSpread
     | InlineFragment
     | LinkedField
@@ -329,13 +305,13 @@ export interface SplitOperation {
     selections: ReadonlyArray<Selection>;
     loc: Location;
     metadata: Metadata;
-    type: GraphQLCompositeType;
+    parentSources: Set<string>;
+    type: TypeID;
 }
 
 export interface Variable {
     kind: 'Variable';
     loc: Location;
-    metadata: Metadata;
     variableName: string;
-    type?: GraphQLInputType;
+    type?: TypeID;
 }

types/relay-compiler/lib/core/IRPrinter.d.ts

@@ -0,0 +1,2 @@
+import { CompilerContextDocument } from './CompilerContext';
+export function print(node: CompilerContextDocument): string;

types/relay-compiler/lib/core/IRVisitor.d.ts

@@ -2,9 +2,7 @@ import {
     Argument,
     ClientExtension,
     Condition,
-    Connection,
     Defer,
-    ConnectionField,
     Directive,
     Fragment,
     FragmentSpread,
@@ -21,15 +19,13 @@ import {
     SplitOperation,
     Stream,
     Variable,
-} from './GraphQLIR';
+} from './IR';
 
 export type VisitNode =
     | Argument
     | ClientExtension
     | Condition
     | Defer
-    | ConnectionField
-    | Connection
     | Directive
     | Fragment
     | FragmentSpread
@@ -69,9 +65,7 @@ export type NodeVisitor =
           Argument?: VisitFn<Argument>;
           ClientExtension?: VisitFn<ClientExtension>;
           Condition?: VisitFn<Condition>;
-          Connection?: VisitFn<Connection>;
           Defer?: VisitFn<Defer>;
-          ConnectionField?: VisitFn<ConnectionField>;
           Directive?: VisitFn<Directive>;
           Fragment?: VisitFn<Fragment>;
           FragmentSpread?: VisitFn<FragmentSpread>;
@@ -92,9 +86,7 @@ export type NodeVisitor =
           Argument?: NodeVisitorObject<Argument>;
           ClientExtension?: VisitFn<ClientExtension>;
           Condition?: NodeVisitorObject<Condition>;
-          Connection?: NodeVisitorObject<Connection>;
           Defer?: NodeVisitorObject<Defer>;
-          ConnectionField?: NodeVisitorObject<ConnectionField>;
           Directive?: NodeVisitorObject<Directive>;
           Fragment?: NodeVisitorObject<Fragment>;
           FragmentSpread?: NodeVisitorObject<FragmentSpread>;

types/relay-compiler/lib/core/RelayCompilerError.d.ts

@@ -1,5 +1,5 @@
 import { ASTNode, GraphQLError } from 'graphql';
-import { Location } from './GraphQLIR';
+import { Location } from './IR';
 
 export type UserError = GraphQLError;
 

types/relay-compiler/lib/core/RelayIRTransforms.d.ts

@@ -1,4 +1,4 @@
-import { IRTransform } from './GraphQLCompilerContext';
+import { IRTransform } from './CompilerContext';
 
 export const commonTransforms: IRTransform[];
 export const codegenTransforms: IRTransform[];

types/relay-compiler/lib/core/RelayParser.d.ts

@@ -1,13 +1,14 @@
-import { GraphQLSchema, DefinitionNode } from 'graphql';
-import { Root, Fragment } from './GraphQLIR';
+import { DefinitionNode } from 'graphql';
+import { Root, Fragment } from './IR';
+import { Schema } from './Schema';
 
 export function parse(
-  schema: GraphQLSchema,
+  schema: Schema,
   text: string,
   filename?: string,
 ): ReadonlyArray<Root | Fragment>;
 
 export function transform(
-  schema: GraphQLSchema,
+  schema: Schema,
   documents: DefinitionNode[],
 ): ReadonlyArray<Root | Fragment>;

types/relay-compiler/lib/core/Schema.d.ts

@@ -1,27 +1,129 @@
+import {
+    TypeNode,
+    DocumentNode,
+    DirectiveLocationEnum,
+    ValueNode,
+} from 'graphql';
+import { Field as IRField } from './IR';
+
+export type AbstractTypeID = any;
+export type CompositeTypeID = any;
 export type EnumTypeID = any;
 export type FieldID = any;
 export type InputObjectTypeID = any;
+export type InputTypeID = any;
+export type InterfaceTypeID = any;
+export type LinkedFieldTypeID = any;
+export type ObjectTypeID = any;
 export type ScalarTypeID = any;
+export type ScalarFieldTypeID = any;
 export type TypeID = any;
+export type UnionTypeID = any;
+
+export type Argument = Readonly<{
+    name: string,
+    type: InputTypeID,
+    defaultValue: any
+}>;
+
+export type Directive = Readonly<{
+    args: ReadonlyArray<Argument>,
+    isClient: boolean,
+    locations: ReadonlyArray<DirectiveLocationEnum>,
+    name: string
+}>;
 
 export interface Schema {
+    areEqualTypes: (typeA: TypeID, typeB: TypeID) => boolean;
+    asCompositeType: (type: any) => CompositeTypeID | null | undefined;
+    asInputType: (type: any) => InputTypeID | null | undefined;
+    asScalarFieldType: (type: any) => ScalarFieldTypeID | null | undefined;
+    assertLinkedFieldType: (type: any) => LinkedFieldTypeID;
+    assertAbstractType: (type: TypeID) => AbstractTypeID;
+    assertBooleanType: (type: TypeID) => ScalarTypeID;
+    assertCompositeType: (type: TypeID) => CompositeTypeID;
     assertEnumType: (type: TypeID) => EnumTypeID;
     assertInputObjectType: (type: TypeID) => InputObjectTypeID;
+    assertInputType: (type: any) => InputTypeID;
+    assertIntType: (type: TypeID) => ScalarTypeID;
+    assertInterfaceType: (type: TypeID) => InterfaceTypeID;
+    assertFloatType: (type: TypeID) => ScalarTypeID;
+    assertIdType: (type: TypeID) => ScalarTypeID;
+    assertLeafType: (type: TypeID) => TypeID;
+    assertObjectType: (type: TypeID) => ObjectTypeID;
+    assertScalarFieldType: (type: any) => ScalarFieldTypeID;
+    assertScalarType: (type: TypeID) => ScalarTypeID;
+    assertStringType: (type: TypeID) => ScalarTypeID;
+    assertUnionType: (type: TypeID) => UnionTypeID;
+    canHaveSelections: (type: TypeID) => boolean;
+    doTypesOverlap: (typeA: CompositeTypeID, typeB: CompositeTypeID) => boolean;
+    expectBooleanType: () => ScalarTypeID;
+    expectIdType: () => ScalarTypeID;
+    expectIntType: () => ScalarTypeID;
+    expectField: (type: CompositeTypeID | InputObjectTypeID, fieldName: string) => FieldID;
+    expectFloatType: () => ScalarTypeID;
+    expectMutationType: () => ObjectTypeID;
+    expectQueryType: () => ObjectTypeID;
     expectStringType: () => ScalarTypeID;
+    expectSubscriptionType: () => ObjectTypeID;
+    expectTypeFromAST: (ast: TypeNode) => TypeID;
+    expectTypeFromString: (typeName: string) => TypeID;
+    extend: (extensions: DocumentNode | ReadonlyArray<string>) => Schema;
+    getDirectives: () => ReadonlyArray<Directive>;
+    getDirective: (directiveName: string) => Directive | null | undefined;
     getEnumValues: (type: EnumTypeID) => string[];
+    getFieldByName: (type: CompositeTypeID | InputObjectTypeID, fieldName: string) => FieldID | null | undefined;
+    getFieldArgs: (field: FieldID) => ReadonlyArray<Argument>;
+    getFieldArgByName: (field: FieldID, argName: string) => Argument | null  | undefined;
+    getFieldConfig: (field: FieldID) => { type: TypeID, args: ReadonlyArray<Argument> };
     getFieldName: (field: FieldID) => string;
+    getFieldParentType: (field: FieldID) => TypeID;
     getFields: (type: TypeID) => FieldID[];
     getFieldType: (field: FieldID) => TypeID;
+    getInterfaces: (type: CompositeTypeID) => ReadonlyArray<TypeID>;
     getListItemType: (type: TypeID) => TypeID;
+    getMutationType: () => ObjectTypeID | null | undefined;
+    getNonNullType: (type: TypeID) => TypeID;
     getNullableType: (type: TypeID) => TypeID;
+    getPossibleTypes: (type: AbstractTypeID) => ReadonlySet<ObjectTypeID>;
+    getQueryType: () => ObjectTypeID | null | undefined;
+    getRawType: (type: TypeID) => TypeID;
+    getSubscriptionType: () => ObjectTypeID | null | undefined;
+    getTypes: () => ReadonlyArray<TypeID>;
+    getTypeFromAST: (typeNode: TypeNode) => TypeID | null | undefined;
+    getTypeFromString: (typeName: string) => TypeID | null | undefined;
     getTypeString: (type: TypeID) => string;
+    getUnionTypes: (type: UnionTypeID) => ReadonlyArray<TypeID>;
+    hasField: (type: CompositeTypeID | InputObjectTypeID, fieldName: string) => boolean;
+    hasId: (type: CompositeTypeID) => boolean;
     isAbstractType: (type: TypeID) => boolean;
+    implementsInterface: (type: CompositeTypeID, interfaceType: InterfaceTypeID) => boolean;
+    isBoolean: (type: TypeID) => boolean;
+    isClientDefinedField: (type: CompositeTypeID, field: IRField) => boolean;
+    isCompositeType: (type: TypeID) => boolean;
     isEnum: (type: TypeID) => boolean;
+    isFloat: (type: TypeID) => boolean;
+    isId: (type: TypeID) => boolean;
     isInputObject: (type: TypeID) => boolean;
+    isInputType: (type: TypeID) => boolean;
+    isInt: (type: TypeID) => boolean;
     isInterface: (type: TypeID) => boolean;
+    isLeafType: (type: TypeID) => boolean;
     isList: (type: TypeID) => boolean;
     isNonNull: (type: TypeID) => boolean;
     isObject: (type: TypeID) => boolean;
+    isPossibleType: (superType: AbstractTypeID, maybeSubType: ObjectTypeID) => boolean;
     isScalar: (type: TypeID) => boolean;
+    isServerDefinedField: (type: CompositeTypeID, field: IRField) => boolean;
+    isServerDirective: (directiveName: string) => boolean;
+    isServerField: (field: FieldID) => boolean;
+    isServerType: (type: TypeID) => boolean;
+    isString: (type: TypeID) => boolean;
+    isTypeSubTypeOf: (maybeSubType: TypeID, superType: TypeID) => boolean;
     isUnion: (type: TypeID) => boolean;
+    isWrapper: (type: TypeID) => boolean;
+    mayImplement: (type: CompositeTypeID, interfaceType: InterfaceTypeID) => boolean;
+    parseLiteral: (type: ScalarTypeID | EnumTypeID, valueNode: ValueNode) => any;
+    parseValue: (type: ScalarTypeID | EnumTypeID, value: any) => any;
+    serialize: (type: ScalarTypeID | EnumTypeID, value: any) => any;
 }

types/relay-compiler/lib/language/RelayLanguagePluginInterface.d.ts

@@ -1,5 +1,5 @@
-import { Root, Fragment, GeneratedDefinition } from '../core/GraphQLIR';
-import { IRTransform } from '../core/GraphQLCompilerContext';
+import { Root, Fragment, GeneratedDefinition } from '../core/IR';
+import { IRTransform } from '../core/CompilerContext';
 import { GeneratedNode, RelayConcreteNode } from 'relay-runtime';
 import { ScalarTypeMapping } from './javascript/RelayFlowTypeTransformers';
 import { Schema } from '../core/Schema';

types/relay-compiler/lib/reporters/ConsoleReporter.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLReporter } from './GraphQLReporter';
+import { Reporter } from './Reporter';
 
-declare class GraphQLMultiReporter implements GraphQLReporter {
+declare class ConsoleReporter implements Reporter {
     reportMessage(message: string): void;
     reportTime(name: string, ms: number): void;
     reportError(caughtLocation: string, error: Error): void;
 }
 
-export = GraphQLMultiReporter;
+export = ConsoleReporter;

types/relay-compiler/lib/reporters/MultiReporter.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLReporter } from './GraphQLReporter';
+import { Reporter } from './Reporter';
 
-declare class GraphQLMultiReporter implements GraphQLReporter {
+declare class MultiReporter implements Reporter {
     reportMessage(message: string): void;
     reportTime(name: string, ms: number): void;
     reportError(caughtLocation: string, error: Error): void;
 }
 
-export = GraphQLMultiReporter;
+export = MultiReporter;

types/relay-compiler/lib/reporters/Reporter.d.ts

@@ -1,4 +1,4 @@
-export interface GraphQLReporter {
+export interface Reporter {
   reportMessage(message: string): void;
   reportTime(name: string, ms: number): void;
   reportError(caughtLocation: string, error: Error): void;

types/relay-compiler/lib/transforms/ApplyFragmentArgumentTransform.d.ts

@@ -1,5 +1,7 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
-export function transform(
-  context: GraphQLCompilerContext,
-): GraphQLCompilerContext;
+declare function applyFragmentArgumentTransform(
+    context: CompilerContext,
+  ): CompilerContext;
+
+export { applyFragmentArgumentTransform as transform };

types/relay-compiler/lib/transforms/ConnectionFieldTransform.d.ts

@@ -1,9 +0,0 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
-
-/**
- * This transform rewrites LinkedField nodes with @connection_resolver and rewrites them
- * into `ConnectionField` nodes.
- */
-declare function connectionFieldTransform(context: GraphQLCompilerContext): GraphQLCompilerContext;
-
-export { connectionFieldTransform as transform };

types/relay-compiler/lib/transforms/ConnectionTransform.d.ts

@@ -0,0 +1,9 @@
+import { CompilerContext } from '../core/CompilerContext';
+
+/**
+ * This transform rewrites LinkedField nodes with @connection_resolver and rewrites them
+ * into `ConnectionField` nodes.
+ */
+declare function connectionTransform(context: CompilerContext): CompilerContext;
+
+export { connectionTransform as transform };

types/relay-compiler/lib/transforms/FlattenTransform.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
 export interface FlattenOptions {
-  flattenAbstractTypes?: boolean;
+    flattenAbstractTypes?: boolean;
 }
 
 export function transformWithOptions(
   options: FlattenOptions,
-): (context: GraphQLCompilerContext) => GraphQLCompilerContext;
+): (context: CompilerContext) => CompilerContext;

types/relay-compiler/lib/transforms/InlineFragmentsTransform.d.ts

@@ -1,5 +1,5 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
 export function transform(
-  context: GraphQLCompilerContext,
-): GraphQLCompilerContext;
+  context: CompilerContext,
+): CompilerContext;

types/relay-compiler/lib/transforms/MaskTransform.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
 /**
  * A transform that inlines fragment spreads with the @relay(mask: false)
  * directive.
  */
-declare function relayMaskTransform(context: GraphQLCompilerContext): GraphQLCompilerContext;
+declare function relayMaskTransform(context: CompilerContext): CompilerContext;
 
 export { relayMaskTransform as transform };

types/relay-compiler/lib/transforms/MatchTransform.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
 /**
  * This transform rewrites LinkedField nodes with @match and rewrites them
  * into `LinkedField` nodes with a `supported` argument.
  */
-declare function relayMatchTransform(context: GraphQLCompilerContext): GraphQLCompilerContext;
+declare function relayMatchTransform(context: CompilerContext): CompilerContext;
 
 export { relayMatchTransform as transform };

types/relay-compiler/lib/transforms/RefetchableFragmentTransform.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
 /**
  * This transform synthesizes "refetch" queries for fragments that
@@ -16,6 +16,6 @@ import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
  * 3. Building the refetch queries, a straightforward copying transform from
  *    Fragment to Root IR nodes.
  */
-declare function relayRefetchableFragmentTransform(context: GraphQLCompilerContext): GraphQLCompilerContext;
+declare function relayRefetchableFragmentTransform(context: CompilerContext): CompilerContext;
 
 export { relayRefetchableFragmentTransform as transform };

types/relay-compiler/lib/transforms/RelayDirectiveTransform.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
 /**
  * A transform that extracts `@relay(plural: Boolean)` directives and converts
  * them to metadata that can be accessed at runtime.
  */
-declare function relayRelayDirectiveTransform(context: GraphQLCompilerContext): GraphQLCompilerContext;
+declare function relayRelayDirectiveTransform(context: CompilerContext): CompilerContext;
 
 export { relayRelayDirectiveTransform as transform };

types/relay-compiler/lib/transforms/SkipRedundantNodesTransform.d.ts

@@ -1,5 +1,7 @@
-import { GraphQLCompilerContext } from '../core/GraphQLCompilerContext';
+import { CompilerContext } from '../core/CompilerContext';
 
-export function transform(
-  context: GraphQLCompilerContext,
-): GraphQLCompilerContext;
+declare function skipRedundantNodesTransform(
+  context: CompilerContext,
+): CompilerContext;
+
+export { skipRedundantNodesTransform as transform };

types/relay-compiler/relay-compiler-tests.ts

@@ -1,39 +1,47 @@
 import {
-    GraphQLCompilerContext,
-    transformASTSchema,
-    Parser as RelayParser,
+    CompilerContext,
+    Fragment,
+    Root,
     Printer as GraphQLIRPrinter,
+    Schema
 } from 'relay-compiler';
-
 import * as InlineFragmentsTransform from 'relay-compiler/lib/transforms/InlineFragmentsTransform';
 import * as SkipRedundantNodesTransform from 'relay-compiler/lib/transforms/SkipRedundantNodesTransform';
 import * as ApplyFragmentArgumentTransform from 'relay-compiler/lib/transforms/ApplyFragmentArgumentTransform';
 import * as FlattenTransform from 'relay-compiler/lib/transforms/FlattenTransform';
-import * as ConnectionFieldTransform from 'relay-compiler/lib/transforms/ConnectionFieldTransform';
+import * as ConnectionTransform from 'relay-compiler/lib/transforms/ConnectionTransform';
 import { getLanguagePlugin } from 'relay-compiler/lib/bin/RelayCompilerMain';
-import { visit } from 'relay-compiler/lib/core/GraphQLIRVisitor';
+import { visit } from 'relay-compiler/lib/core/IRVisitor';
 
-import { GraphQLSchema, DefinitionNode } from 'graphql';
+const TestSchema: Schema = (undefined as any) as Schema;
 
-const documentAsts: DefinitionNode[] = [];
-const schema: GraphQLSchema = (undefined as any) as GraphQLSchema;
+declare function parseGraphQLText(schema: Schema, text: string): {
+    definitions: ReadonlyArray<Fragment | Root>,
+    schema: Schema
+};
 
-const adjustedSchema = transformASTSchema(schema, [
+const schema = TestSchema.extend([
     /* GraphQL */ `
         directive @connection(key: String!) on FIELD
         directive @client on FIELD
     `,
 ]);
 
-const relayDocuments = RelayParser.transform(adjustedSchema, documentAsts);
-const queryCompilerContext = new GraphQLCompilerContext(adjustedSchema)
-    .addAll(relayDocuments)
+const text = `
+    fragment ScalarField on User {
+      traits
+    }
+  `;
+
+const { definitions, schema: extendedSchema } = parseGraphQLText(schema, text);
+const queryCompilerContext = new CompilerContext(extendedSchema)
+    .addAll(definitions)
     .applyTransforms([
         ApplyFragmentArgumentTransform.transform,
         InlineFragmentsTransform.transform,
         FlattenTransform.transformWithOptions({ flattenAbstractTypes: false }),
         SkipRedundantNodesTransform.transform,
-        ConnectionFieldTransform.transform,
+        ConnectionTransform.transform,
     ]);
 
 queryCompilerContext.documents().map(doc => GraphQLIRPrinter.print(doc));

types/relay-config/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://facebook.github.io/relay/
 // Definitions by: Eloy Durán <https://github.com/DefinitelyTyped>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 3.0
+// TypeScript Version: 3.4
 
 import { Config } from 'relay-compiler/lib/bin/RelayCompilerMain';