From dd737b6379fe39b271d2eb484eba3c66de27d316 Mon Sep 17 00:00:00 2001
From: yorkyao <yao.yao@arkie.ai>
Date: Wed, 21 Nov 2018 18:42:32 +0800
Subject: [PATCH] fix: CI failure; simplify graphql root type

---
 demo/root-type.ts                  | 376 ++++++++++++++---------------
 src/graphql-root-type-generator.ts |  16 +-
 2 files changed, 198 insertions(+), 194 deletions(-)

diff --git a/demo/root-type.ts b/demo/root-type.ts
index 95ea5c0..3099720 100644
--- a/demo/root-type.ts
+++ b/demo/root-type.ts
@@ -30,274 +30,274 @@ export interface Root<TContext = any> {
   users(input: {}, context: TContext, info: GraphQLResolveInfo): DeepPromisifyReturnType<GetResult<TContext>> | Promise<DeepPromisifyReturnType<GetResult<TContext>>>
 }
 
-export interface TypeLiteral<TContext> {
-  typeLiteralMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  typeLiteralMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeLiteral<TContext = any> {
+  typeLiteralMember1: number
+  typeLiteralMember2: string
 }
 
-export interface Interface<TContext> {
-  interfaceMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  interfaceMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface Interface<TContext = any> {
+  interfaceMember1: number
+  interfaceMember2: string
 }
 
-export interface TypeUnion1<TContext> {
-  typeLiteralMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  typeLiteralMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  typeUnionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeUnion1<TContext = any> {
+  typeLiteralMember1: number
+  typeLiteralMember2: string
+  typeUnionMember1: number
+  typeUnionMember2: string
 }
 
-export interface TypeUnion2<TContext> {
-  kind(input: {}, context: TContext, info: GraphQLResolveInfo): StringEnum | Promise<StringEnum>
-  typeUnionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeUnion2<TContext = any> {
+  kind: StringEnum
+  typeUnionMember1: string
+  typeUnionMember2: string
 }
 
-export interface TypeUnion3<TContext> {
-  kind(input: {}, context: TContext, info: GraphQLResolveInfo): NumberEnum | Promise<NumberEnum>
-  typeUnionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeUnion3<TContext = any> {
+  kind: NumberEnum
+  typeUnionMember1: string
+  typeUnionMember2: string
 }
 
-export interface TypeUnion4<TContext> {
-  kind(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeUnion4<TContext = any> {
+  kind: string
+  typeUnionMember1: string
+  typeUnionMember2: string
 }
 
-export type TypeUnion5<TContext> = TypeLiteral<TContext> | Interface<TContext>
+export type TypeUnion5<TContext = any> = TypeLiteral<TContext> | Interface<TContext>
 
-export type TypeUnion8<TContext> = string | string | null | boolean
+export type TypeUnion8<TContext = any> = string | string | null | boolean
 
-export interface TypeUnion<TContext> {
-  typeUnionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion1<TContext> | Promise<TypeUnion1<TContext>>
-  typeUnionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion2<TContext> | Promise<TypeUnion2<TContext>>
-  typeUnionMember3(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion3<TContext> | Promise<TypeUnion3<TContext>>
-  typeUnionMember4(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion4<TContext> | Promise<TypeUnion4<TContext>>
-  typeUnionMember5(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion5<TContext> | Promise<TypeUnion5<TContext>>
-  typeUnionMember6(input: {}, context: TContext, info: GraphQLResolveInfo): string | null | boolean | Promise<string | null | boolean>
-  typeUnionMember7(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember8(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion8<TContext> | Promise<TypeUnion8<TContext>>
-  typeUnionMember9(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion9 | Promise<TypeUnion9>
+export interface TypeUnion<TContext = any> {
+  typeUnionMember1: TypeUnion1<TContext>
+  typeUnionMember2: TypeUnion2<TContext>
+  typeUnionMember3: TypeUnion3<TContext>
+  typeUnionMember4: TypeUnion4<TContext>
+  typeUnionMember5: TypeUnion5<TContext>
+  typeUnionMember6: string | null | boolean
+  typeUnionMember7: string
+  typeUnionMember8: TypeUnion8<TContext>
+  typeUnionMember9: TypeUnion9
 }
 
-export interface InterfaceExtends<TContext> {
-  interfaceExtendsMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  interfaceExtendsMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  interfaceMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  interfaceMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface InterfaceExtends<TContext = any> {
+  interfaceExtendsMember1: number
+  interfaceExtendsMember2: string
+  interfaceMember1: number
+  interfaceMember2: string
 }
 
-export interface TypeIntersection1<TContext> {
-  interfaceMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  interfaceMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeIntersectionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  typeIntersectionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeIntersection1<TContext = any> {
+  interfaceMember1: number
+  interfaceMember2: string
+  typeIntersectionMember1: number
+  typeIntersectionMember2: string
 }
 
-export interface TypeIntersection2<TContext> {
-  typeIntersectionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  typeIntersectionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeIntersectionMember3(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  typeIntersectionMember4(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeIntersection2<TContext = any> {
+  typeIntersectionMember1: number
+  typeIntersectionMember2: string
+  typeIntersectionMember3: number
+  typeIntersectionMember4: string
 }
 
-export interface TypeIntersection<TContext> {
-  typeIntersectionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): TypeIntersection1<TContext> | Promise<TypeIntersection1<TContext>>
-  typeIntersectionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): TypeIntersection2<TContext> | Promise<TypeIntersection2<TContext>>
-  typeIntersectionMember3(input: {}, context: TContext, info: GraphQLResolveInfo): any | Promise<any>
+export interface TypeIntersection<TContext = any> {
+  typeIntersectionMember1: TypeIntersection1<TContext>
+  typeIntersectionMember2: TypeIntersection2<TContext>
+  typeIntersectionMember3: any
 }
 
-export interface TypeUnionAndIntersection<TContext> {
-  typeIntersectionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  kind(input: {}, context: TContext, info: GraphQLResolveInfo): NumberEnum | Promise<NumberEnum>
-  typeUnionMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  typeUnionMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TypeUnionAndIntersection<TContext = any> {
+  typeIntersectionMember1: number
+  kind: NumberEnum
+  typeUnionMember1: string
+  typeUnionMember2: string
 }
 
-export interface TaggedField<TContext> {
-  taggedFieldMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  taggedFieldMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface TaggedField<TContext = any> {
+  taggedFieldMember1: number
+  taggedFieldMember2: string
 }
 
-export interface Enum<TContext> {
-  stringEnum(input: {}, context: TContext, info: GraphQLResolveInfo): StringEnum | Promise<StringEnum>
-  numberEnum(input: {}, context: TContext, info: GraphQLResolveInfo): NumberEnum | Promise<NumberEnum>
-  numberEnum2(input: {}, context: TContext, info: GraphQLResolveInfo): NumberEnum2 | Promise<NumberEnum2>
-  stringEnum2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface Enum<TContext = any> {
+  stringEnum: StringEnum
+  numberEnum: NumberEnum
+  numberEnum2: NumberEnum2
+  stringEnum2: string
 }
 
-export interface NumberType<TContext> {
-  numberMember(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  integerMember(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  uint32Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  int32Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  sint32Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  fixed32Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  sfixed32Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  uint64Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  int64Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  sint64Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  fixed64Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  sfixed64Member(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  floatMember(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  doubleMember(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  titleMember(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
+export interface NumberType<TContext = any> {
+  numberMember: number
+  integerMember: number
+  uint32Member: number
+  int32Member: number
+  sint32Member: number
+  fixed32Member: number
+  sfixed32Member: number
+  uint64Member: number
+  int64Member: number
+  sint64Member: number
+  fixed64Member: number
+  sfixed64Member: number
+  floatMember: number
+  doubleMember: number
+  titleMember: number
 }
 
-export interface StringType<TContext> {
-  stringMember(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface StringType<TContext = any> {
+  stringMember: string
 }
 
-export interface ArrayType<TContext> {
-  arrayType1(input: {}, context: TContext, info: GraphQLResolveInfo): Array<string> | Promise<Array<string>>
-  arrayType2(input: {}, context: TContext, info: GraphQLResolveInfo): Array<TypeLiteral<TContext>> | Promise<Array<TypeLiteral<TContext>>>
-  arrayType3(input: {}, context: TContext, info: GraphQLResolveInfo): Array<object> | Promise<Array<object>>
-  arrayType4(input: {}, context: TContext, info: GraphQLResolveInfo): Array<number> | Promise<Array<number>>
-  arrayType5(input: {}, context: TContext, info: GraphQLResolveInfo): Array<object> | Promise<Array<object>>
-  arrayType6(input: {}, context: TContext, info: GraphQLResolveInfo): Array<object> | Promise<Array<object>>
-  arrayType7(input: {}, context: TContext, info: GraphQLResolveInfo): Array<object> | Promise<Array<object>>
-  arrayType8(input: {}, context: TContext, info: GraphQLResolveInfo): Array<object> | Promise<Array<object>>
+export interface ArrayType<TContext = any> {
+  arrayType1: Array<string>
+  arrayType2: Array<TypeLiteral<TContext>>
+  arrayType3: Array<object>
+  arrayType4: Array<number>
+  arrayType5: Array<object>
+  arrayType6: Array<object>
+  arrayType7: Array<object>
+  arrayType8: Array<object>
 }
 
-export interface MapType7<TContext> {
-  foo(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface MapType7<TContext = any> {
+  foo: string
 }
 
-export interface MapType8<TContext> {
+export interface MapType8<TContext = any> {
 
 }
 
-export interface MapType<TContext> {
-  mapType(input: {}, context: TContext, info: GraphQLResolveInfo): { [name: string]: number } | Promise<{ [name: string]: number }>
-  mapType2(input: {}, context: TContext, info: GraphQLResolveInfo): { [name: string]: TypeLiteral<TContext> } | Promise<{ [name: string]: TypeLiteral<TContext> }>
-  mapType3(input: {}, context: TContext, info: GraphQLResolveInfo): { [name: string]: object } | Promise<{ [name: string]: object }>
-  mapType4(input: {}, context: TContext, info: GraphQLResolveInfo): { [name: string]: number } | Promise<{ [name: string]: number }>
-  mapType5(input: {}, context: TContext, info: GraphQLResolveInfo): { [name: string]: any } | Promise<{ [name: string]: any }>
-  mapType6(input: {}, context: TContext, info: GraphQLResolveInfo): object | Promise<object>
-  mapType7(input: {}, context: TContext, info: GraphQLResolveInfo): MapType7<TContext> | Promise<MapType7<TContext>>
-  mapType8(input: {}, context: TContext, info: GraphQLResolveInfo): MapType8<TContext> | Promise<MapType8<TContext>>
+export interface MapType<TContext = any> {
+  mapType: { [name: string]: number }
+  mapType2: { [name: string]: TypeLiteral<TContext> }
+  mapType3: { [name: string]: object }
+  mapType4: { [name: string]: number }
+  mapType5: { [name: string]: any }
+  mapType6: object
+  mapType7: MapType7<TContext>
+  mapType8: MapType8<TContext>
 }
 
-export interface Parameter<TContext> {
+export interface Parameter<TContext = any> {
   member1(input: { name: string, age: number }, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
   member2(input: { name?: string }, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
 }
 
-export interface DefaultValue<TContext> {
-  stringMember(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  numberMember(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  booleanMember(input: {}, context: TContext, info: GraphQLResolveInfo): boolean | Promise<boolean>
-  stringMember2(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  stringMember3(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  arrayMember(input: {}, context: TContext, info: GraphQLResolveInfo): Array<any> | Promise<Array<any>>
-  objectMember(input: {}, context: TContext, info: GraphQLResolveInfo): object | Promise<object>
-  numberMember1(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  objectMember2(input: {}, context: TContext, info: GraphQLResolveInfo): TypeLiteral<TContext> | Promise<TypeLiteral<TContext>>
+export interface DefaultValue<TContext = any> {
+  stringMember: string
+  numberMember: number
+  booleanMember: boolean
+  stringMember2: string
+  stringMember3: string
+  arrayMember: Array<any>
+  objectMember: object
+  numberMember1: number
+  objectMember2: TypeLiteral<TContext>
 }
 
-export type TypeReferenceMember2<TContext> = TypeLiteral<TContext>
+export type TypeReferenceMember2<TContext = any> = TypeLiteral<TContext>
 
-export interface ReferenceType<TContext> {
-  typeReferenceMember1(input: {}, context: TContext, info: GraphQLResolveInfo): TypeLiteral<TContext> | Promise<TypeLiteral<TContext>>
-  typeReferenceMember2(input: {}, context: TContext, info: GraphQLResolveInfo): TypeReferenceMember2<TContext> | Promise<TypeReferenceMember2<TContext>>
+export interface ReferenceType<TContext = any> {
+  typeReferenceMember1: TypeLiteral<TContext>
+  typeReferenceMember2: TypeReferenceMember2<TContext>
 }
 
-export interface ClassType1<TContext> {
-  classMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  classMember2(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
+export interface ClassType1<TContext = any> {
+  classMember1: string
+  classMember2: number
 }
 
-export interface ClassType2<TContext> {
-  classMember3(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  classMember4(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  classMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  classMember2(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
+export interface ClassType2<TContext = any> {
+  classMember3: string
+  classMember4: number
+  classMember1: string
+  classMember2: number
 }
 
-export interface ClassType3<TContext> {
-  classMember1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  classMember2(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  classMember3(input: {}, context: TContext, info: GraphQLResolveInfo): boolean | Promise<boolean>
-  classMember4(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  classMember5(input: {}, context: TContext, info: GraphQLResolveInfo): Array<string> | Promise<Array<string>>
-  classMember6(input: {}, context: TContext, info: GraphQLResolveInfo): object | Promise<object>
+export interface ClassType3<TContext = any> {
+  classMember1: string
+  classMember2: number
+  classMember3: boolean
+  classMember4: string
+  classMember5: Array<string>
+  classMember6: object
 }
 
-export interface ClassType<TContext> {
-  classType1(input: {}, context: TContext, info: GraphQLResolveInfo): ClassType1<TContext> | Promise<ClassType1<TContext>>
-  classType2(input: {}, context: TContext, info: GraphQLResolveInfo): ClassType2<TContext> | Promise<ClassType2<TContext>>
-  classType3(input: {}, context: TContext, info: GraphQLResolveInfo): ClassType3<TContext> | Promise<ClassType3<TContext>>
+export interface ClassType<TContext = any> {
+  classType1: ClassType1<TContext>
+  classType2: ClassType2<TContext>
+  classType3: ClassType3<TContext>
 }
 
-export interface Circular<TContext> {
-  children(input: {}, context: TContext, info: GraphQLResolveInfo): Array<Circular<TContext>> | Promise<Array<Circular<TContext>>>
+export interface Circular<TContext = any> {
+  children: Array<Circular<TContext>>
 }
 
-export interface EntryType<TContext> {
-  optionalMember(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  booleanMember(input: {}, context: TContext, info: GraphQLResolveInfo): boolean | Promise<boolean>
-  stringMember(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  numberType(input: {}, context: TContext, info: GraphQLResolveInfo): NumberType<TContext> | Promise<NumberType<TContext>>
-  arrayType(input: {}, context: TContext, info: GraphQLResolveInfo): ArrayType<TContext> | Promise<ArrayType<TContext>>
-  typeLiteral(input: {}, context: TContext, info: GraphQLResolveInfo): object | Promise<object>
-  referenceType(input: {}, context: TContext, info: GraphQLResolveInfo): ReferenceType<TContext> | Promise<ReferenceType<TContext>>
-  interfaceType(input: {}, context: TContext, info: GraphQLResolveInfo): Interface<TContext> | Promise<Interface<TContext>>
-  typeUnion(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnion<TContext> | Promise<TypeUnion<TContext>>
-  interfaceExtends(input: {}, context: TContext, info: GraphQLResolveInfo): InterfaceExtends<TContext> | Promise<InterfaceExtends<TContext>>
-  typeIntersection(input: {}, context: TContext, info: GraphQLResolveInfo): TypeIntersection<TContext> | Promise<TypeIntersection<TContext>>
-  typeUnionAndIntersection(input: {}, context: TContext, info: GraphQLResolveInfo): TypeUnionAndIntersection<TContext> | Promise<TypeUnionAndIntersection<TContext>>
-  mapType(input: {}, context: TContext, info: GraphQLResolveInfo): MapType<TContext> | Promise<MapType<TContext>>
-  taggedField(input: {}, context: TContext, info: GraphQLResolveInfo): TaggedField<TContext> | Promise<TaggedField<TContext>>
-  enum(input: {}, context: TContext, info: GraphQLResolveInfo): Enum<TContext> | Promise<Enum<TContext>>
-  stringNumber(input: {}, context: TContext, info: GraphQLResolveInfo): StringType<TContext> | Promise<StringType<TContext>>
-  id(input: {}, context: TContext, info: GraphQLResolveInfo): ID<TContext> | Promise<ID<TContext>>
-  parameter(input: {}, context: TContext, info: GraphQLResolveInfo): Parameter<TContext> | Promise<Parameter<TContext>>
-  optionalArrayMember(input: {}, context: TContext, info: GraphQLResolveInfo): Array<string> | Promise<Array<string>>
-  tupleType(input: {}, context: TContext, info: GraphQLResolveInfo): Array<string> | Promise<Array<string>>
-  defaultType(input: {}, context: TContext, info: GraphQLResolveInfo): DefaultValue<TContext> | Promise<DefaultValue<TContext>>
-  anyType(input: {}, context: TContext, info: GraphQLResolveInfo): any | Promise<any>
-  classType(input: {}, context: TContext, info: GraphQLResolveInfo): ClassType<TContext> | Promise<ClassType<TContext>>
-  circular(input: {}, context: TContext, info: GraphQLResolveInfo): Circular<TContext> | Promise<Circular<TContext>>
-  outerType(input: {}, context: TContext, info: GraphQLResolveInfo): OuterType<TContext> | Promise<OuterType<TContext>>
-  typeAlias(input: {}, context: TContext, info: GraphQLResolveInfo): TypeAlias<TContext> | Promise<TypeAlias<TContext>>
+export interface EntryType<TContext = any> {
+  optionalMember: string
+  booleanMember: boolean
+  stringMember: string
+  numberType: NumberType<TContext>
+  arrayType: ArrayType<TContext>
+  typeLiteral: object
+  referenceType: ReferenceType<TContext>
+  interfaceType: Interface<TContext>
+  typeUnion: TypeUnion<TContext>
+  interfaceExtends: InterfaceExtends<TContext>
+  typeIntersection: TypeIntersection<TContext>
+  typeUnionAndIntersection: TypeUnionAndIntersection<TContext>
+  mapType: MapType<TContext>
+  taggedField: TaggedField<TContext>
+  enum: Enum<TContext>
+  stringNumber: StringType<TContext>
+  id: ID<TContext>
+  parameter: Parameter<TContext>
+  optionalArrayMember: Array<string>
+  tupleType: Array<string>
+  defaultType: DefaultValue<TContext>
+  anyType: any
+  classType: ClassType<TContext>
+  circular: Circular<TContext>
+  outerType: OuterType<TContext>
+  typeAlias: TypeAlias<TContext>
 }
 
-export interface CreateInput<TContext> {
-  member1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
-  member2(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
-  member3(input: {}, context: TContext, info: GraphQLResolveInfo): CreateInputMember3<TContext> | Promise<CreateInputMember3<TContext>>
+export interface CreateInput<TContext = any> {
+  member1: string
+  member2: number
+  member3: CreateInputMember3<TContext>
 }
 
-export interface MutationResult<TContext> {
-  result(input: {}, context: TContext, info: GraphQLResolveInfo): boolean | Promise<boolean>
+export interface MutationResult<TContext = any> {
+  result: boolean
 }
 
-export interface GetResult<TContext> {
-  result(input: {}, context: TContext, info: GraphQLResolveInfo): Result<TContext> | Promise<Result<TContext>>
+export interface GetResult<TContext = any> {
+  result: Result<TContext>
 }
 
-export interface Result<TContext> {
-  member1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface Result<TContext = any> {
+  member1: string
   member2(input: { input: string }, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
 }
 
-export interface CreateInputMember3<TContext> {
-  member1(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface CreateInputMember3<TContext = any> {
+  member1: string
 }
 
-export interface TypeAlias<TContext> {
-  result(input: {}, context: TContext, info: GraphQLResolveInfo): Result2<TContext> | Promise<Result2<TContext>>
+export interface TypeAlias<TContext = any> {
+  result: Result2<TContext>
 }
 
-export type Result2<TContext> = Result3<TContext>
+export type Result2<TContext = any> = Result3<TContext>
 
-export interface Result3<TContext> {
-  result3(input: {}, context: TContext, info: GraphQLResolveInfo): string | Promise<string>
+export interface Result3<TContext = any> {
+  result3: string
 }
 
-export interface OuterType<TContext> {
-  outerType(input: {}, context: TContext, info: GraphQLResolveInfo): number | Promise<number>
+export interface OuterType<TContext = any> {
+  outerType: number
 }
 
 export interface ApolloResolvers<TContext = any> {
diff --git a/src/graphql-root-type-generator.ts b/src/graphql-root-type-generator.ts
index 28bdf65..474abff 100644
--- a/src/graphql-root-type-generator.ts
+++ b/src/graphql-root-type-generator.ts
@@ -23,10 +23,14 @@ export function generateGraphqlRootType(declarations: TypeDeclaration[], graphql
         const nonRootTypeMembers: string[] = []
         for (const member of typeDeclaration.members) {
           const memberType = getMemberType(member.type, referenceTypes, declarations)
-          const parameters = getMemberParameters(referenceTypes, declarations, member.parameters)
-          nonRootTypeMembers.push(`  ${member.name}(${parameters}, context: TContext, info: GraphQLResolveInfo): ${memberType} | Promise<${memberType}>`)
+          if (member.parameters) {
+            const parameters = getMemberParameters(referenceTypes, declarations, member.parameters)
+            nonRootTypeMembers.push(`  ${member.name}(${parameters}, context: TContext, info: GraphQLResolveInfo): ${memberType} | Promise<${memberType}>`)
+          } else {
+            nonRootTypeMembers.push(`  ${member.name}: ${memberType}`)
+          }
         }
-        nonRootTypes.push(`export interface ${typeDeclaration.name}<TContext> {
+        nonRootTypes.push(`export interface ${typeDeclaration.name}<TContext = any> {
 ${nonRootTypeMembers.join('\n')}
 }`)
       }
@@ -40,10 +44,10 @@ ${nonRootTypeMembers.join('\n')}
 ${resolverFields.join('\n')}
   },`)
     } else if (typeDeclaration.kind === 'reference') {
-      nonRootTypes.push(`export type ${typeDeclaration.newName}<TContext> = ${typeDeclaration.name}<TContext>`)
+      nonRootTypes.push(`export type ${typeDeclaration.newName}<TContext = any> = ${typeDeclaration.name}<TContext>`)
     } else if (typeDeclaration.kind === 'union') {
       const memberType = getMemberType(typeDeclaration, referenceTypes, declarations)
-      nonRootTypes.push(`export type ${typeDeclaration.name}<TContext> = ${memberType}`)
+      nonRootTypes.push(`export type ${typeDeclaration.name}<TContext = any> = ${memberType}`)
     } else if (typeDeclaration.kind === 'string') {
       if (typeDeclaration.enums && !isNativeType(typeDeclaration.name)) {
         referenceTypes.push(typeDeclaration)
@@ -99,7 +103,7 @@ ${resolveResults.join('\n')}
 
 type ReferenceType = EnumType | StringDeclaration | EnumDeclaration
 
-export function getReferenceTypeImports(referenceTypes: ReferenceType[], graphqlRootTypePath: string) {
+function getReferenceTypeImports(referenceTypes: ReferenceType[], graphqlRootTypePath: string) {
   const map: { [name: string]: string[] } = {}
   for (const referenceType of referenceTypes) {
     const file = referenceType.position.file