fix(Flowtype): Update flowtype definitions due changes in graphql-js@…

…0.8.1 Closes #35
graphql-compose · Nov 14, 2016 · 3a9fede · 3a9fede
1 parent 95e149d
commit 3a9fede
Show file tree

Hide file tree

Showing 6 changed files with 79 additions and 83 deletions.
diff --git a/src/definition.js b/src/definition.js
@@ -3,7 +3,7 @@
 
 import type {
   GraphQLFieldConfigArgumentMap as _GraphQLFieldConfigArgumentMap,
-  GraphQLFieldResolveFn as _GraphQLFieldResolveFn,
+  GraphQLFieldResolver as _GraphQLFieldResolver,
   GraphQLResolveInfo as _GraphQLResolveInfo,
   GraphQLArgumentConfig as _GraphQLArgumentConfig,
   GraphQLOutputType as _GraphQLOutputType,
@@ -14,44 +14,40 @@ import type {
   GraphQLFieldConfig as _GraphQLFieldConfig,
   GraphQLFieldConfigMap as _GraphQLFieldConfigMap,
   GraphQLType as _GraphQLType,
-  InputObjectConfig as _InputObjectConfig,
-  InputObjectField as _InputObjectField,
-  InputObjectFieldConfig as _InputObjectFieldConfig,
-  InputObjectConfigFieldMap as _InputObjectConfigFieldMap,
-  //  InputObjectConfigFieldMapThunk as _InputObjectConfigFieldMapThunk,
+  GraphQLInputObjectTypeConfig as _GraphQLInputObjectTypeConfig,
+  GraphQLInputField as _GraphQLInputField,
+  GraphQLInputFieldConfig as _GraphQLInputFieldConfig,
+  GraphQLInputFieldConfigMap as _GraphQLInputFieldConfigMap,
   GraphQLInterfaceType as _GraphQLInterfaceType,
   GraphQLInputType as _GraphQLInputType,
   GraphQLNullableType as _GraphQLNullableType,
 } from 'graphql/type/definition.js';
 
-import type Resolver from './resolver/resolver';
-import type ResolverList from './resolver/resolverList';
+import type Resolver from './resolver';
 import type InputTypeComposer from './inputTypeComposer';
 
-
+export type Thunk<T> = (() => T) | T;
 export type ObjectMap = { [optName: string]: mixed };
 export type ProjectionType = { [fieldName: string]: true | ProjectionType };
 export type ProjectionMapType = { [relationfieldName: string]: ProjectionType };
 
 // GRAPHQL RE-EXPORT --------------------
 export type GraphQLType = _GraphQLType;
 export type GraphQLObjectType = _GraphQLObjectType;
-export type GraphQLObjectTypeConfig = _GraphQLObjectTypeConfig;
+export type GraphQLObjectTypeConfig = _GraphQLObjectTypeConfig<*>;
 export type GraphQLNullableType = _GraphQLNullableType;
 export type GraphQLInterfaceType = _GraphQLInterfaceType;
-export type GraphQLInterfacesThunk = () => Array<GraphQLInterfaceType>;
 export type GraphQLOutputType = _GraphQLOutputType;
-export type InputObjectField = _InputObjectField;
+export type GraphQLInputField = _GraphQLInputField;
 export type GraphQLInputObjectType = _GraphQLInputObjectType;
-export type InputObjectConfig = _InputObjectConfig;
+export type GraphQLInputObjectTypeConfig = _GraphQLInputObjectTypeConfig;
 export type GraphQLFieldConfigArgumentMap = _GraphQLFieldConfigArgumentMap;
-export type GraphQLFieldResolveFn = _GraphQLFieldResolveFn<*>;
+export type GraphQLFieldResolver = _GraphQLFieldResolver<*>;
 export type GraphQLResolveInfo = _GraphQLResolveInfo;
 export type GraphQLArgumentConfig = _GraphQLArgumentConfig;
 export type GraphQLNamedType = _GraphQLNamedType;
 export type GraphQLFieldConfig = _GraphQLFieldConfig<*>;
 export type GraphQLFieldConfigMap = _GraphQLFieldConfigMap<*>;
-export type GraphQLFieldConfigMapThunk = () => GraphQLFieldConfigMap;
 export type ResolveParams = {
   source: mixed,
   args: {[argName: string]: mixed},
@@ -60,9 +56,8 @@ export type ResolveParams = {
   projection: ProjectionType,
   [opt: string]: mixed,
 };
-export type InputObjectFieldConfig = _InputObjectFieldConfig;
-export type InputObjectConfigFieldMap = _InputObjectConfigFieldMap;
-export type InputObjectConfigFieldMapThunk = () => InputObjectConfigFieldMap; // _InputObjectConfigFieldMapThunk;
+export type GraphQLInputFieldConfig = _GraphQLInputFieldConfig;
+export type GraphQLInputFieldConfigMap = _GraphQLInputFieldConfigMap;
 export type GraphQLInputType = _GraphQLInputType;
 
 export type GraphQLObjectTypeExtended = GraphQLObjectType & {
@@ -75,8 +70,7 @@ export type GraphQLObjectTypeExtended = GraphQLObjectType & {
 };
 
 // RELATION -----------------------------
-export type RelationThunkMap = { [fieldName: string]: RelationThunk };
-export type RelationThunk = () => RelationOpts;
+export type RelationThunkMap = { [fieldName: string]: Thunk<RelationOpts> };
 export type RelationOpts = {
   resolver: Resolver,
   args?: RelationArgsMapper,
@@ -107,7 +101,7 @@ export type ResolverMWOutputType = (next: ResolverMWOutputTypeFn) => ResolverMWO
 export type ResolverFieldConfig = {
   type: GraphQLOutputType,
   args: GraphQLFieldConfigArgumentMap,
-  resolve: GraphQLFieldResolveFn,
+  resolve: GraphQLFieldResolver,
   name?: ?string,
 };
 

diff --git a/src/inputTypeComposer.js b/src/inputTypeComposer.js
@@ -11,19 +11,19 @@ import TypeMapper from './typeMapper';
 import { typeByPath } from './typeByPath';
 
 import type {
-  InputObjectConfig,
-  InputObjectFieldConfig,
-  InputObjectConfigFieldMap,
-  InputObjectConfigFieldMapThunk,
-  InputObjectField,
+  Thunk,
+  GraphQLInputObjectTypeConfig,
+  GraphQLInputFieldConfig,
+  GraphQLInputFieldConfigMap,
+  GraphQLInputField,
   GraphQLInputType,
 } from './definition';
 
 
 export default class InputTypeComposer {
   gqType: GraphQLInputObjectType;
 
-  static create(opts: InputObjectConfig | string | GraphQLInputObjectType) {
+  static create(opts: GraphQLInputObjectTypeConfig | string | GraphQLInputObjectType) {
     let ITC;
 
     if (isString(opts)) {
@@ -54,6 +54,7 @@ export default class InputTypeComposer {
 
       // $FlowFixMe
       if (isObject(opts.fields)) {
+        // $FlowFixMe
         ITC.addFields(opts.fields);
       }
     } else {
@@ -74,8 +75,8 @@ export default class InputTypeComposer {
    * Get fields from a GraphQL type
    * WARNING: this method read an internal GraphQL instance variable.
    */
-  getFields(): InputObjectConfigFieldMap {
-    const fields: InputObjectConfigFieldMapThunk | InputObjectConfigFieldMap
+  getFields(): GraphQLInputFieldConfigMap {
+    const fields: Thunk<GraphQLInputFieldConfigMap>
       = this.gqType._typeConfig.fields;
 
     const fieldMap:mixed = resolveMaybeThunk(fields);
@@ -99,7 +100,7 @@ export default class InputTypeComposer {
    * Completely replace all fields in GraphQL type
    * WARNING: this method rewrite an internal GraphQL instance variable.
    */
-  setFields(fields: InputObjectConfigFieldMap): void {
+  setFields(fields: GraphQLInputFieldConfigMap): void {
     const prepearedFields = TypeMapper.convertInputFieldConfigMap(
       fields,
       this.getTypeName()
@@ -109,29 +110,29 @@ export default class InputTypeComposer {
     delete this.gqType._fields; // if schema was builded, delete defineFieldMap
   }
 
-  setField(fieldName: string, fieldConfig: InputObjectFieldConfig) {
+  setField(fieldName: string, fieldConfig: GraphQLInputFieldConfig) {
     this.addFields({ [fieldName]: fieldConfig });
   }
 
   /**
   * @deprecated 2.0.0
   */
-  addField(fieldName: string, fieldConfig: InputObjectFieldConfig) {
+  addField(fieldName: string, fieldConfig: GraphQLInputFieldConfig) {
     deprecate('Use InputTypeComposer.setField() or plural addFields({}) instead.');
     this.addFields({ [fieldName]: fieldConfig });
   }
 
   /**
    * Add new fields or replace existed in a GraphQL type
    */
-  addFields(newFields: InputObjectConfigFieldMap) {
+  addFields(newFields: GraphQLInputFieldConfigMap) {
     this.setFields(Object.assign({}, this.getFields(), newFields));
   }
 
   /**
    * Get fieldConfig by name
    */
-  getField(fieldName: string): ?InputObjectField {
+  getField(fieldName: string): ?GraphQLInputFieldConfig {
     const fields = this.getFields();
 
     if (fields[fieldName]) {

diff --git a/src/resolver.js b/src/resolver.js
@@ -158,7 +158,7 @@ export default class Resolver {
     return this.outputType;
   }
 
-  setOutputType(gqType: GraphQLOutputType | string) {
+  setOutputType(gqType: GraphQLOutputType | string | TypeComposer | Resolver | InputTypeComposer) {
     let type;
 
     if (gqType instanceof TypeComposer) {
@@ -253,7 +253,7 @@ export default class Resolver {
   }
 
   wrap(cb: ?ResolverWrapFn, opts: ?ResolverOpts = {}): Resolver {
-    const prevResolver = this;
+    const prevResolver: Resolver = this;
     const newResolver = this.clone({
       name: 'wrap',
       parent: prevResolver,

diff --git a/src/toInputObjectType.js b/src/toInputObjectType.js
@@ -18,7 +18,7 @@ import type {
   GraphQLFieldConfig,
   GraphQLFieldConfigMap,
   GraphQLType,
-  InputObjectFieldConfig,
+  GraphQLInputFieldConfig,
   GraphQLInputType,
 } from './definition.js';
 
@@ -88,7 +88,7 @@ export type convertInputObjectFieldOpts = {
 export function convertInputObjectField(
   field: GraphQLFieldConfig,
   opts: convertInputObjectFieldOpts
-): InputObjectFieldConfig {
+): GraphQLInputFieldConfig {
   let fieldType: GraphQLType = field.type;
 
   const wrappers = [];

diff --git a/src/typeComposer.js b/src/typeComposer.js
@@ -14,19 +14,17 @@ import TypeMapper from './typeMapper';
 import { typeByPath } from './typeByPath';
 
 import type {
+  Thunk,
   GraphQLFieldConfig,
   GraphQLFieldConfigMap,
-  GraphQLFieldConfigMapThunk,
   GraphQLOutputType,
   GraphQLObjectTypeConfig,
   GraphQLObjectTypeExtended,
   GraphQLInterfaceType,
-  GraphQLInterfacesThunk,
   GetRecordIdFn,
-  RelationThunk,
+  RelationOpts,
   RelationThunkMap,
   RelationArgsMapperFn,
-  RelationOpts,
   GraphQLFieldConfigArgumentMap,
   GraphQLArgumentConfig,
   ProjectionType,
@@ -87,7 +85,7 @@ export default class TypeComposer {
    * WARNING: this method read an internal GraphQL instance variable.
    */
   getFields(): GraphQLFieldConfigMap {
-    const fields: GraphQLFieldConfigMapThunk | GraphQLFieldConfigMap
+    const fields: Thunk<GraphQLFieldConfigMap>
       = this.gqType._typeConfig.fields;
 
     const fieldMap:mixed = resolveMaybeThunk(fields);
@@ -136,6 +134,7 @@ export default class TypeComposer {
   /**
    * Add new fields or replace existed in a GraphQL type
    */
+  // $FlowFixMe
   addFields(newFields: GraphQLFieldConfigMap): void {
     this.setFields(Object.assign({}, this.getFields(), newFields));
 
@@ -175,7 +174,7 @@ export default class TypeComposer {
     return fieldConfig;
   }
 
-  addRelation(fieldName: string, relationFn: RelationThunk): TypeComposer {
+  addRelation(fieldName: string, relationFn: Thunk<RelationOpts>): TypeComposer {
     if (!this.gqType._gqcRelations) {
       this.gqType._gqcRelations = {};
     }
@@ -205,7 +204,8 @@ export default class TypeComposer {
       throw new Error(`Cannot call buildRelation() for type ${this.getTypeName()}. `
                     + `Relation with name '${fieldName}' does not exist.`);
     }
-    const relationFn: RelationThunk = this.gqType._gqcRelations[fieldName];
+    const relationFn: Thunk<RelationOpts> = this.gqType._gqcRelations[fieldName];
+    // $FlowFixMe
     const relationOpts: RelationOpts = relationFn();
     this.addRelationRaw(fieldName, relationOpts.resolver, relationOpts);
   }
@@ -285,11 +285,12 @@ export default class TypeComposer {
    * WARNING: this method read an internal GraphQL instance variable.
    */
   getInterfaces(): Array<GraphQLInterfaceType> {
-    const interfaces: Array<GraphQLInterfaceType> | ?GraphQLInterfacesThunk
+    const interfaces: Array<GraphQLInterfaceType> | Thunk<?Array<GraphQLInterfaceType>>
+      // $FlowFixMe
       = this.gqType._typeConfig.interfaces || [];
 
     if (typeof interfaces === 'function') {
-      return interfaces();
+      return interfaces() || [];
     }
 
     return interfaces || [];