▽

Source file src/github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated/exec.go

Documentation: github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated

     1  // Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
     2  
     3  package generated
     4  
     5  import (
     6  	"bytes"
     7  	"context"
     8  	"errors"
     9  	"fmt"
    10  	"strconv"
    11  	"sync"
    12  	"sync/atomic"
    13  
    14  	"github.com/99designs/gqlgen/graphql"
    15  	"github.com/99designs/gqlgen/graphql/introspection"
    16  	"github.com/99designs/gqlgen/plugin/federation/fedruntime"
    17  	gqlparser "github.com/vektah/gqlparser/v2"
    18  	"github.com/vektah/gqlparser/v2/ast"
    19  )
    20  
    21  // region    ************************** generated!.gotpl **************************
    22  
    23  // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
    24  func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
    25  	return &executableSchema{
    26  		schema:     cfg.Schema,
    27  		resolvers:  cfg.Resolvers,
    28  		directives: cfg.Directives,
    29  		complexity: cfg.Complexity,
    30  	}
    31  }
    32  
    33  type Config struct {
    34  	Schema     *ast.Schema
    35  	Resolvers  ResolverRoot
    36  	Directives DirectiveRoot
    37  	Complexity ComplexityRoot
    38  }
    39  
    40  type ResolverRoot interface {
    41  	Entity() EntityResolver
    42  }
    43  
    44  type DirectiveRoot struct {
    45  	EntityResolver func(ctx context.Context, obj interface{}, next graphql.Resolver, multi *bool) (res interface{}, err error)
    46  }
    47  
    48  type ComplexityRoot struct {
    49  	Entity struct {
    50  		FindHelloByName                            func(childComplexity int, name string) int
    51  		FindHelloMultiSingleKeysByKey1AndKey2      func(childComplexity int, key1 string, key2 string) int
    52  		FindHelloWithErrorsByName                  func(childComplexity int, name string) int
    53  		FindManyMultiHelloByNames                  func(childComplexity int, reps []*MultiHelloByNamesInput) int
    54  		FindManyMultiHelloMultipleRequiresByNames  func(childComplexity int, reps []*MultiHelloMultipleRequiresByNamesInput) int
    55  		FindManyMultiHelloRequiresByNames          func(childComplexity int, reps []*MultiHelloRequiresByNamesInput) int
    56  		FindManyMultiHelloWithErrorByNames         func(childComplexity int, reps []*MultiHelloWithErrorByNamesInput) int
    57  		FindManyMultiPlanetRequiresNestedByNames   func(childComplexity int, reps []*MultiPlanetRequiresNestedByNamesInput) int
    58  		FindPlanetMultipleRequiresByName           func(childComplexity int, name string) int
    59  		FindPlanetRequiresByName                   func(childComplexity int, name string) int
    60  		FindPlanetRequiresNestedByName             func(childComplexity int, name string) int
    61  		FindWorldByHelloNameAndFoo                 func(childComplexity int, helloName string, foo string) int
    62  		FindWorldNameByName                        func(childComplexity int, name string) int
    63  		FindWorldWithMultipleKeysByBar             func(childComplexity int, bar int) int
    64  		FindWorldWithMultipleKeysByHelloNameAndFoo func(childComplexity int, helloName string, foo string) int
    65  	}
    66  
    67  	Hello struct {
    68  		Name      func(childComplexity int) int
    69  		Secondary func(childComplexity int) int
    70  	}
    71  
    72  	HelloMultiSingleKeys struct {
    73  		Key1 func(childComplexity int) int
    74  		Key2 func(childComplexity int) int
    75  	}
    76  
    77  	HelloWithErrors struct {
    78  		Name func(childComplexity int) int
    79  	}
    80  
    81  	MultiHello struct {
    82  		Name func(childComplexity int) int
    83  	}
    84  
    85  	MultiHelloMultipleRequires struct {
    86  		Key1 func(childComplexity int) int
    87  		Key2 func(childComplexity int) int
    88  		Key3 func(childComplexity int) int
    89  		Name func(childComplexity int) int
    90  	}
    91  
    92  	MultiHelloRequires struct {
    93  		Key1 func(childComplexity int) int
    94  		Key2 func(childComplexity int) int
    95  		Name func(childComplexity int) int
    96  	}
    97  
    98  	MultiHelloWithError struct {
    99  		Name func(childComplexity int) int
   100  	}
   101  
   102  	MultiPlanetRequiresNested struct {
   103  		Name  func(childComplexity int) int
   104  		Size  func(childComplexity int) int
   105  		World func(childComplexity int) int
   106  	}
   107  
   108  	PlanetMultipleRequires struct {
   109  		Density  func(childComplexity int) int
   110  		Diameter func(childComplexity int) int
   111  		Name     func(childComplexity int) int
   112  		Weight   func(childComplexity int) int
   113  	}
   114  
   115  	PlanetRequires struct {
   116  		Diameter func(childComplexity int) int
   117  		Name     func(childComplexity int) int
   118  		Size     func(childComplexity int) int
   119  	}
   120  
   121  	PlanetRequiresNested struct {
   122  		Name   func(childComplexity int) int
   123  		Size   func(childComplexity int) int
   124  		Sizes  func(childComplexity int) int
   125  		World  func(childComplexity int) int
   126  		Worlds func(childComplexity int) int
   127  	}
   128  
   129  	Query struct {
   130  		__resolve__service func(childComplexity int) int
   131  		__resolve_entities func(childComplexity int, representations []map[string]interface{}) int
   132  	}
   133  
   134  	World struct {
   135  		Bar   func(childComplexity int) int
   136  		Foo   func(childComplexity int) int
   137  		Hello func(childComplexity int) int
   138  	}
   139  
   140  	WorldName struct {
   141  		Name func(childComplexity int) int
   142  	}
   143  
   144  	WorldWithMultipleKeys struct {
   145  		Bar   func(childComplexity int) int
   146  		Foo   func(childComplexity int) int
   147  		Hello func(childComplexity int) int
   148  	}
   149  
   150  	_Service struct {
   151  		SDL func(childComplexity int) int
   152  	}
   153  }
   154  
   155  type EntityResolver interface {
   156  	FindHelloByName(ctx context.Context, name string) (*Hello, error)
   157  	FindHelloMultiSingleKeysByKey1AndKey2(ctx context.Context, key1 string, key2 string) (*HelloMultiSingleKeys, error)
   158  	FindHelloWithErrorsByName(ctx context.Context, name string) (*HelloWithErrors, error)
   159  	FindManyMultiHelloByNames(ctx context.Context, reps []*MultiHelloByNamesInput) ([]*MultiHello, error)
   160  	FindManyMultiHelloMultipleRequiresByNames(ctx context.Context, reps []*MultiHelloMultipleRequiresByNamesInput) ([]*MultiHelloMultipleRequires, error)
   161  	FindManyMultiHelloRequiresByNames(ctx context.Context, reps []*MultiHelloRequiresByNamesInput) ([]*MultiHelloRequires, error)
   162  	FindManyMultiHelloWithErrorByNames(ctx context.Context, reps []*MultiHelloWithErrorByNamesInput) ([]*MultiHelloWithError, error)
   163  	FindManyMultiPlanetRequiresNestedByNames(ctx context.Context, reps []*MultiPlanetRequiresNestedByNamesInput) ([]*MultiPlanetRequiresNested, error)
   164  	FindPlanetMultipleRequiresByName(ctx context.Context, name string) (*PlanetMultipleRequires, error)
   165  	FindPlanetRequiresByName(ctx context.Context, name string) (*PlanetRequires, error)
   166  	FindPlanetRequiresNestedByName(ctx context.Context, name string) (*PlanetRequiresNested, error)
   167  	FindWorldByHelloNameAndFoo(ctx context.Context, helloName string, foo string) (*World, error)
   168  	FindWorldNameByName(ctx context.Context, name string) (*WorldName, error)
   169  	FindWorldWithMultipleKeysByHelloNameAndFoo(ctx context.Context, helloName string, foo string) (*WorldWithMultipleKeys, error)
   170  	FindWorldWithMultipleKeysByBar(ctx context.Context, bar int) (*WorldWithMultipleKeys, error)
   171  }
   172  
   173  type executableSchema struct {
   174  	schema     *ast.Schema
   175  	resolvers  ResolverRoot
   176  	directives DirectiveRoot
   177  	complexity ComplexityRoot
   178  }
   179  
   180  func (e *executableSchema) Schema() *ast.Schema {
   181  	if e.schema != nil {
   182  		return e.schema
   183  	}
   184  	return parsedSchema
   185  }
   186  
   187  func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
   188  	ec := executionContext{nil, e, 0, 0, nil}
   189  	_ = ec
   190  	switch typeName + "." + field {
   191  
   192  	case "Entity.findHelloByName":
   193  		if e.complexity.Entity.FindHelloByName == nil {
   194  			break
   195  		}
   196  
   197  		args, err := ec.field_Entity_findHelloByName_args(context.TODO(), rawArgs)
   198  		if err != nil {
   199  			return 0, false
   200  		}
   201  
   202  		return e.complexity.Entity.FindHelloByName(childComplexity, args["name"].(string)), true
   203  
   204  	case "Entity.findHelloMultiSingleKeysByKey1AndKey2":
   205  		if e.complexity.Entity.FindHelloMultiSingleKeysByKey1AndKey2 == nil {
   206  			break
   207  		}
   208  
   209  		args, err := ec.field_Entity_findHelloMultiSingleKeysByKey1AndKey2_args(context.TODO(), rawArgs)
   210  		if err != nil {
   211  			return 0, false
   212  		}
   213  
   214  		return e.complexity.Entity.FindHelloMultiSingleKeysByKey1AndKey2(childComplexity, args["key1"].(string), args["key2"].(string)), true
   215  
   216  	case "Entity.findHelloWithErrorsByName":
   217  		if e.complexity.Entity.FindHelloWithErrorsByName == nil {
   218  			break
   219  		}
   220  
   221  		args, err := ec.field_Entity_findHelloWithErrorsByName_args(context.TODO(), rawArgs)
   222  		if err != nil {
   223  			return 0, false
   224  		}
   225  
   226  		return e.complexity.Entity.FindHelloWithErrorsByName(childComplexity, args["name"].(string)), true
   227  
   228  	case "Entity.findManyMultiHelloByNames":
   229  		if e.complexity.Entity.FindManyMultiHelloByNames == nil {
   230  			break
   231  		}
   232  
   233  		args, err := ec.field_Entity_findManyMultiHelloByNames_args(context.TODO(), rawArgs)
   234  		if err != nil {
   235  			return 0, false
   236  		}
   237  
   238  		return e.complexity.Entity.FindManyMultiHelloByNames(childComplexity, args["reps"].([]*MultiHelloByNamesInput)), true
   239  
   240  	case "Entity.findManyMultiHelloMultipleRequiresByNames":
   241  		if e.complexity.Entity.FindManyMultiHelloMultipleRequiresByNames == nil {
   242  			break
   243  		}
   244  
   245  		args, err := ec.field_Entity_findManyMultiHelloMultipleRequiresByNames_args(context.TODO(), rawArgs)
   246  		if err != nil {
   247  			return 0, false
   248  		}
   249  
   250  		return e.complexity.Entity.FindManyMultiHelloMultipleRequiresByNames(childComplexity, args["reps"].([]*MultiHelloMultipleRequiresByNamesInput)), true
   251  
   252  	case "Entity.findManyMultiHelloRequiresByNames":
   253  		if e.complexity.Entity.FindManyMultiHelloRequiresByNames == nil {
   254  			break
   255  		}
   256  
   257  		args, err := ec.field_Entity_findManyMultiHelloRequiresByNames_args(context.TODO(), rawArgs)
   258  		if err != nil {
   259  			return 0, false
   260  		}
   261  
   262  		return e.complexity.Entity.FindManyMultiHelloRequiresByNames(childComplexity, args["reps"].([]*MultiHelloRequiresByNamesInput)), true
   263  
   264  	case "Entity.findManyMultiHelloWithErrorByNames":
   265  		if e.complexity.Entity.FindManyMultiHelloWithErrorByNames == nil {
   266  			break
   267  		}
   268  
   269  		args, err := ec.field_Entity_findManyMultiHelloWithErrorByNames_args(context.TODO(), rawArgs)
   270  		if err != nil {
   271  			return 0, false
   272  		}
   273  
   274  		return e.complexity.Entity.FindManyMultiHelloWithErrorByNames(childComplexity, args["reps"].([]*MultiHelloWithErrorByNamesInput)), true
   275  
   276  	case "Entity.findManyMultiPlanetRequiresNestedByNames":
   277  		if e.complexity.Entity.FindManyMultiPlanetRequiresNestedByNames == nil {
   278  			break
   279  		}
   280  
   281  		args, err := ec.field_Entity_findManyMultiPlanetRequiresNestedByNames_args(context.TODO(), rawArgs)
   282  		if err != nil {
   283  			return 0, false
   284  		}
   285  
   286  		return e.complexity.Entity.FindManyMultiPlanetRequiresNestedByNames(childComplexity, args["reps"].([]*MultiPlanetRequiresNestedByNamesInput)), true
   287  
   288  	case "Entity.findPlanetMultipleRequiresByName":
   289  		if e.complexity.Entity.FindPlanetMultipleRequiresByName == nil {
   290  			break
   291  		}
   292  
   293  		args, err := ec.field_Entity_findPlanetMultipleRequiresByName_args(context.TODO(), rawArgs)
   294  		if err != nil {
   295  			return 0, false
   296  		}
   297  
   298  		return e.complexity.Entity.FindPlanetMultipleRequiresByName(childComplexity, args["name"].(string)), true
   299  
   300  	case "Entity.findPlanetRequiresByName":
   301  		if e.complexity.Entity.FindPlanetRequiresByName == nil {
   302  			break
   303  		}
   304  
   305  		args, err := ec.field_Entity_findPlanetRequiresByName_args(context.TODO(), rawArgs)
   306  		if err != nil {
   307  			return 0, false
   308  		}
   309  
   310  		return e.complexity.Entity.FindPlanetRequiresByName(childComplexity, args["name"].(string)), true
   311  
   312  	case "Entity.findPlanetRequiresNestedByName":
   313  		if e.complexity.Entity.FindPlanetRequiresNestedByName == nil {
   314  			break
   315  		}
   316  
   317  		args, err := ec.field_Entity_findPlanetRequiresNestedByName_args(context.TODO(), rawArgs)
   318  		if err != nil {
   319  			return 0, false
   320  		}
   321  
   322  		return e.complexity.Entity.FindPlanetRequiresNestedByName(childComplexity, args["name"].(string)), true
   323  
   324  	case "Entity.findWorldByHelloNameAndFoo":
   325  		if e.complexity.Entity.FindWorldByHelloNameAndFoo == nil {
   326  			break
   327  		}
   328  
   329  		args, err := ec.field_Entity_findWorldByHelloNameAndFoo_args(context.TODO(), rawArgs)
   330  		if err != nil {
   331  			return 0, false
   332  		}
   333  
   334  		return e.complexity.Entity.FindWorldByHelloNameAndFoo(childComplexity, args["helloName"].(string), args["foo"].(string)), true
   335  
   336  	case "Entity.findWorldNameByName":
   337  		if e.complexity.Entity.FindWorldNameByName == nil {
   338  			break
   339  		}
   340  
   341  		args, err := ec.field_Entity_findWorldNameByName_args(context.TODO(), rawArgs)
   342  		if err != nil {
   343  			return 0, false
   344  		}
   345  
   346  		return e.complexity.Entity.FindWorldNameByName(childComplexity, args["name"].(string)), true
   347  
   348  	case "Entity.findWorldWithMultipleKeysByBar":
   349  		if e.complexity.Entity.FindWorldWithMultipleKeysByBar == nil {
   350  			break
   351  		}
   352  
   353  		args, err := ec.field_Entity_findWorldWithMultipleKeysByBar_args(context.TODO(), rawArgs)
   354  		if err != nil {
   355  			return 0, false
   356  		}
   357  
   358  		return e.complexity.Entity.FindWorldWithMultipleKeysByBar(childComplexity, args["bar"].(int)), true
   359  
   360  	case "Entity.findWorldWithMultipleKeysByHelloNameAndFoo":
   361  		if e.complexity.Entity.FindWorldWithMultipleKeysByHelloNameAndFoo == nil {
   362  			break
   363  		}
   364  
   365  		args, err := ec.field_Entity_findWorldWithMultipleKeysByHelloNameAndFoo_args(context.TODO(), rawArgs)
   366  		if err != nil {
   367  			return 0, false
   368  		}
   369  
   370  		return e.complexity.Entity.FindWorldWithMultipleKeysByHelloNameAndFoo(childComplexity, args["helloName"].(string), args["foo"].(string)), true
   371  
   372  	case "Hello.name":
   373  		if e.complexity.Hello.Name == nil {
   374  			break
   375  		}
   376  
   377  		return e.complexity.Hello.Name(childComplexity), true
   378  
   379  	case "Hello.secondary":
   380  		if e.complexity.Hello.Secondary == nil {
   381  			break
   382  		}
   383  
   384  		return e.complexity.Hello.Secondary(childComplexity), true
   385  
   386  	case "HelloMultiSingleKeys.key1":
   387  		if e.complexity.HelloMultiSingleKeys.Key1 == nil {
   388  			break
   389  		}
   390  
   391  		return e.complexity.HelloMultiSingleKeys.Key1(childComplexity), true
   392  
   393  	case "HelloMultiSingleKeys.key2":
   394  		if e.complexity.HelloMultiSingleKeys.Key2 == nil {
   395  			break
   396  		}
   397  
   398  		return e.complexity.HelloMultiSingleKeys.Key2(childComplexity), true
   399  
   400  	case "HelloWithErrors.name":
   401  		if e.complexity.HelloWithErrors.Name == nil {
   402  			break
   403  		}
   404  
   405  		return e.complexity.HelloWithErrors.Name(childComplexity), true
   406  
   407  	case "MultiHello.name":
   408  		if e.complexity.MultiHello.Name == nil {
   409  			break
   410  		}
   411  
   412  		return e.complexity.MultiHello.Name(childComplexity), true
   413  
   414  	case "MultiHelloMultipleRequires.key1":
   415  		if e.complexity.MultiHelloMultipleRequires.Key1 == nil {
   416  			break
   417  		}
   418  
   419  		return e.complexity.MultiHelloMultipleRequires.Key1(childComplexity), true
   420  
   421  	case "MultiHelloMultipleRequires.key2":
   422  		if e.complexity.MultiHelloMultipleRequires.Key2 == nil {
   423  			break
   424  		}
   425  
   426  		return e.complexity.MultiHelloMultipleRequires.Key2(childComplexity), true
   427  
   428  	case "MultiHelloMultipleRequires.key3":
   429  		if e.complexity.MultiHelloMultipleRequires.Key3 == nil {
   430  			break
   431  		}
   432  
   433  		return e.complexity.MultiHelloMultipleRequires.Key3(childComplexity), true
   434  
   435  	case "MultiHelloMultipleRequires.name":
   436  		if e.complexity.MultiHelloMultipleRequires.Name == nil {
   437  			break
   438  		}
   439  
   440  		return e.complexity.MultiHelloMultipleRequires.Name(childComplexity), true
   441  
   442  	case "MultiHelloRequires.key1":
   443  		if e.complexity.MultiHelloRequires.Key1 == nil {
   444  			break
   445  		}
   446  
   447  		return e.complexity.MultiHelloRequires.Key1(childComplexity), true
   448  
   449  	case "MultiHelloRequires.key2":
   450  		if e.complexity.MultiHelloRequires.Key2 == nil {
   451  			break
   452  		}
   453  
   454  		return e.complexity.MultiHelloRequires.Key2(childComplexity), true
   455  
   456  	case "MultiHelloRequires.name":
   457  		if e.complexity.MultiHelloRequires.Name == nil {
   458  			break
   459  		}
   460  
   461  		return e.complexity.MultiHelloRequires.Name(childComplexity), true
   462  
   463  	case "MultiHelloWithError.name":
   464  		if e.complexity.MultiHelloWithError.Name == nil {
   465  			break
   466  		}
   467  
   468  		return e.complexity.MultiHelloWithError.Name(childComplexity), true
   469  
   470  	case "MultiPlanetRequiresNested.name":
   471  		if e.complexity.MultiPlanetRequiresNested.Name == nil {
   472  			break
   473  		}
   474  
   475  		return e.complexity.MultiPlanetRequiresNested.Name(childComplexity), true
   476  
   477  	case "MultiPlanetRequiresNested.size":
   478  		if e.complexity.MultiPlanetRequiresNested.Size == nil {
   479  			break
   480  		}
   481  
   482  		return e.complexity.MultiPlanetRequiresNested.Size(childComplexity), true
   483  
   484  	case "MultiPlanetRequiresNested.world":
   485  		if e.complexity.MultiPlanetRequiresNested.World == nil {
   486  			break
   487  		}
   488  
   489  		return e.complexity.MultiPlanetRequiresNested.World(childComplexity), true
   490  
   491  	case "PlanetMultipleRequires.density":
   492  		if e.complexity.PlanetMultipleRequires.Density == nil {
   493  			break
   494  		}
   495  
   496  		return e.complexity.PlanetMultipleRequires.Density(childComplexity), true
   497  
   498  	case "PlanetMultipleRequires.diameter":
   499  		if e.complexity.PlanetMultipleRequires.Diameter == nil {
   500  			break
   501  		}
   502  
   503  		return e.complexity.PlanetMultipleRequires.Diameter(childComplexity), true
   504  
   505  	case "PlanetMultipleRequires.name":
   506  		if e.complexity.PlanetMultipleRequires.Name == nil {
   507  			break
   508  		}
   509  
   510  		return e.complexity.PlanetMultipleRequires.Name(childComplexity), true
   511  
   512  	case "PlanetMultipleRequires.weight":
   513  		if e.complexity.PlanetMultipleRequires.Weight == nil {
   514  			break
   515  		}
   516  
   517  		return e.complexity.PlanetMultipleRequires.Weight(childComplexity), true
   518  
   519  	case "PlanetRequires.diameter":
   520  		if e.complexity.PlanetRequires.Diameter == nil {
   521  			break
   522  		}
   523  
   524  		return e.complexity.PlanetRequires.Diameter(childComplexity), true
   525  
   526  	case "PlanetRequires.name":
   527  		if e.complexity.PlanetRequires.Name == nil {
   528  			break
   529  		}
   530  
   531  		return e.complexity.PlanetRequires.Name(childComplexity), true
   532  
   533  	case "PlanetRequires.size":
   534  		if e.complexity.PlanetRequires.Size == nil {
   535  			break
   536  		}
   537  
   538  		return e.complexity.PlanetRequires.Size(childComplexity), true
   539  
   540  	case "PlanetRequiresNested.name":
   541  		if e.complexity.PlanetRequiresNested.Name == nil {
   542  			break
   543  		}
   544  
   545  		return e.complexity.PlanetRequiresNested.Name(childComplexity), true
   546  
   547  	case "PlanetRequiresNested.size":
   548  		if e.complexity.PlanetRequiresNested.Size == nil {
   549  			break
   550  		}
   551  
   552  		return e.complexity.PlanetRequiresNested.Size(childComplexity), true
   553  
   554  	case "PlanetRequiresNested.sizes":
   555  		if e.complexity.PlanetRequiresNested.Sizes == nil {
   556  			break
   557  		}
   558  
   559  		return e.complexity.PlanetRequiresNested.Sizes(childComplexity), true
   560  
   561  	case "PlanetRequiresNested.world":
   562  		if e.complexity.PlanetRequiresNested.World == nil {
   563  			break
   564  		}
   565  
   566  		return e.complexity.PlanetRequiresNested.World(childComplexity), true
   567  
   568  	case "PlanetRequiresNested.worlds":
   569  		if e.complexity.PlanetRequiresNested.Worlds == nil {
   570  			break
   571  		}
   572  
   573  		return e.complexity.PlanetRequiresNested.Worlds(childComplexity), true
   574  
   575  	case "Query._service":
   576  		if e.complexity.Query.__resolve__service == nil {
   577  			break
   578  		}
   579  
   580  		return e.complexity.Query.__resolve__service(childComplexity), true
   581  
   582  	case "Query._entities":
   583  		if e.complexity.Query.__resolve_entities == nil {
   584  			break
   585  		}
   586  
   587  		args, err := ec.field_Query__entities_args(context.TODO(), rawArgs)
   588  		if err != nil {
   589  			return 0, false
   590  		}
   591  
   592  		return e.complexity.Query.__resolve_entities(childComplexity, args["representations"].([]map[string]interface{})), true
   593  
   594  	case "World.bar":
   595  		if e.complexity.World.Bar == nil {
   596  			break
   597  		}
   598  
   599  		return e.complexity.World.Bar(childComplexity), true
   600  
   601  	case "World.foo":
   602  		if e.complexity.World.Foo == nil {
   603  			break
   604  		}
   605  
   606  		return e.complexity.World.Foo(childComplexity), true
   607  
   608  	case "World.hello":
   609  		if e.complexity.World.Hello == nil {
   610  			break
   611  		}
   612  
   613  		return e.complexity.World.Hello(childComplexity), true
   614  
   615  	case "WorldName.name":
   616  		if e.complexity.WorldName.Name == nil {
   617  			break
   618  		}
   619  
   620  		return e.complexity.WorldName.Name(childComplexity), true
   621  
   622  	case "WorldWithMultipleKeys.bar":
   623  		if e.complexity.WorldWithMultipleKeys.Bar == nil {
   624  			break
   625  		}
   626  
   627  		return e.complexity.WorldWithMultipleKeys.Bar(childComplexity), true
   628  
   629  	case "WorldWithMultipleKeys.foo":
   630  		if e.complexity.WorldWithMultipleKeys.Foo == nil {
   631  			break
   632  		}
   633  
   634  		return e.complexity.WorldWithMultipleKeys.Foo(childComplexity), true
   635  
   636  	case "WorldWithMultipleKeys.hello":
   637  		if e.complexity.WorldWithMultipleKeys.Hello == nil {
   638  			break
   639  		}
   640  
   641  		return e.complexity.WorldWithMultipleKeys.Hello(childComplexity), true
   642  
   643  	case "_Service.sdl":
   644  		if e.complexity._Service.SDL == nil {
   645  			break
   646  		}
   647  
   648  		return e.complexity._Service.SDL(childComplexity), true
   649  
   650  	}
   651  	return 0, false
   652  }
   653  
   654  func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
   655  	rc := graphql.GetOperationContext(ctx)
   656  	ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
   657  	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
   658  		ec.unmarshalInputMultiHelloByNamesInput,
   659  		ec.unmarshalInputMultiHelloMultipleRequiresByNamesInput,
   660  		ec.unmarshalInputMultiHelloRequiresByNamesInput,
   661  		ec.unmarshalInputMultiHelloWithErrorByNamesInput,
   662  		ec.unmarshalInputMultiPlanetRequiresNestedByNamesInput,
   663  	)
   664  	first := true
   665  
   666  	switch rc.Operation.Operation {
   667  	case ast.Query:
   668  		return func(ctx context.Context) *graphql.Response {
   669  			var response graphql.Response
   670  			var data graphql.Marshaler
   671  			if first {
   672  				first = false
   673  				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
   674  				data = ec._Query(ctx, rc.Operation.SelectionSet)
   675  			} else {
   676  				if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
   677  					result := <-ec.deferredResults
   678  					atomic.AddInt32(&ec.pendingDeferred, -1)
   679  					data = result.Result
   680  					response.Path = result.Path
   681  					response.Label = result.Label
   682  					response.Errors = result.Errors
   683  				} else {
   684  					return nil
   685  				}
   686  			}
   687  			var buf bytes.Buffer
   688  			data.MarshalGQL(&buf)
   689  			response.Data = buf.Bytes()
   690  			if atomic.LoadInt32(&ec.deferred) > 0 {
   691  				hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
   692  				response.HasNext = &hasNext
   693  			}
   694  
   695  			return &response
   696  		}
   697  
   698  	default:
   699  		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
   700  	}
   701  }
   702  
   703  type executionContext struct {
   704  	*graphql.OperationContext
   705  	*executableSchema
   706  	deferred        int32
   707  	pendingDeferred int32
   708  	deferredResults chan graphql.DeferredResult
   709  }
   710  
   711  func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
   712  	atomic.AddInt32(&ec.pendingDeferred, 1)
   713  	go func() {
   714  		ctx := graphql.WithFreshResponseContext(dg.Context)
   715  		dg.FieldSet.Dispatch(ctx)
   716  		ds := graphql.DeferredResult{
   717  			Path:   dg.Path,
   718  			Label:  dg.Label,
   719  			Result: dg.FieldSet,
   720  			Errors: graphql.GetErrors(ctx),
   721  		}
   722  		// null fields should bubble up
   723  		if dg.FieldSet.Invalids > 0 {
   724  			ds.Result = graphql.Null
   725  		}
   726  		ec.deferredResults <- ds
   727  	}()
   728  }
   729  
   730  func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
   731  	if ec.DisableIntrospection {
   732  		return nil, errors.New("introspection disabled")
   733  	}
   734  	return introspection.WrapSchema(ec.Schema()), nil
   735  }
   736  
   737  func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
   738  	if ec.DisableIntrospection {
   739  		return nil, errors.New("introspection disabled")
   740  	}
   741  	return introspection.WrapTypeFromDef(ec.Schema(), ec.Schema().Types[name]), nil
   742  }
   743  
   744  var sources = []*ast.Source{
   745  	{Name: "../schema.graphql", Input: `directive @entityResolver(multi: Boolean) on OBJECT
   746  
   747  type Hello @key(fields: "name") {
   748      name: String!
   749      secondary: String!
   750  }
   751  
   752  type World @key(fields: "hello { name } foo   ") {
   753      foo: String!
   754      bar: Int!
   755      hello: Hello
   756  }
   757  
   758  type WorldWithMultipleKeys @key(fields: "hello { name } foo   ") @key(fields: "bar") {
   759      foo: String!
   760      bar: Int!
   761      hello: Hello
   762  }
   763  
   764  type WorldName @key(fields: "name") {
   765      name: String!
   766  }
   767  
   768  type HelloWithErrors @key(fields: "name") {
   769      name: String!
   770  }
   771  
   772  type PlanetRequires @key(fields: "name") {
   773      name: String!
   774      size: Int! @requires(fields: "diameter")
   775      diameter: Int!
   776  }
   777  
   778  type PlanetMultipleRequires @key(fields: "name") {
   779      name: String! @external
   780      diameter: Int! @external
   781      density: Int! @external
   782      weight: Int! @requires(fields: "diameter density")
   783  }
   784  
   785  type PlanetRequiresNested @key(fields: "name") {
   786      name: String! @external
   787      world: World! @external
   788      worlds: [World!] @external
   789      size: Int! @requires(fields: "world{ foo }")
   790      sizes: [Int!] @requires(fields: "worlds{ foo }")
   791  }
   792  
   793  type MultiPlanetRequiresNested @key(fields: "name") @entityResolver(multi: true) {
   794      name: String! @external
   795      world: World! @external
   796      size: Int! @requires(fields: "world{ foo }")
   797  }
   798  
   799  type MultiHello @key(fields: "name") @entityResolver(multi: true) {
   800      name: String!
   801  }
   802  
   803  type MultiHelloWithError @key(fields: "name") @entityResolver(multi: true) {
   804      name: String!
   805  }
   806  
   807  type HelloMultiSingleKeys @key(fields: "key1 key2") {
   808      key1: String!
   809      key2: String!
   810  }
   811  
   812  type MultiHelloRequires @key(fields: "name") @entityResolver(multi: true) {
   813      name: String! @external
   814      key1: String! @external
   815      key2: String! @requires(fields: "key1")
   816  }
   817  
   818  type MultiHelloMultipleRequires @key(fields: "name") @entityResolver(multi: true) {
   819      name: String! @external
   820      key1: String! @external
   821      key2: String! @external
   822      key3: String! @requires(fields: "key1 key2")
   823  }
   824  `, BuiltIn: false},
   825  	{Name: "../../../federation/directives.graphql", Input: `
   826  	directive @key(fields: _FieldSet!) repeatable on OBJECT | INTERFACE
   827  	directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
   828  	directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
   829  	directive @extends on OBJECT | INTERFACE
   830  	directive @external on FIELD_DEFINITION
   831  	scalar _Any
   832  	scalar _FieldSet
   833  `, BuiltIn: true},
   834  	{Name: "../../../federation/entity.graphql", Input: `
   835  # a union of all types that use the @key directive
   836  union _Entity = Hello | HelloMultiSingleKeys | HelloWithErrors | MultiHello | MultiHelloMultipleRequires | MultiHelloRequires | MultiHelloWithError | MultiPlanetRequiresNested | PlanetMultipleRequires | PlanetRequires | PlanetRequiresNested | World | WorldName | WorldWithMultipleKeys
   837  
   838  input MultiHelloByNamesInput {
   839  	Name: String!
   840  }
   841  
   842  input MultiHelloMultipleRequiresByNamesInput {
   843  	Name: String!
   844  }
   845  
   846  input MultiHelloRequiresByNamesInput {
   847  	Name: String!
   848  }
   849  
   850  input MultiHelloWithErrorByNamesInput {
   851  	Name: String!
   852  }
   853  
   854  input MultiPlanetRequiresNestedByNamesInput {
   855  	Name: String!
   856  }
   857  
   858  # fake type to build resolver interfaces for users to implement
   859  type Entity {
   860  		findHelloByName(name: String!,): Hello!
   861  	findHelloMultiSingleKeysByKey1AndKey2(key1: String!,key2: String!,): HelloMultiSingleKeys!
   862  	findHelloWithErrorsByName(name: String!,): HelloWithErrors!
   863  	findManyMultiHelloByNames(reps: [MultiHelloByNamesInput]!): [MultiHello]
   864  	findManyMultiHelloMultipleRequiresByNames(reps: [MultiHelloMultipleRequiresByNamesInput]!): [MultiHelloMultipleRequires]
   865  	findManyMultiHelloRequiresByNames(reps: [MultiHelloRequiresByNamesInput]!): [MultiHelloRequires]
   866  	findManyMultiHelloWithErrorByNames(reps: [MultiHelloWithErrorByNamesInput]!): [MultiHelloWithError]
   867  	findManyMultiPlanetRequiresNestedByNames(reps: [MultiPlanetRequiresNestedByNamesInput]!): [MultiPlanetRequiresNested]
   868  	findPlanetMultipleRequiresByName(name: String!,): PlanetMultipleRequires!
   869  	findPlanetRequiresByName(name: String!,): PlanetRequires!
   870  	findPlanetRequiresNestedByName(name: String!,): PlanetRequiresNested!
   871  	findWorldByHelloNameAndFoo(helloName: String!,foo: String!,): World!
   872  	findWorldNameByName(name: String!,): WorldName!
   873  	findWorldWithMultipleKeysByHelloNameAndFoo(helloName: String!,foo: String!,): WorldWithMultipleKeys!
   874  	findWorldWithMultipleKeysByBar(bar: Int!,): WorldWithMultipleKeys!
   875  
   876  }
   877  
   878  type _Service {
   879    sdl: String
   880  }
   881  
   882  extend type Query {
   883    _entities(representations: [_Any!]!): [_Entity]!
   884    _service: _Service!
   885  }
   886  `, BuiltIn: true},
   887  }
   888  var parsedSchema = gqlparser.MustLoadSchema(sources...)
   889  
   890  // endregion ************************** generated!.gotpl **************************
   891  
   892  // region    ***************************** args.gotpl *****************************
   893  
   894  func (ec *executionContext) dir_entityResolver_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   895  	var err error
   896  	args := map[string]interface{}{}
   897  	var arg0 *bool
   898  	if tmp, ok := rawArgs["multi"]; ok {
   899  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("multi"))
   900  		arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
   901  		if err != nil {
   902  			return nil, err
   903  		}
   904  	}
   905  	args["multi"] = arg0
   906  	return args, nil
   907  }
   908  
   909  func (ec *executionContext) field_Entity_findHelloByName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   910  	var err error
   911  	args := map[string]interface{}{}
   912  	var arg0 string
   913  	if tmp, ok := rawArgs["name"]; ok {
   914  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
   915  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   916  		if err != nil {
   917  			return nil, err
   918  		}
   919  	}
   920  	args["name"] = arg0
   921  	return args, nil
   922  }
   923  
   924  func (ec *executionContext) field_Entity_findHelloMultiSingleKeysByKey1AndKey2_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   925  	var err error
   926  	args := map[string]interface{}{}
   927  	var arg0 string
   928  	if tmp, ok := rawArgs["key1"]; ok {
   929  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key1"))
   930  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   931  		if err != nil {
   932  			return nil, err
   933  		}
   934  	}
   935  	args["key1"] = arg0
   936  	var arg1 string
   937  	if tmp, ok := rawArgs["key2"]; ok {
   938  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key2"))
   939  		arg1, err = ec.unmarshalNString2string(ctx, tmp)
   940  		if err != nil {
   941  			return nil, err
   942  		}
   943  	}
   944  	args["key2"] = arg1
   945  	return args, nil
   946  }
   947  
   948  func (ec *executionContext) field_Entity_findHelloWithErrorsByName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   949  	var err error
   950  	args := map[string]interface{}{}
   951  	var arg0 string
   952  	if tmp, ok := rawArgs["name"]; ok {
   953  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
   954  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   955  		if err != nil {
   956  			return nil, err
   957  		}
   958  	}
   959  	args["name"] = arg0
   960  	return args, nil
   961  }
   962  
   963  func (ec *executionContext) field_Entity_findManyMultiHelloByNames_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   964  	var err error
   965  	args := map[string]interface{}{}
   966  	var arg0 []*MultiHelloByNamesInput
   967  	if tmp, ok := rawArgs["reps"]; ok {
   968  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("reps"))
   969  		arg0, err = ec.unmarshalNMultiHelloByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloByNamesInput(ctx, tmp)
   970  		if err != nil {
   971  			return nil, err
   972  		}
   973  	}
   974  	args["reps"] = arg0
   975  	return args, nil
   976  }
   977  
   978  func (ec *executionContext) field_Entity_findManyMultiHelloMultipleRequiresByNames_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   979  	var err error
   980  	args := map[string]interface{}{}
   981  	var arg0 []*MultiHelloMultipleRequiresByNamesInput
   982  	if tmp, ok := rawArgs["reps"]; ok {
   983  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("reps"))
   984  		arg0, err = ec.unmarshalNMultiHelloMultipleRequiresByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequiresByNamesInput(ctx, tmp)
   985  		if err != nil {
   986  			return nil, err
   987  		}
   988  	}
   989  	args["reps"] = arg0
   990  	return args, nil
   991  }
   992  
   993  func (ec *executionContext) field_Entity_findManyMultiHelloRequiresByNames_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   994  	var err error
   995  	args := map[string]interface{}{}
   996  	var arg0 []*MultiHelloRequiresByNamesInput
   997  	if tmp, ok := rawArgs["reps"]; ok {
   998  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("reps"))
   999  		arg0, err = ec.unmarshalNMultiHelloRequiresByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequiresByNamesInput(ctx, tmp)
  1000  		if err != nil {
  1001  			return nil, err
  1002  		}
  1003  	}
  1004  	args["reps"] = arg0
  1005  	return args, nil
  1006  }
  1007  
  1008  func (ec *executionContext) field_Entity_findManyMultiHelloWithErrorByNames_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1009  	var err error
  1010  	args := map[string]interface{}{}
  1011  	var arg0 []*MultiHelloWithErrorByNamesInput
  1012  	if tmp, ok := rawArgs["reps"]; ok {
  1013  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("reps"))
  1014  		arg0, err = ec.unmarshalNMultiHelloWithErrorByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithErrorByNamesInput(ctx, tmp)
  1015  		if err != nil {
  1016  			return nil, err
  1017  		}
  1018  	}
  1019  	args["reps"] = arg0
  1020  	return args, nil
  1021  }
  1022  
  1023  func (ec *executionContext) field_Entity_findManyMultiPlanetRequiresNestedByNames_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1024  	var err error
  1025  	args := map[string]interface{}{}
  1026  	var arg0 []*MultiPlanetRequiresNestedByNamesInput
  1027  	if tmp, ok := rawArgs["reps"]; ok {
  1028  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("reps"))
  1029  		arg0, err = ec.unmarshalNMultiPlanetRequiresNestedByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNestedByNamesInput(ctx, tmp)
  1030  		if err != nil {
  1031  			return nil, err
  1032  		}
  1033  	}
  1034  	args["reps"] = arg0
  1035  	return args, nil
  1036  }
  1037  
  1038  func (ec *executionContext) field_Entity_findPlanetMultipleRequiresByName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1039  	var err error
  1040  	args := map[string]interface{}{}
  1041  	var arg0 string
  1042  	if tmp, ok := rawArgs["name"]; ok {
  1043  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
  1044  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1045  		if err != nil {
  1046  			return nil, err
  1047  		}
  1048  	}
  1049  	args["name"] = arg0
  1050  	return args, nil
  1051  }
  1052  
  1053  func (ec *executionContext) field_Entity_findPlanetRequiresByName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1054  	var err error
  1055  	args := map[string]interface{}{}
  1056  	var arg0 string
  1057  	if tmp, ok := rawArgs["name"]; ok {
  1058  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
  1059  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1060  		if err != nil {
  1061  			return nil, err
  1062  		}
  1063  	}
  1064  	args["name"] = arg0
  1065  	return args, nil
  1066  }
  1067  
  1068  func (ec *executionContext) field_Entity_findPlanetRequiresNestedByName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1069  	var err error
  1070  	args := map[string]interface{}{}
  1071  	var arg0 string
  1072  	if tmp, ok := rawArgs["name"]; ok {
  1073  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
  1074  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1075  		if err != nil {
  1076  			return nil, err
  1077  		}
  1078  	}
  1079  	args["name"] = arg0
  1080  	return args, nil
  1081  }
  1082  
  1083  func (ec *executionContext) field_Entity_findWorldByHelloNameAndFoo_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1084  	var err error
  1085  	args := map[string]interface{}{}
  1086  	var arg0 string
  1087  	if tmp, ok := rawArgs["helloName"]; ok {
  1088  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("helloName"))
  1089  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1090  		if err != nil {
  1091  			return nil, err
  1092  		}
  1093  	}
  1094  	args["helloName"] = arg0
  1095  	var arg1 string
  1096  	if tmp, ok := rawArgs["foo"]; ok {
  1097  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("foo"))
  1098  		arg1, err = ec.unmarshalNString2string(ctx, tmp)
  1099  		if err != nil {
  1100  			return nil, err
  1101  		}
  1102  	}
  1103  	args["foo"] = arg1
  1104  	return args, nil
  1105  }
  1106  
  1107  func (ec *executionContext) field_Entity_findWorldNameByName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1108  	var err error
  1109  	args := map[string]interface{}{}
  1110  	var arg0 string
  1111  	if tmp, ok := rawArgs["name"]; ok {
  1112  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
  1113  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1114  		if err != nil {
  1115  			return nil, err
  1116  		}
  1117  	}
  1118  	args["name"] = arg0
  1119  	return args, nil
  1120  }
  1121  
  1122  func (ec *executionContext) field_Entity_findWorldWithMultipleKeysByBar_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1123  	var err error
  1124  	args := map[string]interface{}{}
  1125  	var arg0 int
  1126  	if tmp, ok := rawArgs["bar"]; ok {
  1127  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bar"))
  1128  		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
  1129  		if err != nil {
  1130  			return nil, err
  1131  		}
  1132  	}
  1133  	args["bar"] = arg0
  1134  	return args, nil
  1135  }
  1136  
  1137  func (ec *executionContext) field_Entity_findWorldWithMultipleKeysByHelloNameAndFoo_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1138  	var err error
  1139  	args := map[string]interface{}{}
  1140  	var arg0 string
  1141  	if tmp, ok := rawArgs["helloName"]; ok {
  1142  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("helloName"))
  1143  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1144  		if err != nil {
  1145  			return nil, err
  1146  		}
  1147  	}
  1148  	args["helloName"] = arg0
  1149  	var arg1 string
  1150  	if tmp, ok := rawArgs["foo"]; ok {
  1151  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("foo"))
  1152  		arg1, err = ec.unmarshalNString2string(ctx, tmp)
  1153  		if err != nil {
  1154  			return nil, err
  1155  		}
  1156  	}
  1157  	args["foo"] = arg1
  1158  	return args, nil
  1159  }
  1160  
  1161  func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1162  	var err error
  1163  	args := map[string]interface{}{}
  1164  	var arg0 string
  1165  	if tmp, ok := rawArgs["name"]; ok {
  1166  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
  1167  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
  1168  		if err != nil {
  1169  			return nil, err
  1170  		}
  1171  	}
  1172  	args["name"] = arg0
  1173  	return args, nil
  1174  }
  1175  
  1176  func (ec *executionContext) field_Query__entities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1177  	var err error
  1178  	args := map[string]interface{}{}
  1179  	var arg0 []map[string]interface{}
  1180  	if tmp, ok := rawArgs["representations"]; ok {
  1181  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("representations"))
  1182  		arg0, err = ec.unmarshalN_Any2ᚕmapᚄ(ctx, tmp)
  1183  		if err != nil {
  1184  			return nil, err
  1185  		}
  1186  	}
  1187  	args["representations"] = arg0
  1188  	return args, nil
  1189  }
  1190  
  1191  func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1192  	var err error
  1193  	args := map[string]interface{}{}
  1194  	var arg0 bool
  1195  	if tmp, ok := rawArgs["includeDeprecated"]; ok {
  1196  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
  1197  		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
  1198  		if err != nil {
  1199  			return nil, err
  1200  		}
  1201  	}
  1202  	args["includeDeprecated"] = arg0
  1203  	return args, nil
  1204  }
  1205  
  1206  func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  1207  	var err error
  1208  	args := map[string]interface{}{}
  1209  	var arg0 bool
  1210  	if tmp, ok := rawArgs["includeDeprecated"]; ok {
  1211  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
  1212  		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
  1213  		if err != nil {
  1214  			return nil, err
  1215  		}
  1216  	}
  1217  	args["includeDeprecated"] = arg0
  1218  	return args, nil
  1219  }
  1220  
  1221  // endregion ***************************** args.gotpl *****************************
  1222  
  1223  // region    ************************** directives.gotpl **************************
  1224  
  1225  // endregion ************************** directives.gotpl **************************
  1226  
  1227  // region    **************************** field.gotpl *****************************
  1228  
  1229  func (ec *executionContext) _Entity_findHelloByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1230  	fc, err := ec.fieldContext_Entity_findHelloByName(ctx, field)
  1231  	if err != nil {
  1232  		return graphql.Null
  1233  	}
  1234  	ctx = graphql.WithFieldContext(ctx, fc)
  1235  	defer func() {
  1236  		if r := recover(); r != nil {
  1237  			ec.Error(ctx, ec.Recover(ctx, r))
  1238  			ret = graphql.Null
  1239  		}
  1240  	}()
  1241  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1242  		ctx = rctx // use context from middleware stack in children
  1243  		return ec.resolvers.Entity().FindHelloByName(rctx, fc.Args["name"].(string))
  1244  	})
  1245  	if err != nil {
  1246  		ec.Error(ctx, err)
  1247  		return graphql.Null
  1248  	}
  1249  	if resTmp == nil {
  1250  		if !graphql.HasFieldError(ctx, fc) {
  1251  			ec.Errorf(ctx, "must not be null")
  1252  		}
  1253  		return graphql.Null
  1254  	}
  1255  	res := resTmp.(*Hello)
  1256  	fc.Result = res
  1257  	return ec.marshalNHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHello(ctx, field.Selections, res)
  1258  }
  1259  
  1260  func (ec *executionContext) fieldContext_Entity_findHelloByName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1261  	fc = &graphql.FieldContext{
  1262  		Object:     "Entity",
  1263  		Field:      field,
  1264  		IsMethod:   true,
  1265  		IsResolver: true,
  1266  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1267  			switch field.Name {
  1268  			case "name":
  1269  				return ec.fieldContext_Hello_name(ctx, field)
  1270  			case "secondary":
  1271  				return ec.fieldContext_Hello_secondary(ctx, field)
  1272  			}
  1273  			return nil, fmt.Errorf("no field named %q was found under type Hello", field.Name)
  1274  		},
  1275  	}
  1276  	defer func() {
  1277  		if r := recover(); r != nil {
  1278  			err = ec.Recover(ctx, r)
  1279  			ec.Error(ctx, err)
  1280  		}
  1281  	}()
  1282  	ctx = graphql.WithFieldContext(ctx, fc)
  1283  	if fc.Args, err = ec.field_Entity_findHelloByName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1284  		ec.Error(ctx, err)
  1285  		return fc, err
  1286  	}
  1287  	return fc, nil
  1288  }
  1289  
  1290  func (ec *executionContext) _Entity_findHelloMultiSingleKeysByKey1AndKey2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1291  	fc, err := ec.fieldContext_Entity_findHelloMultiSingleKeysByKey1AndKey2(ctx, field)
  1292  	if err != nil {
  1293  		return graphql.Null
  1294  	}
  1295  	ctx = graphql.WithFieldContext(ctx, fc)
  1296  	defer func() {
  1297  		if r := recover(); r != nil {
  1298  			ec.Error(ctx, ec.Recover(ctx, r))
  1299  			ret = graphql.Null
  1300  		}
  1301  	}()
  1302  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1303  		ctx = rctx // use context from middleware stack in children
  1304  		return ec.resolvers.Entity().FindHelloMultiSingleKeysByKey1AndKey2(rctx, fc.Args["key1"].(string), fc.Args["key2"].(string))
  1305  	})
  1306  	if err != nil {
  1307  		ec.Error(ctx, err)
  1308  		return graphql.Null
  1309  	}
  1310  	if resTmp == nil {
  1311  		if !graphql.HasFieldError(ctx, fc) {
  1312  			ec.Errorf(ctx, "must not be null")
  1313  		}
  1314  		return graphql.Null
  1315  	}
  1316  	res := resTmp.(*HelloMultiSingleKeys)
  1317  	fc.Result = res
  1318  	return ec.marshalNHelloMultiSingleKeys2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHelloMultiSingleKeys(ctx, field.Selections, res)
  1319  }
  1320  
  1321  func (ec *executionContext) fieldContext_Entity_findHelloMultiSingleKeysByKey1AndKey2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1322  	fc = &graphql.FieldContext{
  1323  		Object:     "Entity",
  1324  		Field:      field,
  1325  		IsMethod:   true,
  1326  		IsResolver: true,
  1327  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1328  			switch field.Name {
  1329  			case "key1":
  1330  				return ec.fieldContext_HelloMultiSingleKeys_key1(ctx, field)
  1331  			case "key2":
  1332  				return ec.fieldContext_HelloMultiSingleKeys_key2(ctx, field)
  1333  			}
  1334  			return nil, fmt.Errorf("no field named %q was found under type HelloMultiSingleKeys", field.Name)
  1335  		},
  1336  	}
  1337  	defer func() {
  1338  		if r := recover(); r != nil {
  1339  			err = ec.Recover(ctx, r)
  1340  			ec.Error(ctx, err)
  1341  		}
  1342  	}()
  1343  	ctx = graphql.WithFieldContext(ctx, fc)
  1344  	if fc.Args, err = ec.field_Entity_findHelloMultiSingleKeysByKey1AndKey2_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1345  		ec.Error(ctx, err)
  1346  		return fc, err
  1347  	}
  1348  	return fc, nil
  1349  }
  1350  
  1351  func (ec *executionContext) _Entity_findHelloWithErrorsByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1352  	fc, err := ec.fieldContext_Entity_findHelloWithErrorsByName(ctx, field)
  1353  	if err != nil {
  1354  		return graphql.Null
  1355  	}
  1356  	ctx = graphql.WithFieldContext(ctx, fc)
  1357  	defer func() {
  1358  		if r := recover(); r != nil {
  1359  			ec.Error(ctx, ec.Recover(ctx, r))
  1360  			ret = graphql.Null
  1361  		}
  1362  	}()
  1363  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1364  		ctx = rctx // use context from middleware stack in children
  1365  		return ec.resolvers.Entity().FindHelloWithErrorsByName(rctx, fc.Args["name"].(string))
  1366  	})
  1367  	if err != nil {
  1368  		ec.Error(ctx, err)
  1369  		return graphql.Null
  1370  	}
  1371  	if resTmp == nil {
  1372  		if !graphql.HasFieldError(ctx, fc) {
  1373  			ec.Errorf(ctx, "must not be null")
  1374  		}
  1375  		return graphql.Null
  1376  	}
  1377  	res := resTmp.(*HelloWithErrors)
  1378  	fc.Result = res
  1379  	return ec.marshalNHelloWithErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHelloWithErrors(ctx, field.Selections, res)
  1380  }
  1381  
  1382  func (ec *executionContext) fieldContext_Entity_findHelloWithErrorsByName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1383  	fc = &graphql.FieldContext{
  1384  		Object:     "Entity",
  1385  		Field:      field,
  1386  		IsMethod:   true,
  1387  		IsResolver: true,
  1388  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1389  			switch field.Name {
  1390  			case "name":
  1391  				return ec.fieldContext_HelloWithErrors_name(ctx, field)
  1392  			}
  1393  			return nil, fmt.Errorf("no field named %q was found under type HelloWithErrors", field.Name)
  1394  		},
  1395  	}
  1396  	defer func() {
  1397  		if r := recover(); r != nil {
  1398  			err = ec.Recover(ctx, r)
  1399  			ec.Error(ctx, err)
  1400  		}
  1401  	}()
  1402  	ctx = graphql.WithFieldContext(ctx, fc)
  1403  	if fc.Args, err = ec.field_Entity_findHelloWithErrorsByName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1404  		ec.Error(ctx, err)
  1405  		return fc, err
  1406  	}
  1407  	return fc, nil
  1408  }
  1409  
  1410  func (ec *executionContext) _Entity_findManyMultiHelloByNames(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1411  	fc, err := ec.fieldContext_Entity_findManyMultiHelloByNames(ctx, field)
  1412  	if err != nil {
  1413  		return graphql.Null
  1414  	}
  1415  	ctx = graphql.WithFieldContext(ctx, fc)
  1416  	defer func() {
  1417  		if r := recover(); r != nil {
  1418  			ec.Error(ctx, ec.Recover(ctx, r))
  1419  			ret = graphql.Null
  1420  		}
  1421  	}()
  1422  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1423  		directive0 := func(rctx context.Context) (interface{}, error) {
  1424  			ctx = rctx // use context from middleware stack in children
  1425  			return ec.resolvers.Entity().FindManyMultiHelloByNames(rctx, fc.Args["reps"].([]*MultiHelloByNamesInput))
  1426  		}
  1427  		directive1 := func(ctx context.Context) (interface{}, error) {
  1428  			multi, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
  1429  			if err != nil {
  1430  				return nil, err
  1431  			}
  1432  			if ec.directives.EntityResolver == nil {
  1433  				return nil, errors.New("directive entityResolver is not implemented")
  1434  			}
  1435  			return ec.directives.EntityResolver(ctx, nil, directive0, multi)
  1436  		}
  1437  
  1438  		tmp, err := directive1(rctx)
  1439  		if err != nil {
  1440  			return nil, graphql.ErrorOnPath(ctx, err)
  1441  		}
  1442  		if tmp == nil {
  1443  			return nil, nil
  1444  		}
  1445  		if data, ok := tmp.([]*MultiHello); ok {
  1446  			return data, nil
  1447  		}
  1448  		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated.MultiHello`, tmp)
  1449  	})
  1450  	if err != nil {
  1451  		ec.Error(ctx, err)
  1452  		return graphql.Null
  1453  	}
  1454  	if resTmp == nil {
  1455  		return graphql.Null
  1456  	}
  1457  	res := resTmp.([]*MultiHello)
  1458  	fc.Result = res
  1459  	return ec.marshalOMultiHello2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHello(ctx, field.Selections, res)
  1460  }
  1461  
  1462  func (ec *executionContext) fieldContext_Entity_findManyMultiHelloByNames(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1463  	fc = &graphql.FieldContext{
  1464  		Object:     "Entity",
  1465  		Field:      field,
  1466  		IsMethod:   true,
  1467  		IsResolver: true,
  1468  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1469  			switch field.Name {
  1470  			case "name":
  1471  				return ec.fieldContext_MultiHello_name(ctx, field)
  1472  			}
  1473  			return nil, fmt.Errorf("no field named %q was found under type MultiHello", field.Name)
  1474  		},
  1475  	}
  1476  	defer func() {
  1477  		if r := recover(); r != nil {
  1478  			err = ec.Recover(ctx, r)
  1479  			ec.Error(ctx, err)
  1480  		}
  1481  	}()
  1482  	ctx = graphql.WithFieldContext(ctx, fc)
  1483  	if fc.Args, err = ec.field_Entity_findManyMultiHelloByNames_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1484  		ec.Error(ctx, err)
  1485  		return fc, err
  1486  	}
  1487  	return fc, nil
  1488  }
  1489  
  1490  func (ec *executionContext) _Entity_findManyMultiHelloMultipleRequiresByNames(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1491  	fc, err := ec.fieldContext_Entity_findManyMultiHelloMultipleRequiresByNames(ctx, field)
  1492  	if err != nil {
  1493  		return graphql.Null
  1494  	}
  1495  	ctx = graphql.WithFieldContext(ctx, fc)
  1496  	defer func() {
  1497  		if r := recover(); r != nil {
  1498  			ec.Error(ctx, ec.Recover(ctx, r))
  1499  			ret = graphql.Null
  1500  		}
  1501  	}()
  1502  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1503  		directive0 := func(rctx context.Context) (interface{}, error) {
  1504  			ctx = rctx // use context from middleware stack in children
  1505  			return ec.resolvers.Entity().FindManyMultiHelloMultipleRequiresByNames(rctx, fc.Args["reps"].([]*MultiHelloMultipleRequiresByNamesInput))
  1506  		}
  1507  		directive1 := func(ctx context.Context) (interface{}, error) {
  1508  			multi, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
  1509  			if err != nil {
  1510  				return nil, err
  1511  			}
  1512  			if ec.directives.EntityResolver == nil {
  1513  				return nil, errors.New("directive entityResolver is not implemented")
  1514  			}
  1515  			return ec.directives.EntityResolver(ctx, nil, directive0, multi)
  1516  		}
  1517  
  1518  		tmp, err := directive1(rctx)
  1519  		if err != nil {
  1520  			return nil, graphql.ErrorOnPath(ctx, err)
  1521  		}
  1522  		if tmp == nil {
  1523  			return nil, nil
  1524  		}
  1525  		if data, ok := tmp.([]*MultiHelloMultipleRequires); ok {
  1526  			return data, nil
  1527  		}
  1528  		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated.MultiHelloMultipleRequires`, tmp)
  1529  	})
  1530  	if err != nil {
  1531  		ec.Error(ctx, err)
  1532  		return graphql.Null
  1533  	}
  1534  	if resTmp == nil {
  1535  		return graphql.Null
  1536  	}
  1537  	res := resTmp.([]*MultiHelloMultipleRequires)
  1538  	fc.Result = res
  1539  	return ec.marshalOMultiHelloMultipleRequires2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequires(ctx, field.Selections, res)
  1540  }
  1541  
  1542  func (ec *executionContext) fieldContext_Entity_findManyMultiHelloMultipleRequiresByNames(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1543  	fc = &graphql.FieldContext{
  1544  		Object:     "Entity",
  1545  		Field:      field,
  1546  		IsMethod:   true,
  1547  		IsResolver: true,
  1548  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1549  			switch field.Name {
  1550  			case "name":
  1551  				return ec.fieldContext_MultiHelloMultipleRequires_name(ctx, field)
  1552  			case "key1":
  1553  				return ec.fieldContext_MultiHelloMultipleRequires_key1(ctx, field)
  1554  			case "key2":
  1555  				return ec.fieldContext_MultiHelloMultipleRequires_key2(ctx, field)
  1556  			case "key3":
  1557  				return ec.fieldContext_MultiHelloMultipleRequires_key3(ctx, field)
  1558  			}
  1559  			return nil, fmt.Errorf("no field named %q was found under type MultiHelloMultipleRequires", field.Name)
  1560  		},
  1561  	}
  1562  	defer func() {
  1563  		if r := recover(); r != nil {
  1564  			err = ec.Recover(ctx, r)
  1565  			ec.Error(ctx, err)
  1566  		}
  1567  	}()
  1568  	ctx = graphql.WithFieldContext(ctx, fc)
  1569  	if fc.Args, err = ec.field_Entity_findManyMultiHelloMultipleRequiresByNames_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1570  		ec.Error(ctx, err)
  1571  		return fc, err
  1572  	}
  1573  	return fc, nil
  1574  }
  1575  
  1576  func (ec *executionContext) _Entity_findManyMultiHelloRequiresByNames(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1577  	fc, err := ec.fieldContext_Entity_findManyMultiHelloRequiresByNames(ctx, field)
  1578  	if err != nil {
  1579  		return graphql.Null
  1580  	}
  1581  	ctx = graphql.WithFieldContext(ctx, fc)
  1582  	defer func() {
  1583  		if r := recover(); r != nil {
  1584  			ec.Error(ctx, ec.Recover(ctx, r))
  1585  			ret = graphql.Null
  1586  		}
  1587  	}()
  1588  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1589  		directive0 := func(rctx context.Context) (interface{}, error) {
  1590  			ctx = rctx // use context from middleware stack in children
  1591  			return ec.resolvers.Entity().FindManyMultiHelloRequiresByNames(rctx, fc.Args["reps"].([]*MultiHelloRequiresByNamesInput))
  1592  		}
  1593  		directive1 := func(ctx context.Context) (interface{}, error) {
  1594  			multi, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
  1595  			if err != nil {
  1596  				return nil, err
  1597  			}
  1598  			if ec.directives.EntityResolver == nil {
  1599  				return nil, errors.New("directive entityResolver is not implemented")
  1600  			}
  1601  			return ec.directives.EntityResolver(ctx, nil, directive0, multi)
  1602  		}
  1603  
  1604  		tmp, err := directive1(rctx)
  1605  		if err != nil {
  1606  			return nil, graphql.ErrorOnPath(ctx, err)
  1607  		}
  1608  		if tmp == nil {
  1609  			return nil, nil
  1610  		}
  1611  		if data, ok := tmp.([]*MultiHelloRequires); ok {
  1612  			return data, nil
  1613  		}
  1614  		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated.MultiHelloRequires`, tmp)
  1615  	})
  1616  	if err != nil {
  1617  		ec.Error(ctx, err)
  1618  		return graphql.Null
  1619  	}
  1620  	if resTmp == nil {
  1621  		return graphql.Null
  1622  	}
  1623  	res := resTmp.([]*MultiHelloRequires)
  1624  	fc.Result = res
  1625  	return ec.marshalOMultiHelloRequires2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequires(ctx, field.Selections, res)
  1626  }
  1627  
  1628  func (ec *executionContext) fieldContext_Entity_findManyMultiHelloRequiresByNames(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1629  	fc = &graphql.FieldContext{
  1630  		Object:     "Entity",
  1631  		Field:      field,
  1632  		IsMethod:   true,
  1633  		IsResolver: true,
  1634  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1635  			switch field.Name {
  1636  			case "name":
  1637  				return ec.fieldContext_MultiHelloRequires_name(ctx, field)
  1638  			case "key1":
  1639  				return ec.fieldContext_MultiHelloRequires_key1(ctx, field)
  1640  			case "key2":
  1641  				return ec.fieldContext_MultiHelloRequires_key2(ctx, field)
  1642  			}
  1643  			return nil, fmt.Errorf("no field named %q was found under type MultiHelloRequires", field.Name)
  1644  		},
  1645  	}
  1646  	defer func() {
  1647  		if r := recover(); r != nil {
  1648  			err = ec.Recover(ctx, r)
  1649  			ec.Error(ctx, err)
  1650  		}
  1651  	}()
  1652  	ctx = graphql.WithFieldContext(ctx, fc)
  1653  	if fc.Args, err = ec.field_Entity_findManyMultiHelloRequiresByNames_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1654  		ec.Error(ctx, err)
  1655  		return fc, err
  1656  	}
  1657  	return fc, nil
  1658  }
  1659  
  1660  func (ec *executionContext) _Entity_findManyMultiHelloWithErrorByNames(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1661  	fc, err := ec.fieldContext_Entity_findManyMultiHelloWithErrorByNames(ctx, field)
  1662  	if err != nil {
  1663  		return graphql.Null
  1664  	}
  1665  	ctx = graphql.WithFieldContext(ctx, fc)
  1666  	defer func() {
  1667  		if r := recover(); r != nil {
  1668  			ec.Error(ctx, ec.Recover(ctx, r))
  1669  			ret = graphql.Null
  1670  		}
  1671  	}()
  1672  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1673  		directive0 := func(rctx context.Context) (interface{}, error) {
  1674  			ctx = rctx // use context from middleware stack in children
  1675  			return ec.resolvers.Entity().FindManyMultiHelloWithErrorByNames(rctx, fc.Args["reps"].([]*MultiHelloWithErrorByNamesInput))
  1676  		}
  1677  		directive1 := func(ctx context.Context) (interface{}, error) {
  1678  			multi, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
  1679  			if err != nil {
  1680  				return nil, err
  1681  			}
  1682  			if ec.directives.EntityResolver == nil {
  1683  				return nil, errors.New("directive entityResolver is not implemented")
  1684  			}
  1685  			return ec.directives.EntityResolver(ctx, nil, directive0, multi)
  1686  		}
  1687  
  1688  		tmp, err := directive1(rctx)
  1689  		if err != nil {
  1690  			return nil, graphql.ErrorOnPath(ctx, err)
  1691  		}
  1692  		if tmp == nil {
  1693  			return nil, nil
  1694  		}
  1695  		if data, ok := tmp.([]*MultiHelloWithError); ok {
  1696  			return data, nil
  1697  		}
  1698  		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated.MultiHelloWithError`, tmp)
  1699  	})
  1700  	if err != nil {
  1701  		ec.Error(ctx, err)
  1702  		return graphql.Null
  1703  	}
  1704  	if resTmp == nil {
  1705  		return graphql.Null
  1706  	}
  1707  	res := resTmp.([]*MultiHelloWithError)
  1708  	fc.Result = res
  1709  	return ec.marshalOMultiHelloWithError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithError(ctx, field.Selections, res)
  1710  }
  1711  
  1712  func (ec *executionContext) fieldContext_Entity_findManyMultiHelloWithErrorByNames(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1713  	fc = &graphql.FieldContext{
  1714  		Object:     "Entity",
  1715  		Field:      field,
  1716  		IsMethod:   true,
  1717  		IsResolver: true,
  1718  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1719  			switch field.Name {
  1720  			case "name":
  1721  				return ec.fieldContext_MultiHelloWithError_name(ctx, field)
  1722  			}
  1723  			return nil, fmt.Errorf("no field named %q was found under type MultiHelloWithError", field.Name)
  1724  		},
  1725  	}
  1726  	defer func() {
  1727  		if r := recover(); r != nil {
  1728  			err = ec.Recover(ctx, r)
  1729  			ec.Error(ctx, err)
  1730  		}
  1731  	}()
  1732  	ctx = graphql.WithFieldContext(ctx, fc)
  1733  	if fc.Args, err = ec.field_Entity_findManyMultiHelloWithErrorByNames_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1734  		ec.Error(ctx, err)
  1735  		return fc, err
  1736  	}
  1737  	return fc, nil
  1738  }
  1739  
  1740  func (ec *executionContext) _Entity_findManyMultiPlanetRequiresNestedByNames(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1741  	fc, err := ec.fieldContext_Entity_findManyMultiPlanetRequiresNestedByNames(ctx, field)
  1742  	if err != nil {
  1743  		return graphql.Null
  1744  	}
  1745  	ctx = graphql.WithFieldContext(ctx, fc)
  1746  	defer func() {
  1747  		if r := recover(); r != nil {
  1748  			ec.Error(ctx, ec.Recover(ctx, r))
  1749  			ret = graphql.Null
  1750  		}
  1751  	}()
  1752  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1753  		directive0 := func(rctx context.Context) (interface{}, error) {
  1754  			ctx = rctx // use context from middleware stack in children
  1755  			return ec.resolvers.Entity().FindManyMultiPlanetRequiresNestedByNames(rctx, fc.Args["reps"].([]*MultiPlanetRequiresNestedByNamesInput))
  1756  		}
  1757  		directive1 := func(ctx context.Context) (interface{}, error) {
  1758  			multi, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
  1759  			if err != nil {
  1760  				return nil, err
  1761  			}
  1762  			if ec.directives.EntityResolver == nil {
  1763  				return nil, errors.New("directive entityResolver is not implemented")
  1764  			}
  1765  			return ec.directives.EntityResolver(ctx, nil, directive0, multi)
  1766  		}
  1767  
  1768  		tmp, err := directive1(rctx)
  1769  		if err != nil {
  1770  			return nil, graphql.ErrorOnPath(ctx, err)
  1771  		}
  1772  		if tmp == nil {
  1773  			return nil, nil
  1774  		}
  1775  		if data, ok := tmp.([]*MultiPlanetRequiresNested); ok {
  1776  			return data, nil
  1777  		}
  1778  		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated.MultiPlanetRequiresNested`, tmp)
  1779  	})
  1780  	if err != nil {
  1781  		ec.Error(ctx, err)
  1782  		return graphql.Null
  1783  	}
  1784  	if resTmp == nil {
  1785  		return graphql.Null
  1786  	}
  1787  	res := resTmp.([]*MultiPlanetRequiresNested)
  1788  	fc.Result = res
  1789  	return ec.marshalOMultiPlanetRequiresNested2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNested(ctx, field.Selections, res)
  1790  }
  1791  
  1792  func (ec *executionContext) fieldContext_Entity_findManyMultiPlanetRequiresNestedByNames(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1793  	fc = &graphql.FieldContext{
  1794  		Object:     "Entity",
  1795  		Field:      field,
  1796  		IsMethod:   true,
  1797  		IsResolver: true,
  1798  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1799  			switch field.Name {
  1800  			case "name":
  1801  				return ec.fieldContext_MultiPlanetRequiresNested_name(ctx, field)
  1802  			case "world":
  1803  				return ec.fieldContext_MultiPlanetRequiresNested_world(ctx, field)
  1804  			case "size":
  1805  				return ec.fieldContext_MultiPlanetRequiresNested_size(ctx, field)
  1806  			}
  1807  			return nil, fmt.Errorf("no field named %q was found under type MultiPlanetRequiresNested", field.Name)
  1808  		},
  1809  	}
  1810  	defer func() {
  1811  		if r := recover(); r != nil {
  1812  			err = ec.Recover(ctx, r)
  1813  			ec.Error(ctx, err)
  1814  		}
  1815  	}()
  1816  	ctx = graphql.WithFieldContext(ctx, fc)
  1817  	if fc.Args, err = ec.field_Entity_findManyMultiPlanetRequiresNestedByNames_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1818  		ec.Error(ctx, err)
  1819  		return fc, err
  1820  	}
  1821  	return fc, nil
  1822  }
  1823  
  1824  func (ec *executionContext) _Entity_findPlanetMultipleRequiresByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1825  	fc, err := ec.fieldContext_Entity_findPlanetMultipleRequiresByName(ctx, field)
  1826  	if err != nil {
  1827  		return graphql.Null
  1828  	}
  1829  	ctx = graphql.WithFieldContext(ctx, fc)
  1830  	defer func() {
  1831  		if r := recover(); r != nil {
  1832  			ec.Error(ctx, ec.Recover(ctx, r))
  1833  			ret = graphql.Null
  1834  		}
  1835  	}()
  1836  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1837  		ctx = rctx // use context from middleware stack in children
  1838  		return ec.resolvers.Entity().FindPlanetMultipleRequiresByName(rctx, fc.Args["name"].(string))
  1839  	})
  1840  	if err != nil {
  1841  		ec.Error(ctx, err)
  1842  		return graphql.Null
  1843  	}
  1844  	if resTmp == nil {
  1845  		if !graphql.HasFieldError(ctx, fc) {
  1846  			ec.Errorf(ctx, "must not be null")
  1847  		}
  1848  		return graphql.Null
  1849  	}
  1850  	res := resTmp.(*PlanetMultipleRequires)
  1851  	fc.Result = res
  1852  	return ec.marshalNPlanetMultipleRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetMultipleRequires(ctx, field.Selections, res)
  1853  }
  1854  
  1855  func (ec *executionContext) fieldContext_Entity_findPlanetMultipleRequiresByName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1856  	fc = &graphql.FieldContext{
  1857  		Object:     "Entity",
  1858  		Field:      field,
  1859  		IsMethod:   true,
  1860  		IsResolver: true,
  1861  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1862  			switch field.Name {
  1863  			case "name":
  1864  				return ec.fieldContext_PlanetMultipleRequires_name(ctx, field)
  1865  			case "diameter":
  1866  				return ec.fieldContext_PlanetMultipleRequires_diameter(ctx, field)
  1867  			case "density":
  1868  				return ec.fieldContext_PlanetMultipleRequires_density(ctx, field)
  1869  			case "weight":
  1870  				return ec.fieldContext_PlanetMultipleRequires_weight(ctx, field)
  1871  			}
  1872  			return nil, fmt.Errorf("no field named %q was found under type PlanetMultipleRequires", field.Name)
  1873  		},
  1874  	}
  1875  	defer func() {
  1876  		if r := recover(); r != nil {
  1877  			err = ec.Recover(ctx, r)
  1878  			ec.Error(ctx, err)
  1879  		}
  1880  	}()
  1881  	ctx = graphql.WithFieldContext(ctx, fc)
  1882  	if fc.Args, err = ec.field_Entity_findPlanetMultipleRequiresByName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1883  		ec.Error(ctx, err)
  1884  		return fc, err
  1885  	}
  1886  	return fc, nil
  1887  }
  1888  
  1889  func (ec *executionContext) _Entity_findPlanetRequiresByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1890  	fc, err := ec.fieldContext_Entity_findPlanetRequiresByName(ctx, field)
  1891  	if err != nil {
  1892  		return graphql.Null
  1893  	}
  1894  	ctx = graphql.WithFieldContext(ctx, fc)
  1895  	defer func() {
  1896  		if r := recover(); r != nil {
  1897  			ec.Error(ctx, ec.Recover(ctx, r))
  1898  			ret = graphql.Null
  1899  		}
  1900  	}()
  1901  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1902  		ctx = rctx // use context from middleware stack in children
  1903  		return ec.resolvers.Entity().FindPlanetRequiresByName(rctx, fc.Args["name"].(string))
  1904  	})
  1905  	if err != nil {
  1906  		ec.Error(ctx, err)
  1907  		return graphql.Null
  1908  	}
  1909  	if resTmp == nil {
  1910  		if !graphql.HasFieldError(ctx, fc) {
  1911  			ec.Errorf(ctx, "must not be null")
  1912  		}
  1913  		return graphql.Null
  1914  	}
  1915  	res := resTmp.(*PlanetRequires)
  1916  	fc.Result = res
  1917  	return ec.marshalNPlanetRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetRequires(ctx, field.Selections, res)
  1918  }
  1919  
  1920  func (ec *executionContext) fieldContext_Entity_findPlanetRequiresByName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1921  	fc = &graphql.FieldContext{
  1922  		Object:     "Entity",
  1923  		Field:      field,
  1924  		IsMethod:   true,
  1925  		IsResolver: true,
  1926  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1927  			switch field.Name {
  1928  			case "name":
  1929  				return ec.fieldContext_PlanetRequires_name(ctx, field)
  1930  			case "size":
  1931  				return ec.fieldContext_PlanetRequires_size(ctx, field)
  1932  			case "diameter":
  1933  				return ec.fieldContext_PlanetRequires_diameter(ctx, field)
  1934  			}
  1935  			return nil, fmt.Errorf("no field named %q was found under type PlanetRequires", field.Name)
  1936  		},
  1937  	}
  1938  	defer func() {
  1939  		if r := recover(); r != nil {
  1940  			err = ec.Recover(ctx, r)
  1941  			ec.Error(ctx, err)
  1942  		}
  1943  	}()
  1944  	ctx = graphql.WithFieldContext(ctx, fc)
  1945  	if fc.Args, err = ec.field_Entity_findPlanetRequiresByName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1946  		ec.Error(ctx, err)
  1947  		return fc, err
  1948  	}
  1949  	return fc, nil
  1950  }
  1951  
  1952  func (ec *executionContext) _Entity_findPlanetRequiresNestedByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1953  	fc, err := ec.fieldContext_Entity_findPlanetRequiresNestedByName(ctx, field)
  1954  	if err != nil {
  1955  		return graphql.Null
  1956  	}
  1957  	ctx = graphql.WithFieldContext(ctx, fc)
  1958  	defer func() {
  1959  		if r := recover(); r != nil {
  1960  			ec.Error(ctx, ec.Recover(ctx, r))
  1961  			ret = graphql.Null
  1962  		}
  1963  	}()
  1964  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1965  		ctx = rctx // use context from middleware stack in children
  1966  		return ec.resolvers.Entity().FindPlanetRequiresNestedByName(rctx, fc.Args["name"].(string))
  1967  	})
  1968  	if err != nil {
  1969  		ec.Error(ctx, err)
  1970  		return graphql.Null
  1971  	}
  1972  	if resTmp == nil {
  1973  		if !graphql.HasFieldError(ctx, fc) {
  1974  			ec.Errorf(ctx, "must not be null")
  1975  		}
  1976  		return graphql.Null
  1977  	}
  1978  	res := resTmp.(*PlanetRequiresNested)
  1979  	fc.Result = res
  1980  	return ec.marshalNPlanetRequiresNested2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetRequiresNested(ctx, field.Selections, res)
  1981  }
  1982  
  1983  func (ec *executionContext) fieldContext_Entity_findPlanetRequiresNestedByName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1984  	fc = &graphql.FieldContext{
  1985  		Object:     "Entity",
  1986  		Field:      field,
  1987  		IsMethod:   true,
  1988  		IsResolver: true,
  1989  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1990  			switch field.Name {
  1991  			case "name":
  1992  				return ec.fieldContext_PlanetRequiresNested_name(ctx, field)
  1993  			case "world":
  1994  				return ec.fieldContext_PlanetRequiresNested_world(ctx, field)
  1995  			case "worlds":
  1996  				return ec.fieldContext_PlanetRequiresNested_worlds(ctx, field)
  1997  			case "size":
  1998  				return ec.fieldContext_PlanetRequiresNested_size(ctx, field)
  1999  			case "sizes":
  2000  				return ec.fieldContext_PlanetRequiresNested_sizes(ctx, field)
  2001  			}
  2002  			return nil, fmt.Errorf("no field named %q was found under type PlanetRequiresNested", field.Name)
  2003  		},
  2004  	}
  2005  	defer func() {
  2006  		if r := recover(); r != nil {
  2007  			err = ec.Recover(ctx, r)
  2008  			ec.Error(ctx, err)
  2009  		}
  2010  	}()
  2011  	ctx = graphql.WithFieldContext(ctx, fc)
  2012  	if fc.Args, err = ec.field_Entity_findPlanetRequiresNestedByName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2013  		ec.Error(ctx, err)
  2014  		return fc, err
  2015  	}
  2016  	return fc, nil
  2017  }
  2018  
  2019  func (ec *executionContext) _Entity_findWorldByHelloNameAndFoo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2020  	fc, err := ec.fieldContext_Entity_findWorldByHelloNameAndFoo(ctx, field)
  2021  	if err != nil {
  2022  		return graphql.Null
  2023  	}
  2024  	ctx = graphql.WithFieldContext(ctx, fc)
  2025  	defer func() {
  2026  		if r := recover(); r != nil {
  2027  			ec.Error(ctx, ec.Recover(ctx, r))
  2028  			ret = graphql.Null
  2029  		}
  2030  	}()
  2031  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2032  		ctx = rctx // use context from middleware stack in children
  2033  		return ec.resolvers.Entity().FindWorldByHelloNameAndFoo(rctx, fc.Args["helloName"].(string), fc.Args["foo"].(string))
  2034  	})
  2035  	if err != nil {
  2036  		ec.Error(ctx, err)
  2037  		return graphql.Null
  2038  	}
  2039  	if resTmp == nil {
  2040  		if !graphql.HasFieldError(ctx, fc) {
  2041  			ec.Errorf(ctx, "must not be null")
  2042  		}
  2043  		return graphql.Null
  2044  	}
  2045  	res := resTmp.(*World)
  2046  	fc.Result = res
  2047  	return ec.marshalNWorld2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorld(ctx, field.Selections, res)
  2048  }
  2049  
  2050  func (ec *executionContext) fieldContext_Entity_findWorldByHelloNameAndFoo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2051  	fc = &graphql.FieldContext{
  2052  		Object:     "Entity",
  2053  		Field:      field,
  2054  		IsMethod:   true,
  2055  		IsResolver: true,
  2056  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2057  			switch field.Name {
  2058  			case "foo":
  2059  				return ec.fieldContext_World_foo(ctx, field)
  2060  			case "bar":
  2061  				return ec.fieldContext_World_bar(ctx, field)
  2062  			case "hello":
  2063  				return ec.fieldContext_World_hello(ctx, field)
  2064  			}
  2065  			return nil, fmt.Errorf("no field named %q was found under type World", field.Name)
  2066  		},
  2067  	}
  2068  	defer func() {
  2069  		if r := recover(); r != nil {
  2070  			err = ec.Recover(ctx, r)
  2071  			ec.Error(ctx, err)
  2072  		}
  2073  	}()
  2074  	ctx = graphql.WithFieldContext(ctx, fc)
  2075  	if fc.Args, err = ec.field_Entity_findWorldByHelloNameAndFoo_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2076  		ec.Error(ctx, err)
  2077  		return fc, err
  2078  	}
  2079  	return fc, nil
  2080  }
  2081  
  2082  func (ec *executionContext) _Entity_findWorldNameByName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2083  	fc, err := ec.fieldContext_Entity_findWorldNameByName(ctx, field)
  2084  	if err != nil {
  2085  		return graphql.Null
  2086  	}
  2087  	ctx = graphql.WithFieldContext(ctx, fc)
  2088  	defer func() {
  2089  		if r := recover(); r != nil {
  2090  			ec.Error(ctx, ec.Recover(ctx, r))
  2091  			ret = graphql.Null
  2092  		}
  2093  	}()
  2094  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2095  		ctx = rctx // use context from middleware stack in children
  2096  		return ec.resolvers.Entity().FindWorldNameByName(rctx, fc.Args["name"].(string))
  2097  	})
  2098  	if err != nil {
  2099  		ec.Error(ctx, err)
  2100  		return graphql.Null
  2101  	}
  2102  	if resTmp == nil {
  2103  		if !graphql.HasFieldError(ctx, fc) {
  2104  			ec.Errorf(ctx, "must not be null")
  2105  		}
  2106  		return graphql.Null
  2107  	}
  2108  	res := resTmp.(*WorldName)
  2109  	fc.Result = res
  2110  	return ec.marshalNWorldName2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldName(ctx, field.Selections, res)
  2111  }
  2112  
  2113  func (ec *executionContext) fieldContext_Entity_findWorldNameByName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2114  	fc = &graphql.FieldContext{
  2115  		Object:     "Entity",
  2116  		Field:      field,
  2117  		IsMethod:   true,
  2118  		IsResolver: true,
  2119  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2120  			switch field.Name {
  2121  			case "name":
  2122  				return ec.fieldContext_WorldName_name(ctx, field)
  2123  			}
  2124  			return nil, fmt.Errorf("no field named %q was found under type WorldName", field.Name)
  2125  		},
  2126  	}
  2127  	defer func() {
  2128  		if r := recover(); r != nil {
  2129  			err = ec.Recover(ctx, r)
  2130  			ec.Error(ctx, err)
  2131  		}
  2132  	}()
  2133  	ctx = graphql.WithFieldContext(ctx, fc)
  2134  	if fc.Args, err = ec.field_Entity_findWorldNameByName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2135  		ec.Error(ctx, err)
  2136  		return fc, err
  2137  	}
  2138  	return fc, nil
  2139  }
  2140  
  2141  func (ec *executionContext) _Entity_findWorldWithMultipleKeysByHelloNameAndFoo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2142  	fc, err := ec.fieldContext_Entity_findWorldWithMultipleKeysByHelloNameAndFoo(ctx, field)
  2143  	if err != nil {
  2144  		return graphql.Null
  2145  	}
  2146  	ctx = graphql.WithFieldContext(ctx, fc)
  2147  	defer func() {
  2148  		if r := recover(); r != nil {
  2149  			ec.Error(ctx, ec.Recover(ctx, r))
  2150  			ret = graphql.Null
  2151  		}
  2152  	}()
  2153  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2154  		ctx = rctx // use context from middleware stack in children
  2155  		return ec.resolvers.Entity().FindWorldWithMultipleKeysByHelloNameAndFoo(rctx, fc.Args["helloName"].(string), fc.Args["foo"].(string))
  2156  	})
  2157  	if err != nil {
  2158  		ec.Error(ctx, err)
  2159  		return graphql.Null
  2160  	}
  2161  	if resTmp == nil {
  2162  		if !graphql.HasFieldError(ctx, fc) {
  2163  			ec.Errorf(ctx, "must not be null")
  2164  		}
  2165  		return graphql.Null
  2166  	}
  2167  	res := resTmp.(*WorldWithMultipleKeys)
  2168  	fc.Result = res
  2169  	return ec.marshalNWorldWithMultipleKeys2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldWithMultipleKeys(ctx, field.Selections, res)
  2170  }
  2171  
  2172  func (ec *executionContext) fieldContext_Entity_findWorldWithMultipleKeysByHelloNameAndFoo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2173  	fc = &graphql.FieldContext{
  2174  		Object:     "Entity",
  2175  		Field:      field,
  2176  		IsMethod:   true,
  2177  		IsResolver: true,
  2178  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2179  			switch field.Name {
  2180  			case "foo":
  2181  				return ec.fieldContext_WorldWithMultipleKeys_foo(ctx, field)
  2182  			case "bar":
  2183  				return ec.fieldContext_WorldWithMultipleKeys_bar(ctx, field)
  2184  			case "hello":
  2185  				return ec.fieldContext_WorldWithMultipleKeys_hello(ctx, field)
  2186  			}
  2187  			return nil, fmt.Errorf("no field named %q was found under type WorldWithMultipleKeys", field.Name)
  2188  		},
  2189  	}
  2190  	defer func() {
  2191  		if r := recover(); r != nil {
  2192  			err = ec.Recover(ctx, r)
  2193  			ec.Error(ctx, err)
  2194  		}
  2195  	}()
  2196  	ctx = graphql.WithFieldContext(ctx, fc)
  2197  	if fc.Args, err = ec.field_Entity_findWorldWithMultipleKeysByHelloNameAndFoo_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2198  		ec.Error(ctx, err)
  2199  		return fc, err
  2200  	}
  2201  	return fc, nil
  2202  }
  2203  
  2204  func (ec *executionContext) _Entity_findWorldWithMultipleKeysByBar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2205  	fc, err := ec.fieldContext_Entity_findWorldWithMultipleKeysByBar(ctx, field)
  2206  	if err != nil {
  2207  		return graphql.Null
  2208  	}
  2209  	ctx = graphql.WithFieldContext(ctx, fc)
  2210  	defer func() {
  2211  		if r := recover(); r != nil {
  2212  			ec.Error(ctx, ec.Recover(ctx, r))
  2213  			ret = graphql.Null
  2214  		}
  2215  	}()
  2216  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2217  		ctx = rctx // use context from middleware stack in children
  2218  		return ec.resolvers.Entity().FindWorldWithMultipleKeysByBar(rctx, fc.Args["bar"].(int))
  2219  	})
  2220  	if err != nil {
  2221  		ec.Error(ctx, err)
  2222  		return graphql.Null
  2223  	}
  2224  	if resTmp == nil {
  2225  		if !graphql.HasFieldError(ctx, fc) {
  2226  			ec.Errorf(ctx, "must not be null")
  2227  		}
  2228  		return graphql.Null
  2229  	}
  2230  	res := resTmp.(*WorldWithMultipleKeys)
  2231  	fc.Result = res
  2232  	return ec.marshalNWorldWithMultipleKeys2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldWithMultipleKeys(ctx, field.Selections, res)
  2233  }
  2234  
  2235  func (ec *executionContext) fieldContext_Entity_findWorldWithMultipleKeysByBar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2236  	fc = &graphql.FieldContext{
  2237  		Object:     "Entity",
  2238  		Field:      field,
  2239  		IsMethod:   true,
  2240  		IsResolver: true,
  2241  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2242  			switch field.Name {
  2243  			case "foo":
  2244  				return ec.fieldContext_WorldWithMultipleKeys_foo(ctx, field)
  2245  			case "bar":
  2246  				return ec.fieldContext_WorldWithMultipleKeys_bar(ctx, field)
  2247  			case "hello":
  2248  				return ec.fieldContext_WorldWithMultipleKeys_hello(ctx, field)
  2249  			}
  2250  			return nil, fmt.Errorf("no field named %q was found under type WorldWithMultipleKeys", field.Name)
  2251  		},
  2252  	}
  2253  	defer func() {
  2254  		if r := recover(); r != nil {
  2255  			err = ec.Recover(ctx, r)
  2256  			ec.Error(ctx, err)
  2257  		}
  2258  	}()
  2259  	ctx = graphql.WithFieldContext(ctx, fc)
  2260  	if fc.Args, err = ec.field_Entity_findWorldWithMultipleKeysByBar_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2261  		ec.Error(ctx, err)
  2262  		return fc, err
  2263  	}
  2264  	return fc, nil
  2265  }
  2266  
  2267  func (ec *executionContext) _Hello_name(ctx context.Context, field graphql.CollectedField, obj *Hello) (ret graphql.Marshaler) {
  2268  	fc, err := ec.fieldContext_Hello_name(ctx, field)
  2269  	if err != nil {
  2270  		return graphql.Null
  2271  	}
  2272  	ctx = graphql.WithFieldContext(ctx, fc)
  2273  	defer func() {
  2274  		if r := recover(); r != nil {
  2275  			ec.Error(ctx, ec.Recover(ctx, r))
  2276  			ret = graphql.Null
  2277  		}
  2278  	}()
  2279  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2280  		ctx = rctx // use context from middleware stack in children
  2281  		return obj.Name, nil
  2282  	})
  2283  	if err != nil {
  2284  		ec.Error(ctx, err)
  2285  		return graphql.Null
  2286  	}
  2287  	if resTmp == nil {
  2288  		if !graphql.HasFieldError(ctx, fc) {
  2289  			ec.Errorf(ctx, "must not be null")
  2290  		}
  2291  		return graphql.Null
  2292  	}
  2293  	res := resTmp.(string)
  2294  	fc.Result = res
  2295  	return ec.marshalNString2string(ctx, field.Selections, res)
  2296  }
  2297  
  2298  func (ec *executionContext) fieldContext_Hello_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2299  	fc = &graphql.FieldContext{
  2300  		Object:     "Hello",
  2301  		Field:      field,
  2302  		IsMethod:   false,
  2303  		IsResolver: false,
  2304  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2305  			return nil, errors.New("field of type String does not have child fields")
  2306  		},
  2307  	}
  2308  	return fc, nil
  2309  }
  2310  
  2311  func (ec *executionContext) _Hello_secondary(ctx context.Context, field graphql.CollectedField, obj *Hello) (ret graphql.Marshaler) {
  2312  	fc, err := ec.fieldContext_Hello_secondary(ctx, field)
  2313  	if err != nil {
  2314  		return graphql.Null
  2315  	}
  2316  	ctx = graphql.WithFieldContext(ctx, fc)
  2317  	defer func() {
  2318  		if r := recover(); r != nil {
  2319  			ec.Error(ctx, ec.Recover(ctx, r))
  2320  			ret = graphql.Null
  2321  		}
  2322  	}()
  2323  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2324  		ctx = rctx // use context from middleware stack in children
  2325  		return obj.Secondary, nil
  2326  	})
  2327  	if err != nil {
  2328  		ec.Error(ctx, err)
  2329  		return graphql.Null
  2330  	}
  2331  	if resTmp == nil {
  2332  		if !graphql.HasFieldError(ctx, fc) {
  2333  			ec.Errorf(ctx, "must not be null")
  2334  		}
  2335  		return graphql.Null
  2336  	}
  2337  	res := resTmp.(string)
  2338  	fc.Result = res
  2339  	return ec.marshalNString2string(ctx, field.Selections, res)
  2340  }
  2341  
  2342  func (ec *executionContext) fieldContext_Hello_secondary(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2343  	fc = &graphql.FieldContext{
  2344  		Object:     "Hello",
  2345  		Field:      field,
  2346  		IsMethod:   false,
  2347  		IsResolver: false,
  2348  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2349  			return nil, errors.New("field of type String does not have child fields")
  2350  		},
  2351  	}
  2352  	return fc, nil
  2353  }
  2354  
  2355  func (ec *executionContext) _HelloMultiSingleKeys_key1(ctx context.Context, field graphql.CollectedField, obj *HelloMultiSingleKeys) (ret graphql.Marshaler) {
  2356  	fc, err := ec.fieldContext_HelloMultiSingleKeys_key1(ctx, field)
  2357  	if err != nil {
  2358  		return graphql.Null
  2359  	}
  2360  	ctx = graphql.WithFieldContext(ctx, fc)
  2361  	defer func() {
  2362  		if r := recover(); r != nil {
  2363  			ec.Error(ctx, ec.Recover(ctx, r))
  2364  			ret = graphql.Null
  2365  		}
  2366  	}()
  2367  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2368  		ctx = rctx // use context from middleware stack in children
  2369  		return obj.Key1, nil
  2370  	})
  2371  	if err != nil {
  2372  		ec.Error(ctx, err)
  2373  		return graphql.Null
  2374  	}
  2375  	if resTmp == nil {
  2376  		if !graphql.HasFieldError(ctx, fc) {
  2377  			ec.Errorf(ctx, "must not be null")
  2378  		}
  2379  		return graphql.Null
  2380  	}
  2381  	res := resTmp.(string)
  2382  	fc.Result = res
  2383  	return ec.marshalNString2string(ctx, field.Selections, res)
  2384  }
  2385  
  2386  func (ec *executionContext) fieldContext_HelloMultiSingleKeys_key1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2387  	fc = &graphql.FieldContext{
  2388  		Object:     "HelloMultiSingleKeys",
  2389  		Field:      field,
  2390  		IsMethod:   false,
  2391  		IsResolver: false,
  2392  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2393  			return nil, errors.New("field of type String does not have child fields")
  2394  		},
  2395  	}
  2396  	return fc, nil
  2397  }
  2398  
  2399  func (ec *executionContext) _HelloMultiSingleKeys_key2(ctx context.Context, field graphql.CollectedField, obj *HelloMultiSingleKeys) (ret graphql.Marshaler) {
  2400  	fc, err := ec.fieldContext_HelloMultiSingleKeys_key2(ctx, field)
  2401  	if err != nil {
  2402  		return graphql.Null
  2403  	}
  2404  	ctx = graphql.WithFieldContext(ctx, fc)
  2405  	defer func() {
  2406  		if r := recover(); r != nil {
  2407  			ec.Error(ctx, ec.Recover(ctx, r))
  2408  			ret = graphql.Null
  2409  		}
  2410  	}()
  2411  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2412  		ctx = rctx // use context from middleware stack in children
  2413  		return obj.Key2, nil
  2414  	})
  2415  	if err != nil {
  2416  		ec.Error(ctx, err)
  2417  		return graphql.Null
  2418  	}
  2419  	if resTmp == nil {
  2420  		if !graphql.HasFieldError(ctx, fc) {
  2421  			ec.Errorf(ctx, "must not be null")
  2422  		}
  2423  		return graphql.Null
  2424  	}
  2425  	res := resTmp.(string)
  2426  	fc.Result = res
  2427  	return ec.marshalNString2string(ctx, field.Selections, res)
  2428  }
  2429  
  2430  func (ec *executionContext) fieldContext_HelloMultiSingleKeys_key2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2431  	fc = &graphql.FieldContext{
  2432  		Object:     "HelloMultiSingleKeys",
  2433  		Field:      field,
  2434  		IsMethod:   false,
  2435  		IsResolver: false,
  2436  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2437  			return nil, errors.New("field of type String does not have child fields")
  2438  		},
  2439  	}
  2440  	return fc, nil
  2441  }
  2442  
  2443  func (ec *executionContext) _HelloWithErrors_name(ctx context.Context, field graphql.CollectedField, obj *HelloWithErrors) (ret graphql.Marshaler) {
  2444  	fc, err := ec.fieldContext_HelloWithErrors_name(ctx, field)
  2445  	if err != nil {
  2446  		return graphql.Null
  2447  	}
  2448  	ctx = graphql.WithFieldContext(ctx, fc)
  2449  	defer func() {
  2450  		if r := recover(); r != nil {
  2451  			ec.Error(ctx, ec.Recover(ctx, r))
  2452  			ret = graphql.Null
  2453  		}
  2454  	}()
  2455  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2456  		ctx = rctx // use context from middleware stack in children
  2457  		return obj.Name, nil
  2458  	})
  2459  	if err != nil {
  2460  		ec.Error(ctx, err)
  2461  		return graphql.Null
  2462  	}
  2463  	if resTmp == nil {
  2464  		if !graphql.HasFieldError(ctx, fc) {
  2465  			ec.Errorf(ctx, "must not be null")
  2466  		}
  2467  		return graphql.Null
  2468  	}
  2469  	res := resTmp.(string)
  2470  	fc.Result = res
  2471  	return ec.marshalNString2string(ctx, field.Selections, res)
  2472  }
  2473  
  2474  func (ec *executionContext) fieldContext_HelloWithErrors_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2475  	fc = &graphql.FieldContext{
  2476  		Object:     "HelloWithErrors",
  2477  		Field:      field,
  2478  		IsMethod:   false,
  2479  		IsResolver: false,
  2480  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2481  			return nil, errors.New("field of type String does not have child fields")
  2482  		},
  2483  	}
  2484  	return fc, nil
  2485  }
  2486  
  2487  func (ec *executionContext) _MultiHello_name(ctx context.Context, field graphql.CollectedField, obj *MultiHello) (ret graphql.Marshaler) {
  2488  	fc, err := ec.fieldContext_MultiHello_name(ctx, field)
  2489  	if err != nil {
  2490  		return graphql.Null
  2491  	}
  2492  	ctx = graphql.WithFieldContext(ctx, fc)
  2493  	defer func() {
  2494  		if r := recover(); r != nil {
  2495  			ec.Error(ctx, ec.Recover(ctx, r))
  2496  			ret = graphql.Null
  2497  		}
  2498  	}()
  2499  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2500  		ctx = rctx // use context from middleware stack in children
  2501  		return obj.Name, nil
  2502  	})
  2503  	if err != nil {
  2504  		ec.Error(ctx, err)
  2505  		return graphql.Null
  2506  	}
  2507  	if resTmp == nil {
  2508  		if !graphql.HasFieldError(ctx, fc) {
  2509  			ec.Errorf(ctx, "must not be null")
  2510  		}
  2511  		return graphql.Null
  2512  	}
  2513  	res := resTmp.(string)
  2514  	fc.Result = res
  2515  	return ec.marshalNString2string(ctx, field.Selections, res)
  2516  }
  2517  
  2518  func (ec *executionContext) fieldContext_MultiHello_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2519  	fc = &graphql.FieldContext{
  2520  		Object:     "MultiHello",
  2521  		Field:      field,
  2522  		IsMethod:   false,
  2523  		IsResolver: false,
  2524  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2525  			return nil, errors.New("field of type String does not have child fields")
  2526  		},
  2527  	}
  2528  	return fc, nil
  2529  }
  2530  
  2531  func (ec *executionContext) _MultiHelloMultipleRequires_name(ctx context.Context, field graphql.CollectedField, obj *MultiHelloMultipleRequires) (ret graphql.Marshaler) {
  2532  	fc, err := ec.fieldContext_MultiHelloMultipleRequires_name(ctx, field)
  2533  	if err != nil {
  2534  		return graphql.Null
  2535  	}
  2536  	ctx = graphql.WithFieldContext(ctx, fc)
  2537  	defer func() {
  2538  		if r := recover(); r != nil {
  2539  			ec.Error(ctx, ec.Recover(ctx, r))
  2540  			ret = graphql.Null
  2541  		}
  2542  	}()
  2543  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2544  		ctx = rctx // use context from middleware stack in children
  2545  		return obj.Name, nil
  2546  	})
  2547  	if err != nil {
  2548  		ec.Error(ctx, err)
  2549  		return graphql.Null
  2550  	}
  2551  	if resTmp == nil {
  2552  		if !graphql.HasFieldError(ctx, fc) {
  2553  			ec.Errorf(ctx, "must not be null")
  2554  		}
  2555  		return graphql.Null
  2556  	}
  2557  	res := resTmp.(string)
  2558  	fc.Result = res
  2559  	return ec.marshalNString2string(ctx, field.Selections, res)
  2560  }
  2561  
  2562  func (ec *executionContext) fieldContext_MultiHelloMultipleRequires_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2563  	fc = &graphql.FieldContext{
  2564  		Object:     "MultiHelloMultipleRequires",
  2565  		Field:      field,
  2566  		IsMethod:   false,
  2567  		IsResolver: false,
  2568  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2569  			return nil, errors.New("field of type String does not have child fields")
  2570  		},
  2571  	}
  2572  	return fc, nil
  2573  }
  2574  
  2575  func (ec *executionContext) _MultiHelloMultipleRequires_key1(ctx context.Context, field graphql.CollectedField, obj *MultiHelloMultipleRequires) (ret graphql.Marshaler) {
  2576  	fc, err := ec.fieldContext_MultiHelloMultipleRequires_key1(ctx, field)
  2577  	if err != nil {
  2578  		return graphql.Null
  2579  	}
  2580  	ctx = graphql.WithFieldContext(ctx, fc)
  2581  	defer func() {
  2582  		if r := recover(); r != nil {
  2583  			ec.Error(ctx, ec.Recover(ctx, r))
  2584  			ret = graphql.Null
  2585  		}
  2586  	}()
  2587  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2588  		ctx = rctx // use context from middleware stack in children
  2589  		return obj.Key1, nil
  2590  	})
  2591  	if err != nil {
  2592  		ec.Error(ctx, err)
  2593  		return graphql.Null
  2594  	}
  2595  	if resTmp == nil {
  2596  		if !graphql.HasFieldError(ctx, fc) {
  2597  			ec.Errorf(ctx, "must not be null")
  2598  		}
  2599  		return graphql.Null
  2600  	}
  2601  	res := resTmp.(string)
  2602  	fc.Result = res
  2603  	return ec.marshalNString2string(ctx, field.Selections, res)
  2604  }
  2605  
  2606  func (ec *executionContext) fieldContext_MultiHelloMultipleRequires_key1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2607  	fc = &graphql.FieldContext{
  2608  		Object:     "MultiHelloMultipleRequires",
  2609  		Field:      field,
  2610  		IsMethod:   false,
  2611  		IsResolver: false,
  2612  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2613  			return nil, errors.New("field of type String does not have child fields")
  2614  		},
  2615  	}
  2616  	return fc, nil
  2617  }
  2618  
  2619  func (ec *executionContext) _MultiHelloMultipleRequires_key2(ctx context.Context, field graphql.CollectedField, obj *MultiHelloMultipleRequires) (ret graphql.Marshaler) {
  2620  	fc, err := ec.fieldContext_MultiHelloMultipleRequires_key2(ctx, field)
  2621  	if err != nil {
  2622  		return graphql.Null
  2623  	}
  2624  	ctx = graphql.WithFieldContext(ctx, fc)
  2625  	defer func() {
  2626  		if r := recover(); r != nil {
  2627  			ec.Error(ctx, ec.Recover(ctx, r))
  2628  			ret = graphql.Null
  2629  		}
  2630  	}()
  2631  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2632  		ctx = rctx // use context from middleware stack in children
  2633  		return obj.Key2, nil
  2634  	})
  2635  	if err != nil {
  2636  		ec.Error(ctx, err)
  2637  		return graphql.Null
  2638  	}
  2639  	if resTmp == nil {
  2640  		if !graphql.HasFieldError(ctx, fc) {
  2641  			ec.Errorf(ctx, "must not be null")
  2642  		}
  2643  		return graphql.Null
  2644  	}
  2645  	res := resTmp.(string)
  2646  	fc.Result = res
  2647  	return ec.marshalNString2string(ctx, field.Selections, res)
  2648  }
  2649  
  2650  func (ec *executionContext) fieldContext_MultiHelloMultipleRequires_key2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2651  	fc = &graphql.FieldContext{
  2652  		Object:     "MultiHelloMultipleRequires",
  2653  		Field:      field,
  2654  		IsMethod:   false,
  2655  		IsResolver: false,
  2656  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2657  			return nil, errors.New("field of type String does not have child fields")
  2658  		},
  2659  	}
  2660  	return fc, nil
  2661  }
  2662  
  2663  func (ec *executionContext) _MultiHelloMultipleRequires_key3(ctx context.Context, field graphql.CollectedField, obj *MultiHelloMultipleRequires) (ret graphql.Marshaler) {
  2664  	fc, err := ec.fieldContext_MultiHelloMultipleRequires_key3(ctx, field)
  2665  	if err != nil {
  2666  		return graphql.Null
  2667  	}
  2668  	ctx = graphql.WithFieldContext(ctx, fc)
  2669  	defer func() {
  2670  		if r := recover(); r != nil {
  2671  			ec.Error(ctx, ec.Recover(ctx, r))
  2672  			ret = graphql.Null
  2673  		}
  2674  	}()
  2675  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2676  		ctx = rctx // use context from middleware stack in children
  2677  		return obj.Key3, nil
  2678  	})
  2679  	if err != nil {
  2680  		ec.Error(ctx, err)
  2681  		return graphql.Null
  2682  	}
  2683  	if resTmp == nil {
  2684  		if !graphql.HasFieldError(ctx, fc) {
  2685  			ec.Errorf(ctx, "must not be null")
  2686  		}
  2687  		return graphql.Null
  2688  	}
  2689  	res := resTmp.(string)
  2690  	fc.Result = res
  2691  	return ec.marshalNString2string(ctx, field.Selections, res)
  2692  }
  2693  
  2694  func (ec *executionContext) fieldContext_MultiHelloMultipleRequires_key3(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2695  	fc = &graphql.FieldContext{
  2696  		Object:     "MultiHelloMultipleRequires",
  2697  		Field:      field,
  2698  		IsMethod:   false,
  2699  		IsResolver: false,
  2700  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2701  			return nil, errors.New("field of type String does not have child fields")
  2702  		},
  2703  	}
  2704  	return fc, nil
  2705  }
  2706  
  2707  func (ec *executionContext) _MultiHelloRequires_name(ctx context.Context, field graphql.CollectedField, obj *MultiHelloRequires) (ret graphql.Marshaler) {
  2708  	fc, err := ec.fieldContext_MultiHelloRequires_name(ctx, field)
  2709  	if err != nil {
  2710  		return graphql.Null
  2711  	}
  2712  	ctx = graphql.WithFieldContext(ctx, fc)
  2713  	defer func() {
  2714  		if r := recover(); r != nil {
  2715  			ec.Error(ctx, ec.Recover(ctx, r))
  2716  			ret = graphql.Null
  2717  		}
  2718  	}()
  2719  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2720  		ctx = rctx // use context from middleware stack in children
  2721  		return obj.Name, nil
  2722  	})
  2723  	if err != nil {
  2724  		ec.Error(ctx, err)
  2725  		return graphql.Null
  2726  	}
  2727  	if resTmp == nil {
  2728  		if !graphql.HasFieldError(ctx, fc) {
  2729  			ec.Errorf(ctx, "must not be null")
  2730  		}
  2731  		return graphql.Null
  2732  	}
  2733  	res := resTmp.(string)
  2734  	fc.Result = res
  2735  	return ec.marshalNString2string(ctx, field.Selections, res)
  2736  }
  2737  
  2738  func (ec *executionContext) fieldContext_MultiHelloRequires_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2739  	fc = &graphql.FieldContext{
  2740  		Object:     "MultiHelloRequires",
  2741  		Field:      field,
  2742  		IsMethod:   false,
  2743  		IsResolver: false,
  2744  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2745  			return nil, errors.New("field of type String does not have child fields")
  2746  		},
  2747  	}
  2748  	return fc, nil
  2749  }
  2750  
  2751  func (ec *executionContext) _MultiHelloRequires_key1(ctx context.Context, field graphql.CollectedField, obj *MultiHelloRequires) (ret graphql.Marshaler) {
  2752  	fc, err := ec.fieldContext_MultiHelloRequires_key1(ctx, field)
  2753  	if err != nil {
  2754  		return graphql.Null
  2755  	}
  2756  	ctx = graphql.WithFieldContext(ctx, fc)
  2757  	defer func() {
  2758  		if r := recover(); r != nil {
  2759  			ec.Error(ctx, ec.Recover(ctx, r))
  2760  			ret = graphql.Null
  2761  		}
  2762  	}()
  2763  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2764  		ctx = rctx // use context from middleware stack in children
  2765  		return obj.Key1, nil
  2766  	})
  2767  	if err != nil {
  2768  		ec.Error(ctx, err)
  2769  		return graphql.Null
  2770  	}
  2771  	if resTmp == nil {
  2772  		if !graphql.HasFieldError(ctx, fc) {
  2773  			ec.Errorf(ctx, "must not be null")
  2774  		}
  2775  		return graphql.Null
  2776  	}
  2777  	res := resTmp.(string)
  2778  	fc.Result = res
  2779  	return ec.marshalNString2string(ctx, field.Selections, res)
  2780  }
  2781  
  2782  func (ec *executionContext) fieldContext_MultiHelloRequires_key1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2783  	fc = &graphql.FieldContext{
  2784  		Object:     "MultiHelloRequires",
  2785  		Field:      field,
  2786  		IsMethod:   false,
  2787  		IsResolver: false,
  2788  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2789  			return nil, errors.New("field of type String does not have child fields")
  2790  		},
  2791  	}
  2792  	return fc, nil
  2793  }
  2794  
  2795  func (ec *executionContext) _MultiHelloRequires_key2(ctx context.Context, field graphql.CollectedField, obj *MultiHelloRequires) (ret graphql.Marshaler) {
  2796  	fc, err := ec.fieldContext_MultiHelloRequires_key2(ctx, field)
  2797  	if err != nil {
  2798  		return graphql.Null
  2799  	}
  2800  	ctx = graphql.WithFieldContext(ctx, fc)
  2801  	defer func() {
  2802  		if r := recover(); r != nil {
  2803  			ec.Error(ctx, ec.Recover(ctx, r))
  2804  			ret = graphql.Null
  2805  		}
  2806  	}()
  2807  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2808  		ctx = rctx // use context from middleware stack in children
  2809  		return obj.Key2, nil
  2810  	})
  2811  	if err != nil {
  2812  		ec.Error(ctx, err)
  2813  		return graphql.Null
  2814  	}
  2815  	if resTmp == nil {
  2816  		if !graphql.HasFieldError(ctx, fc) {
  2817  			ec.Errorf(ctx, "must not be null")
  2818  		}
  2819  		return graphql.Null
  2820  	}
  2821  	res := resTmp.(string)
  2822  	fc.Result = res
  2823  	return ec.marshalNString2string(ctx, field.Selections, res)
  2824  }
  2825  
  2826  func (ec *executionContext) fieldContext_MultiHelloRequires_key2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2827  	fc = &graphql.FieldContext{
  2828  		Object:     "MultiHelloRequires",
  2829  		Field:      field,
  2830  		IsMethod:   false,
  2831  		IsResolver: false,
  2832  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2833  			return nil, errors.New("field of type String does not have child fields")
  2834  		},
  2835  	}
  2836  	return fc, nil
  2837  }
  2838  
  2839  func (ec *executionContext) _MultiHelloWithError_name(ctx context.Context, field graphql.CollectedField, obj *MultiHelloWithError) (ret graphql.Marshaler) {
  2840  	fc, err := ec.fieldContext_MultiHelloWithError_name(ctx, field)
  2841  	if err != nil {
  2842  		return graphql.Null
  2843  	}
  2844  	ctx = graphql.WithFieldContext(ctx, fc)
  2845  	defer func() {
  2846  		if r := recover(); r != nil {
  2847  			ec.Error(ctx, ec.Recover(ctx, r))
  2848  			ret = graphql.Null
  2849  		}
  2850  	}()
  2851  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2852  		ctx = rctx // use context from middleware stack in children
  2853  		return obj.Name, nil
  2854  	})
  2855  	if err != nil {
  2856  		ec.Error(ctx, err)
  2857  		return graphql.Null
  2858  	}
  2859  	if resTmp == nil {
  2860  		if !graphql.HasFieldError(ctx, fc) {
  2861  			ec.Errorf(ctx, "must not be null")
  2862  		}
  2863  		return graphql.Null
  2864  	}
  2865  	res := resTmp.(string)
  2866  	fc.Result = res
  2867  	return ec.marshalNString2string(ctx, field.Selections, res)
  2868  }
  2869  
  2870  func (ec *executionContext) fieldContext_MultiHelloWithError_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2871  	fc = &graphql.FieldContext{
  2872  		Object:     "MultiHelloWithError",
  2873  		Field:      field,
  2874  		IsMethod:   false,
  2875  		IsResolver: false,
  2876  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2877  			return nil, errors.New("field of type String does not have child fields")
  2878  		},
  2879  	}
  2880  	return fc, nil
  2881  }
  2882  
  2883  func (ec *executionContext) _MultiPlanetRequiresNested_name(ctx context.Context, field graphql.CollectedField, obj *MultiPlanetRequiresNested) (ret graphql.Marshaler) {
  2884  	fc, err := ec.fieldContext_MultiPlanetRequiresNested_name(ctx, field)
  2885  	if err != nil {
  2886  		return graphql.Null
  2887  	}
  2888  	ctx = graphql.WithFieldContext(ctx, fc)
  2889  	defer func() {
  2890  		if r := recover(); r != nil {
  2891  			ec.Error(ctx, ec.Recover(ctx, r))
  2892  			ret = graphql.Null
  2893  		}
  2894  	}()
  2895  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2896  		ctx = rctx // use context from middleware stack in children
  2897  		return obj.Name, nil
  2898  	})
  2899  	if err != nil {
  2900  		ec.Error(ctx, err)
  2901  		return graphql.Null
  2902  	}
  2903  	if resTmp == nil {
  2904  		if !graphql.HasFieldError(ctx, fc) {
  2905  			ec.Errorf(ctx, "must not be null")
  2906  		}
  2907  		return graphql.Null
  2908  	}
  2909  	res := resTmp.(string)
  2910  	fc.Result = res
  2911  	return ec.marshalNString2string(ctx, field.Selections, res)
  2912  }
  2913  
  2914  func (ec *executionContext) fieldContext_MultiPlanetRequiresNested_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2915  	fc = &graphql.FieldContext{
  2916  		Object:     "MultiPlanetRequiresNested",
  2917  		Field:      field,
  2918  		IsMethod:   false,
  2919  		IsResolver: false,
  2920  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2921  			return nil, errors.New("field of type String does not have child fields")
  2922  		},
  2923  	}
  2924  	return fc, nil
  2925  }
  2926  
  2927  func (ec *executionContext) _MultiPlanetRequiresNested_world(ctx context.Context, field graphql.CollectedField, obj *MultiPlanetRequiresNested) (ret graphql.Marshaler) {
  2928  	fc, err := ec.fieldContext_MultiPlanetRequiresNested_world(ctx, field)
  2929  	if err != nil {
  2930  		return graphql.Null
  2931  	}
  2932  	ctx = graphql.WithFieldContext(ctx, fc)
  2933  	defer func() {
  2934  		if r := recover(); r != nil {
  2935  			ec.Error(ctx, ec.Recover(ctx, r))
  2936  			ret = graphql.Null
  2937  		}
  2938  	}()
  2939  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2940  		ctx = rctx // use context from middleware stack in children
  2941  		return obj.World, nil
  2942  	})
  2943  	if err != nil {
  2944  		ec.Error(ctx, err)
  2945  		return graphql.Null
  2946  	}
  2947  	if resTmp == nil {
  2948  		if !graphql.HasFieldError(ctx, fc) {
  2949  			ec.Errorf(ctx, "must not be null")
  2950  		}
  2951  		return graphql.Null
  2952  	}
  2953  	res := resTmp.(*World)
  2954  	fc.Result = res
  2955  	return ec.marshalNWorld2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorld(ctx, field.Selections, res)
  2956  }
  2957  
  2958  func (ec *executionContext) fieldContext_MultiPlanetRequiresNested_world(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2959  	fc = &graphql.FieldContext{
  2960  		Object:     "MultiPlanetRequiresNested",
  2961  		Field:      field,
  2962  		IsMethod:   false,
  2963  		IsResolver: false,
  2964  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2965  			switch field.Name {
  2966  			case "foo":
  2967  				return ec.fieldContext_World_foo(ctx, field)
  2968  			case "bar":
  2969  				return ec.fieldContext_World_bar(ctx, field)
  2970  			case "hello":
  2971  				return ec.fieldContext_World_hello(ctx, field)
  2972  			}
  2973  			return nil, fmt.Errorf("no field named %q was found under type World", field.Name)
  2974  		},
  2975  	}
  2976  	return fc, nil
  2977  }
  2978  
  2979  func (ec *executionContext) _MultiPlanetRequiresNested_size(ctx context.Context, field graphql.CollectedField, obj *MultiPlanetRequiresNested) (ret graphql.Marshaler) {
  2980  	fc, err := ec.fieldContext_MultiPlanetRequiresNested_size(ctx, field)
  2981  	if err != nil {
  2982  		return graphql.Null
  2983  	}
  2984  	ctx = graphql.WithFieldContext(ctx, fc)
  2985  	defer func() {
  2986  		if r := recover(); r != nil {
  2987  			ec.Error(ctx, ec.Recover(ctx, r))
  2988  			ret = graphql.Null
  2989  		}
  2990  	}()
  2991  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2992  		ctx = rctx // use context from middleware stack in children
  2993  		return obj.Size, nil
  2994  	})
  2995  	if err != nil {
  2996  		ec.Error(ctx, err)
  2997  		return graphql.Null
  2998  	}
  2999  	if resTmp == nil {
  3000  		if !graphql.HasFieldError(ctx, fc) {
  3001  			ec.Errorf(ctx, "must not be null")
  3002  		}
  3003  		return graphql.Null
  3004  	}
  3005  	res := resTmp.(int)
  3006  	fc.Result = res
  3007  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3008  }
  3009  
  3010  func (ec *executionContext) fieldContext_MultiPlanetRequiresNested_size(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3011  	fc = &graphql.FieldContext{
  3012  		Object:     "MultiPlanetRequiresNested",
  3013  		Field:      field,
  3014  		IsMethod:   false,
  3015  		IsResolver: false,
  3016  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3017  			return nil, errors.New("field of type Int does not have child fields")
  3018  		},
  3019  	}
  3020  	return fc, nil
  3021  }
  3022  
  3023  func (ec *executionContext) _PlanetMultipleRequires_name(ctx context.Context, field graphql.CollectedField, obj *PlanetMultipleRequires) (ret graphql.Marshaler) {
  3024  	fc, err := ec.fieldContext_PlanetMultipleRequires_name(ctx, field)
  3025  	if err != nil {
  3026  		return graphql.Null
  3027  	}
  3028  	ctx = graphql.WithFieldContext(ctx, fc)
  3029  	defer func() {
  3030  		if r := recover(); r != nil {
  3031  			ec.Error(ctx, ec.Recover(ctx, r))
  3032  			ret = graphql.Null
  3033  		}
  3034  	}()
  3035  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3036  		ctx = rctx // use context from middleware stack in children
  3037  		return obj.Name, nil
  3038  	})
  3039  	if err != nil {
  3040  		ec.Error(ctx, err)
  3041  		return graphql.Null
  3042  	}
  3043  	if resTmp == nil {
  3044  		if !graphql.HasFieldError(ctx, fc) {
  3045  			ec.Errorf(ctx, "must not be null")
  3046  		}
  3047  		return graphql.Null
  3048  	}
  3049  	res := resTmp.(string)
  3050  	fc.Result = res
  3051  	return ec.marshalNString2string(ctx, field.Selections, res)
  3052  }
  3053  
  3054  func (ec *executionContext) fieldContext_PlanetMultipleRequires_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3055  	fc = &graphql.FieldContext{
  3056  		Object:     "PlanetMultipleRequires",
  3057  		Field:      field,
  3058  		IsMethod:   false,
  3059  		IsResolver: false,
  3060  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3061  			return nil, errors.New("field of type String does not have child fields")
  3062  		},
  3063  	}
  3064  	return fc, nil
  3065  }
  3066  
  3067  func (ec *executionContext) _PlanetMultipleRequires_diameter(ctx context.Context, field graphql.CollectedField, obj *PlanetMultipleRequires) (ret graphql.Marshaler) {
  3068  	fc, err := ec.fieldContext_PlanetMultipleRequires_diameter(ctx, field)
  3069  	if err != nil {
  3070  		return graphql.Null
  3071  	}
  3072  	ctx = graphql.WithFieldContext(ctx, fc)
  3073  	defer func() {
  3074  		if r := recover(); r != nil {
  3075  			ec.Error(ctx, ec.Recover(ctx, r))
  3076  			ret = graphql.Null
  3077  		}
  3078  	}()
  3079  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3080  		ctx = rctx // use context from middleware stack in children
  3081  		return obj.Diameter, nil
  3082  	})
  3083  	if err != nil {
  3084  		ec.Error(ctx, err)
  3085  		return graphql.Null
  3086  	}
  3087  	if resTmp == nil {
  3088  		if !graphql.HasFieldError(ctx, fc) {
  3089  			ec.Errorf(ctx, "must not be null")
  3090  		}
  3091  		return graphql.Null
  3092  	}
  3093  	res := resTmp.(int)
  3094  	fc.Result = res
  3095  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3096  }
  3097  
  3098  func (ec *executionContext) fieldContext_PlanetMultipleRequires_diameter(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3099  	fc = &graphql.FieldContext{
  3100  		Object:     "PlanetMultipleRequires",
  3101  		Field:      field,
  3102  		IsMethod:   false,
  3103  		IsResolver: false,
  3104  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3105  			return nil, errors.New("field of type Int does not have child fields")
  3106  		},
  3107  	}
  3108  	return fc, nil
  3109  }
  3110  
  3111  func (ec *executionContext) _PlanetMultipleRequires_density(ctx context.Context, field graphql.CollectedField, obj *PlanetMultipleRequires) (ret graphql.Marshaler) {
  3112  	fc, err := ec.fieldContext_PlanetMultipleRequires_density(ctx, field)
  3113  	if err != nil {
  3114  		return graphql.Null
  3115  	}
  3116  	ctx = graphql.WithFieldContext(ctx, fc)
  3117  	defer func() {
  3118  		if r := recover(); r != nil {
  3119  			ec.Error(ctx, ec.Recover(ctx, r))
  3120  			ret = graphql.Null
  3121  		}
  3122  	}()
  3123  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3124  		ctx = rctx // use context from middleware stack in children
  3125  		return obj.Density, nil
  3126  	})
  3127  	if err != nil {
  3128  		ec.Error(ctx, err)
  3129  		return graphql.Null
  3130  	}
  3131  	if resTmp == nil {
  3132  		if !graphql.HasFieldError(ctx, fc) {
  3133  			ec.Errorf(ctx, "must not be null")
  3134  		}
  3135  		return graphql.Null
  3136  	}
  3137  	res := resTmp.(int)
  3138  	fc.Result = res
  3139  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3140  }
  3141  
  3142  func (ec *executionContext) fieldContext_PlanetMultipleRequires_density(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3143  	fc = &graphql.FieldContext{
  3144  		Object:     "PlanetMultipleRequires",
  3145  		Field:      field,
  3146  		IsMethod:   false,
  3147  		IsResolver: false,
  3148  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3149  			return nil, errors.New("field of type Int does not have child fields")
  3150  		},
  3151  	}
  3152  	return fc, nil
  3153  }
  3154  
  3155  func (ec *executionContext) _PlanetMultipleRequires_weight(ctx context.Context, field graphql.CollectedField, obj *PlanetMultipleRequires) (ret graphql.Marshaler) {
  3156  	fc, err := ec.fieldContext_PlanetMultipleRequires_weight(ctx, field)
  3157  	if err != nil {
  3158  		return graphql.Null
  3159  	}
  3160  	ctx = graphql.WithFieldContext(ctx, fc)
  3161  	defer func() {
  3162  		if r := recover(); r != nil {
  3163  			ec.Error(ctx, ec.Recover(ctx, r))
  3164  			ret = graphql.Null
  3165  		}
  3166  	}()
  3167  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3168  		ctx = rctx // use context from middleware stack in children
  3169  		return obj.Weight, nil
  3170  	})
  3171  	if err != nil {
  3172  		ec.Error(ctx, err)
  3173  		return graphql.Null
  3174  	}
  3175  	if resTmp == nil {
  3176  		if !graphql.HasFieldError(ctx, fc) {
  3177  			ec.Errorf(ctx, "must not be null")
  3178  		}
  3179  		return graphql.Null
  3180  	}
  3181  	res := resTmp.(int)
  3182  	fc.Result = res
  3183  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3184  }
  3185  
  3186  func (ec *executionContext) fieldContext_PlanetMultipleRequires_weight(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3187  	fc = &graphql.FieldContext{
  3188  		Object:     "PlanetMultipleRequires",
  3189  		Field:      field,
  3190  		IsMethod:   false,
  3191  		IsResolver: false,
  3192  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3193  			return nil, errors.New("field of type Int does not have child fields")
  3194  		},
  3195  	}
  3196  	return fc, nil
  3197  }
  3198  
  3199  func (ec *executionContext) _PlanetRequires_name(ctx context.Context, field graphql.CollectedField, obj *PlanetRequires) (ret graphql.Marshaler) {
  3200  	fc, err := ec.fieldContext_PlanetRequires_name(ctx, field)
  3201  	if err != nil {
  3202  		return graphql.Null
  3203  	}
  3204  	ctx = graphql.WithFieldContext(ctx, fc)
  3205  	defer func() {
  3206  		if r := recover(); r != nil {
  3207  			ec.Error(ctx, ec.Recover(ctx, r))
  3208  			ret = graphql.Null
  3209  		}
  3210  	}()
  3211  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3212  		ctx = rctx // use context from middleware stack in children
  3213  		return obj.Name, nil
  3214  	})
  3215  	if err != nil {
  3216  		ec.Error(ctx, err)
  3217  		return graphql.Null
  3218  	}
  3219  	if resTmp == nil {
  3220  		if !graphql.HasFieldError(ctx, fc) {
  3221  			ec.Errorf(ctx, "must not be null")
  3222  		}
  3223  		return graphql.Null
  3224  	}
  3225  	res := resTmp.(string)
  3226  	fc.Result = res
  3227  	return ec.marshalNString2string(ctx, field.Selections, res)
  3228  }
  3229  
  3230  func (ec *executionContext) fieldContext_PlanetRequires_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3231  	fc = &graphql.FieldContext{
  3232  		Object:     "PlanetRequires",
  3233  		Field:      field,
  3234  		IsMethod:   false,
  3235  		IsResolver: false,
  3236  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3237  			return nil, errors.New("field of type String does not have child fields")
  3238  		},
  3239  	}
  3240  	return fc, nil
  3241  }
  3242  
  3243  func (ec *executionContext) _PlanetRequires_size(ctx context.Context, field graphql.CollectedField, obj *PlanetRequires) (ret graphql.Marshaler) {
  3244  	fc, err := ec.fieldContext_PlanetRequires_size(ctx, field)
  3245  	if err != nil {
  3246  		return graphql.Null
  3247  	}
  3248  	ctx = graphql.WithFieldContext(ctx, fc)
  3249  	defer func() {
  3250  		if r := recover(); r != nil {
  3251  			ec.Error(ctx, ec.Recover(ctx, r))
  3252  			ret = graphql.Null
  3253  		}
  3254  	}()
  3255  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3256  		ctx = rctx // use context from middleware stack in children
  3257  		return obj.Size, nil
  3258  	})
  3259  	if err != nil {
  3260  		ec.Error(ctx, err)
  3261  		return graphql.Null
  3262  	}
  3263  	if resTmp == nil {
  3264  		if !graphql.HasFieldError(ctx, fc) {
  3265  			ec.Errorf(ctx, "must not be null")
  3266  		}
  3267  		return graphql.Null
  3268  	}
  3269  	res := resTmp.(int)
  3270  	fc.Result = res
  3271  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3272  }
  3273  
  3274  func (ec *executionContext) fieldContext_PlanetRequires_size(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3275  	fc = &graphql.FieldContext{
  3276  		Object:     "PlanetRequires",
  3277  		Field:      field,
  3278  		IsMethod:   false,
  3279  		IsResolver: false,
  3280  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3281  			return nil, errors.New("field of type Int does not have child fields")
  3282  		},
  3283  	}
  3284  	return fc, nil
  3285  }
  3286  
  3287  func (ec *executionContext) _PlanetRequires_diameter(ctx context.Context, field graphql.CollectedField, obj *PlanetRequires) (ret graphql.Marshaler) {
  3288  	fc, err := ec.fieldContext_PlanetRequires_diameter(ctx, field)
  3289  	if err != nil {
  3290  		return graphql.Null
  3291  	}
  3292  	ctx = graphql.WithFieldContext(ctx, fc)
  3293  	defer func() {
  3294  		if r := recover(); r != nil {
  3295  			ec.Error(ctx, ec.Recover(ctx, r))
  3296  			ret = graphql.Null
  3297  		}
  3298  	}()
  3299  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3300  		ctx = rctx // use context from middleware stack in children
  3301  		return obj.Diameter, nil
  3302  	})
  3303  	if err != nil {
  3304  		ec.Error(ctx, err)
  3305  		return graphql.Null
  3306  	}
  3307  	if resTmp == nil {
  3308  		if !graphql.HasFieldError(ctx, fc) {
  3309  			ec.Errorf(ctx, "must not be null")
  3310  		}
  3311  		return graphql.Null
  3312  	}
  3313  	res := resTmp.(int)
  3314  	fc.Result = res
  3315  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3316  }
  3317  
  3318  func (ec *executionContext) fieldContext_PlanetRequires_diameter(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3319  	fc = &graphql.FieldContext{
  3320  		Object:     "PlanetRequires",
  3321  		Field:      field,
  3322  		IsMethod:   false,
  3323  		IsResolver: false,
  3324  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3325  			return nil, errors.New("field of type Int does not have child fields")
  3326  		},
  3327  	}
  3328  	return fc, nil
  3329  }
  3330  
  3331  func (ec *executionContext) _PlanetRequiresNested_name(ctx context.Context, field graphql.CollectedField, obj *PlanetRequiresNested) (ret graphql.Marshaler) {
  3332  	fc, err := ec.fieldContext_PlanetRequiresNested_name(ctx, field)
  3333  	if err != nil {
  3334  		return graphql.Null
  3335  	}
  3336  	ctx = graphql.WithFieldContext(ctx, fc)
  3337  	defer func() {
  3338  		if r := recover(); r != nil {
  3339  			ec.Error(ctx, ec.Recover(ctx, r))
  3340  			ret = graphql.Null
  3341  		}
  3342  	}()
  3343  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3344  		ctx = rctx // use context from middleware stack in children
  3345  		return obj.Name, nil
  3346  	})
  3347  	if err != nil {
  3348  		ec.Error(ctx, err)
  3349  		return graphql.Null
  3350  	}
  3351  	if resTmp == nil {
  3352  		if !graphql.HasFieldError(ctx, fc) {
  3353  			ec.Errorf(ctx, "must not be null")
  3354  		}
  3355  		return graphql.Null
  3356  	}
  3357  	res := resTmp.(string)
  3358  	fc.Result = res
  3359  	return ec.marshalNString2string(ctx, field.Selections, res)
  3360  }
  3361  
  3362  func (ec *executionContext) fieldContext_PlanetRequiresNested_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3363  	fc = &graphql.FieldContext{
  3364  		Object:     "PlanetRequiresNested",
  3365  		Field:      field,
  3366  		IsMethod:   false,
  3367  		IsResolver: false,
  3368  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3369  			return nil, errors.New("field of type String does not have child fields")
  3370  		},
  3371  	}
  3372  	return fc, nil
  3373  }
  3374  
  3375  func (ec *executionContext) _PlanetRequiresNested_world(ctx context.Context, field graphql.CollectedField, obj *PlanetRequiresNested) (ret graphql.Marshaler) {
  3376  	fc, err := ec.fieldContext_PlanetRequiresNested_world(ctx, field)
  3377  	if err != nil {
  3378  		return graphql.Null
  3379  	}
  3380  	ctx = graphql.WithFieldContext(ctx, fc)
  3381  	defer func() {
  3382  		if r := recover(); r != nil {
  3383  			ec.Error(ctx, ec.Recover(ctx, r))
  3384  			ret = graphql.Null
  3385  		}
  3386  	}()
  3387  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3388  		ctx = rctx // use context from middleware stack in children
  3389  		return obj.World, nil
  3390  	})
  3391  	if err != nil {
  3392  		ec.Error(ctx, err)
  3393  		return graphql.Null
  3394  	}
  3395  	if resTmp == nil {
  3396  		if !graphql.HasFieldError(ctx, fc) {
  3397  			ec.Errorf(ctx, "must not be null")
  3398  		}
  3399  		return graphql.Null
  3400  	}
  3401  	res := resTmp.(*World)
  3402  	fc.Result = res
  3403  	return ec.marshalNWorld2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorld(ctx, field.Selections, res)
  3404  }
  3405  
  3406  func (ec *executionContext) fieldContext_PlanetRequiresNested_world(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3407  	fc = &graphql.FieldContext{
  3408  		Object:     "PlanetRequiresNested",
  3409  		Field:      field,
  3410  		IsMethod:   false,
  3411  		IsResolver: false,
  3412  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3413  			switch field.Name {
  3414  			case "foo":
  3415  				return ec.fieldContext_World_foo(ctx, field)
  3416  			case "bar":
  3417  				return ec.fieldContext_World_bar(ctx, field)
  3418  			case "hello":
  3419  				return ec.fieldContext_World_hello(ctx, field)
  3420  			}
  3421  			return nil, fmt.Errorf("no field named %q was found under type World", field.Name)
  3422  		},
  3423  	}
  3424  	return fc, nil
  3425  }
  3426  
  3427  func (ec *executionContext) _PlanetRequiresNested_worlds(ctx context.Context, field graphql.CollectedField, obj *PlanetRequiresNested) (ret graphql.Marshaler) {
  3428  	fc, err := ec.fieldContext_PlanetRequiresNested_worlds(ctx, field)
  3429  	if err != nil {
  3430  		return graphql.Null
  3431  	}
  3432  	ctx = graphql.WithFieldContext(ctx, fc)
  3433  	defer func() {
  3434  		if r := recover(); r != nil {
  3435  			ec.Error(ctx, ec.Recover(ctx, r))
  3436  			ret = graphql.Null
  3437  		}
  3438  	}()
  3439  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3440  		ctx = rctx // use context from middleware stack in children
  3441  		return obj.Worlds, nil
  3442  	})
  3443  	if err != nil {
  3444  		ec.Error(ctx, err)
  3445  		return graphql.Null
  3446  	}
  3447  	if resTmp == nil {
  3448  		return graphql.Null
  3449  	}
  3450  	res := resTmp.([]*World)
  3451  	fc.Result = res
  3452  	return ec.marshalOWorld2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldᚄ(ctx, field.Selections, res)
  3453  }
  3454  
  3455  func (ec *executionContext) fieldContext_PlanetRequiresNested_worlds(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3456  	fc = &graphql.FieldContext{
  3457  		Object:     "PlanetRequiresNested",
  3458  		Field:      field,
  3459  		IsMethod:   false,
  3460  		IsResolver: false,
  3461  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3462  			switch field.Name {
  3463  			case "foo":
  3464  				return ec.fieldContext_World_foo(ctx, field)
  3465  			case "bar":
  3466  				return ec.fieldContext_World_bar(ctx, field)
  3467  			case "hello":
  3468  				return ec.fieldContext_World_hello(ctx, field)
  3469  			}
  3470  			return nil, fmt.Errorf("no field named %q was found under type World", field.Name)
  3471  		},
  3472  	}
  3473  	return fc, nil
  3474  }
  3475  
  3476  func (ec *executionContext) _PlanetRequiresNested_size(ctx context.Context, field graphql.CollectedField, obj *PlanetRequiresNested) (ret graphql.Marshaler) {
  3477  	fc, err := ec.fieldContext_PlanetRequiresNested_size(ctx, field)
  3478  	if err != nil {
  3479  		return graphql.Null
  3480  	}
  3481  	ctx = graphql.WithFieldContext(ctx, fc)
  3482  	defer func() {
  3483  		if r := recover(); r != nil {
  3484  			ec.Error(ctx, ec.Recover(ctx, r))
  3485  			ret = graphql.Null
  3486  		}
  3487  	}()
  3488  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3489  		ctx = rctx // use context from middleware stack in children
  3490  		return obj.Size, nil
  3491  	})
  3492  	if err != nil {
  3493  		ec.Error(ctx, err)
  3494  		return graphql.Null
  3495  	}
  3496  	if resTmp == nil {
  3497  		if !graphql.HasFieldError(ctx, fc) {
  3498  			ec.Errorf(ctx, "must not be null")
  3499  		}
  3500  		return graphql.Null
  3501  	}
  3502  	res := resTmp.(int)
  3503  	fc.Result = res
  3504  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3505  }
  3506  
  3507  func (ec *executionContext) fieldContext_PlanetRequiresNested_size(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3508  	fc = &graphql.FieldContext{
  3509  		Object:     "PlanetRequiresNested",
  3510  		Field:      field,
  3511  		IsMethod:   false,
  3512  		IsResolver: false,
  3513  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3514  			return nil, errors.New("field of type Int does not have child fields")
  3515  		},
  3516  	}
  3517  	return fc, nil
  3518  }
  3519  
  3520  func (ec *executionContext) _PlanetRequiresNested_sizes(ctx context.Context, field graphql.CollectedField, obj *PlanetRequiresNested) (ret graphql.Marshaler) {
  3521  	fc, err := ec.fieldContext_PlanetRequiresNested_sizes(ctx, field)
  3522  	if err != nil {
  3523  		return graphql.Null
  3524  	}
  3525  	ctx = graphql.WithFieldContext(ctx, fc)
  3526  	defer func() {
  3527  		if r := recover(); r != nil {
  3528  			ec.Error(ctx, ec.Recover(ctx, r))
  3529  			ret = graphql.Null
  3530  		}
  3531  	}()
  3532  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3533  		ctx = rctx // use context from middleware stack in children
  3534  		return obj.Sizes, nil
  3535  	})
  3536  	if err != nil {
  3537  		ec.Error(ctx, err)
  3538  		return graphql.Null
  3539  	}
  3540  	if resTmp == nil {
  3541  		return graphql.Null
  3542  	}
  3543  	res := resTmp.([]int)
  3544  	fc.Result = res
  3545  	return ec.marshalOInt2ᚕintᚄ(ctx, field.Selections, res)
  3546  }
  3547  
  3548  func (ec *executionContext) fieldContext_PlanetRequiresNested_sizes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3549  	fc = &graphql.FieldContext{
  3550  		Object:     "PlanetRequiresNested",
  3551  		Field:      field,
  3552  		IsMethod:   false,
  3553  		IsResolver: false,
  3554  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3555  			return nil, errors.New("field of type Int does not have child fields")
  3556  		},
  3557  	}
  3558  	return fc, nil
  3559  }
  3560  
  3561  func (ec *executionContext) _Query__entities(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3562  	fc, err := ec.fieldContext_Query__entities(ctx, field)
  3563  	if err != nil {
  3564  		return graphql.Null
  3565  	}
  3566  	ctx = graphql.WithFieldContext(ctx, fc)
  3567  	defer func() {
  3568  		if r := recover(); r != nil {
  3569  			ec.Error(ctx, ec.Recover(ctx, r))
  3570  			ret = graphql.Null
  3571  		}
  3572  	}()
  3573  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3574  		ctx = rctx // use context from middleware stack in children
  3575  		return ec.__resolve_entities(ctx, fc.Args["representations"].([]map[string]interface{})), nil
  3576  	})
  3577  	if err != nil {
  3578  		ec.Error(ctx, err)
  3579  		return graphql.Null
  3580  	}
  3581  	if resTmp == nil {
  3582  		if !graphql.HasFieldError(ctx, fc) {
  3583  			ec.Errorf(ctx, "must not be null")
  3584  		}
  3585  		return graphql.Null
  3586  	}
  3587  	res := resTmp.([]fedruntime.Entity)
  3588  	fc.Result = res
  3589  	return ec.marshalN_Entity2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐEntity(ctx, field.Selections, res)
  3590  }
  3591  
  3592  func (ec *executionContext) fieldContext_Query__entities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3593  	fc = &graphql.FieldContext{
  3594  		Object:     "Query",
  3595  		Field:      field,
  3596  		IsMethod:   true,
  3597  		IsResolver: false,
  3598  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3599  			return nil, errors.New("field of type _Entity does not have child fields")
  3600  		},
  3601  	}
  3602  	defer func() {
  3603  		if r := recover(); r != nil {
  3604  			err = ec.Recover(ctx, r)
  3605  			ec.Error(ctx, err)
  3606  		}
  3607  	}()
  3608  	ctx = graphql.WithFieldContext(ctx, fc)
  3609  	if fc.Args, err = ec.field_Query__entities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  3610  		ec.Error(ctx, err)
  3611  		return fc, err
  3612  	}
  3613  	return fc, nil
  3614  }
  3615  
  3616  func (ec *executionContext) _Query__service(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3617  	fc, err := ec.fieldContext_Query__service(ctx, field)
  3618  	if err != nil {
  3619  		return graphql.Null
  3620  	}
  3621  	ctx = graphql.WithFieldContext(ctx, fc)
  3622  	defer func() {
  3623  		if r := recover(); r != nil {
  3624  			ec.Error(ctx, ec.Recover(ctx, r))
  3625  			ret = graphql.Null
  3626  		}
  3627  	}()
  3628  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3629  		ctx = rctx // use context from middleware stack in children
  3630  		return ec.__resolve__service(ctx)
  3631  	})
  3632  	if err != nil {
  3633  		ec.Error(ctx, err)
  3634  		return graphql.Null
  3635  	}
  3636  	if resTmp == nil {
  3637  		if !graphql.HasFieldError(ctx, fc) {
  3638  			ec.Errorf(ctx, "must not be null")
  3639  		}
  3640  		return graphql.Null
  3641  	}
  3642  	res := resTmp.(fedruntime.Service)
  3643  	fc.Result = res
  3644  	return ec.marshalN_Service2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐService(ctx, field.Selections, res)
  3645  }
  3646  
  3647  func (ec *executionContext) fieldContext_Query__service(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3648  	fc = &graphql.FieldContext{
  3649  		Object:     "Query",
  3650  		Field:      field,
  3651  		IsMethod:   true,
  3652  		IsResolver: false,
  3653  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3654  			switch field.Name {
  3655  			case "sdl":
  3656  				return ec.fieldContext__Service_sdl(ctx, field)
  3657  			}
  3658  			return nil, fmt.Errorf("no field named %q was found under type _Service", field.Name)
  3659  		},
  3660  	}
  3661  	return fc, nil
  3662  }
  3663  
  3664  func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3665  	fc, err := ec.fieldContext_Query___type(ctx, field)
  3666  	if err != nil {
  3667  		return graphql.Null
  3668  	}
  3669  	ctx = graphql.WithFieldContext(ctx, fc)
  3670  	defer func() {
  3671  		if r := recover(); r != nil {
  3672  			ec.Error(ctx, ec.Recover(ctx, r))
  3673  			ret = graphql.Null
  3674  		}
  3675  	}()
  3676  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3677  		ctx = rctx // use context from middleware stack in children
  3678  		return ec.introspectType(fc.Args["name"].(string))
  3679  	})
  3680  	if err != nil {
  3681  		ec.Error(ctx, err)
  3682  		return graphql.Null
  3683  	}
  3684  	if resTmp == nil {
  3685  		return graphql.Null
  3686  	}
  3687  	res := resTmp.(*introspection.Type)
  3688  	fc.Result = res
  3689  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  3690  }
  3691  
  3692  func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3693  	fc = &graphql.FieldContext{
  3694  		Object:     "Query",
  3695  		Field:      field,
  3696  		IsMethod:   true,
  3697  		IsResolver: false,
  3698  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3699  			switch field.Name {
  3700  			case "kind":
  3701  				return ec.fieldContext___Type_kind(ctx, field)
  3702  			case "name":
  3703  				return ec.fieldContext___Type_name(ctx, field)
  3704  			case "description":
  3705  				return ec.fieldContext___Type_description(ctx, field)
  3706  			case "fields":
  3707  				return ec.fieldContext___Type_fields(ctx, field)
  3708  			case "interfaces":
  3709  				return ec.fieldContext___Type_interfaces(ctx, field)
  3710  			case "possibleTypes":
  3711  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  3712  			case "enumValues":
  3713  				return ec.fieldContext___Type_enumValues(ctx, field)
  3714  			case "inputFields":
  3715  				return ec.fieldContext___Type_inputFields(ctx, field)
  3716  			case "ofType":
  3717  				return ec.fieldContext___Type_ofType(ctx, field)
  3718  			case "specifiedByURL":
  3719  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  3720  			}
  3721  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  3722  		},
  3723  	}
  3724  	defer func() {
  3725  		if r := recover(); r != nil {
  3726  			err = ec.Recover(ctx, r)
  3727  			ec.Error(ctx, err)
  3728  		}
  3729  	}()
  3730  	ctx = graphql.WithFieldContext(ctx, fc)
  3731  	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  3732  		ec.Error(ctx, err)
  3733  		return fc, err
  3734  	}
  3735  	return fc, nil
  3736  }
  3737  
  3738  func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3739  	fc, err := ec.fieldContext_Query___schema(ctx, field)
  3740  	if err != nil {
  3741  		return graphql.Null
  3742  	}
  3743  	ctx = graphql.WithFieldContext(ctx, fc)
  3744  	defer func() {
  3745  		if r := recover(); r != nil {
  3746  			ec.Error(ctx, ec.Recover(ctx, r))
  3747  			ret = graphql.Null
  3748  		}
  3749  	}()
  3750  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3751  		ctx = rctx // use context from middleware stack in children
  3752  		return ec.introspectSchema()
  3753  	})
  3754  	if err != nil {
  3755  		ec.Error(ctx, err)
  3756  		return graphql.Null
  3757  	}
  3758  	if resTmp == nil {
  3759  		return graphql.Null
  3760  	}
  3761  	res := resTmp.(*introspection.Schema)
  3762  	fc.Result = res
  3763  	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
  3764  }
  3765  
  3766  func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3767  	fc = &graphql.FieldContext{
  3768  		Object:     "Query",
  3769  		Field:      field,
  3770  		IsMethod:   true,
  3771  		IsResolver: false,
  3772  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3773  			switch field.Name {
  3774  			case "description":
  3775  				return ec.fieldContext___Schema_description(ctx, field)
  3776  			case "types":
  3777  				return ec.fieldContext___Schema_types(ctx, field)
  3778  			case "queryType":
  3779  				return ec.fieldContext___Schema_queryType(ctx, field)
  3780  			case "mutationType":
  3781  				return ec.fieldContext___Schema_mutationType(ctx, field)
  3782  			case "subscriptionType":
  3783  				return ec.fieldContext___Schema_subscriptionType(ctx, field)
  3784  			case "directives":
  3785  				return ec.fieldContext___Schema_directives(ctx, field)
  3786  			}
  3787  			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
  3788  		},
  3789  	}
  3790  	return fc, nil
  3791  }
  3792  
  3793  func (ec *executionContext) _World_foo(ctx context.Context, field graphql.CollectedField, obj *World) (ret graphql.Marshaler) {
  3794  	fc, err := ec.fieldContext_World_foo(ctx, field)
  3795  	if err != nil {
  3796  		return graphql.Null
  3797  	}
  3798  	ctx = graphql.WithFieldContext(ctx, fc)
  3799  	defer func() {
  3800  		if r := recover(); r != nil {
  3801  			ec.Error(ctx, ec.Recover(ctx, r))
  3802  			ret = graphql.Null
  3803  		}
  3804  	}()
  3805  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3806  		ctx = rctx // use context from middleware stack in children
  3807  		return obj.Foo, nil
  3808  	})
  3809  	if err != nil {
  3810  		ec.Error(ctx, err)
  3811  		return graphql.Null
  3812  	}
  3813  	if resTmp == nil {
  3814  		if !graphql.HasFieldError(ctx, fc) {
  3815  			ec.Errorf(ctx, "must not be null")
  3816  		}
  3817  		return graphql.Null
  3818  	}
  3819  	res := resTmp.(string)
  3820  	fc.Result = res
  3821  	return ec.marshalNString2string(ctx, field.Selections, res)
  3822  }
  3823  
  3824  func (ec *executionContext) fieldContext_World_foo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3825  	fc = &graphql.FieldContext{
  3826  		Object:     "World",
  3827  		Field:      field,
  3828  		IsMethod:   false,
  3829  		IsResolver: false,
  3830  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3831  			return nil, errors.New("field of type String does not have child fields")
  3832  		},
  3833  	}
  3834  	return fc, nil
  3835  }
  3836  
  3837  func (ec *executionContext) _World_bar(ctx context.Context, field graphql.CollectedField, obj *World) (ret graphql.Marshaler) {
  3838  	fc, err := ec.fieldContext_World_bar(ctx, field)
  3839  	if err != nil {
  3840  		return graphql.Null
  3841  	}
  3842  	ctx = graphql.WithFieldContext(ctx, fc)
  3843  	defer func() {
  3844  		if r := recover(); r != nil {
  3845  			ec.Error(ctx, ec.Recover(ctx, r))
  3846  			ret = graphql.Null
  3847  		}
  3848  	}()
  3849  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3850  		ctx = rctx // use context from middleware stack in children
  3851  		return obj.Bar, nil
  3852  	})
  3853  	if err != nil {
  3854  		ec.Error(ctx, err)
  3855  		return graphql.Null
  3856  	}
  3857  	if resTmp == nil {
  3858  		if !graphql.HasFieldError(ctx, fc) {
  3859  			ec.Errorf(ctx, "must not be null")
  3860  		}
  3861  		return graphql.Null
  3862  	}
  3863  	res := resTmp.(int)
  3864  	fc.Result = res
  3865  	return ec.marshalNInt2int(ctx, field.Selections, res)
  3866  }
  3867  
  3868  func (ec *executionContext) fieldContext_World_bar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3869  	fc = &graphql.FieldContext{
  3870  		Object:     "World",
  3871  		Field:      field,
  3872  		IsMethod:   false,
  3873  		IsResolver: false,
  3874  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3875  			return nil, errors.New("field of type Int does not have child fields")
  3876  		},
  3877  	}
  3878  	return fc, nil
  3879  }
  3880  
  3881  func (ec *executionContext) _World_hello(ctx context.Context, field graphql.CollectedField, obj *World) (ret graphql.Marshaler) {
  3882  	fc, err := ec.fieldContext_World_hello(ctx, field)
  3883  	if err != nil {
  3884  		return graphql.Null
  3885  	}
  3886  	ctx = graphql.WithFieldContext(ctx, fc)
  3887  	defer func() {
  3888  		if r := recover(); r != nil {
  3889  			ec.Error(ctx, ec.Recover(ctx, r))
  3890  			ret = graphql.Null
  3891  		}
  3892  	}()
  3893  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3894  		ctx = rctx // use context from middleware stack in children
  3895  		return obj.Hello, nil
  3896  	})
  3897  	if err != nil {
  3898  		ec.Error(ctx, err)
  3899  		return graphql.Null
  3900  	}
  3901  	if resTmp == nil {
  3902  		return graphql.Null
  3903  	}
  3904  	res := resTmp.(*Hello)
  3905  	fc.Result = res
  3906  	return ec.marshalOHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHello(ctx, field.Selections, res)
  3907  }
  3908  
  3909  func (ec *executionContext) fieldContext_World_hello(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3910  	fc = &graphql.FieldContext{
  3911  		Object:     "World",
  3912  		Field:      field,
  3913  		IsMethod:   false,
  3914  		IsResolver: false,
  3915  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3916  			switch field.Name {
  3917  			case "name":
  3918  				return ec.fieldContext_Hello_name(ctx, field)
  3919  			case "secondary":
  3920  				return ec.fieldContext_Hello_secondary(ctx, field)
  3921  			}
  3922  			return nil, fmt.Errorf("no field named %q was found under type Hello", field.Name)
  3923  		},
  3924  	}
  3925  	return fc, nil
  3926  }
  3927  
  3928  func (ec *executionContext) _WorldName_name(ctx context.Context, field graphql.CollectedField, obj *WorldName) (ret graphql.Marshaler) {
  3929  	fc, err := ec.fieldContext_WorldName_name(ctx, field)
  3930  	if err != nil {
  3931  		return graphql.Null
  3932  	}
  3933  	ctx = graphql.WithFieldContext(ctx, fc)
  3934  	defer func() {
  3935  		if r := recover(); r != nil {
  3936  			ec.Error(ctx, ec.Recover(ctx, r))
  3937  			ret = graphql.Null
  3938  		}
  3939  	}()
  3940  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3941  		ctx = rctx // use context from middleware stack in children
  3942  		return obj.Name, nil
  3943  	})
  3944  	if err != nil {
  3945  		ec.Error(ctx, err)
  3946  		return graphql.Null
  3947  	}
  3948  	if resTmp == nil {
  3949  		if !graphql.HasFieldError(ctx, fc) {
  3950  			ec.Errorf(ctx, "must not be null")
  3951  		}
  3952  		return graphql.Null
  3953  	}
  3954  	res := resTmp.(string)
  3955  	fc.Result = res
  3956  	return ec.marshalNString2string(ctx, field.Selections, res)
  3957  }
  3958  
  3959  func (ec *executionContext) fieldContext_WorldName_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3960  	fc = &graphql.FieldContext{
  3961  		Object:     "WorldName",
  3962  		Field:      field,
  3963  		IsMethod:   false,
  3964  		IsResolver: false,
  3965  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3966  			return nil, errors.New("field of type String does not have child fields")
  3967  		},
  3968  	}
  3969  	return fc, nil
  3970  }
  3971  
  3972  func (ec *executionContext) _WorldWithMultipleKeys_foo(ctx context.Context, field graphql.CollectedField, obj *WorldWithMultipleKeys) (ret graphql.Marshaler) {
  3973  	fc, err := ec.fieldContext_WorldWithMultipleKeys_foo(ctx, field)
  3974  	if err != nil {
  3975  		return graphql.Null
  3976  	}
  3977  	ctx = graphql.WithFieldContext(ctx, fc)
  3978  	defer func() {
  3979  		if r := recover(); r != nil {
  3980  			ec.Error(ctx, ec.Recover(ctx, r))
  3981  			ret = graphql.Null
  3982  		}
  3983  	}()
  3984  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3985  		ctx = rctx // use context from middleware stack in children
  3986  		return obj.Foo, nil
  3987  	})
  3988  	if err != nil {
  3989  		ec.Error(ctx, err)
  3990  		return graphql.Null
  3991  	}
  3992  	if resTmp == nil {
  3993  		if !graphql.HasFieldError(ctx, fc) {
  3994  			ec.Errorf(ctx, "must not be null")
  3995  		}
  3996  		return graphql.Null
  3997  	}
  3998  	res := resTmp.(string)
  3999  	fc.Result = res
  4000  	return ec.marshalNString2string(ctx, field.Selections, res)
  4001  }
  4002  
  4003  func (ec *executionContext) fieldContext_WorldWithMultipleKeys_foo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4004  	fc = &graphql.FieldContext{
  4005  		Object:     "WorldWithMultipleKeys",
  4006  		Field:      field,
  4007  		IsMethod:   false,
  4008  		IsResolver: false,
  4009  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4010  			return nil, errors.New("field of type String does not have child fields")
  4011  		},
  4012  	}
  4013  	return fc, nil
  4014  }
  4015  
  4016  func (ec *executionContext) _WorldWithMultipleKeys_bar(ctx context.Context, field graphql.CollectedField, obj *WorldWithMultipleKeys) (ret graphql.Marshaler) {
  4017  	fc, err := ec.fieldContext_WorldWithMultipleKeys_bar(ctx, field)
  4018  	if err != nil {
  4019  		return graphql.Null
  4020  	}
  4021  	ctx = graphql.WithFieldContext(ctx, fc)
  4022  	defer func() {
  4023  		if r := recover(); r != nil {
  4024  			ec.Error(ctx, ec.Recover(ctx, r))
  4025  			ret = graphql.Null
  4026  		}
  4027  	}()
  4028  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4029  		ctx = rctx // use context from middleware stack in children
  4030  		return obj.Bar, nil
  4031  	})
  4032  	if err != nil {
  4033  		ec.Error(ctx, err)
  4034  		return graphql.Null
  4035  	}
  4036  	if resTmp == nil {
  4037  		if !graphql.HasFieldError(ctx, fc) {
  4038  			ec.Errorf(ctx, "must not be null")
  4039  		}
  4040  		return graphql.Null
  4041  	}
  4042  	res := resTmp.(int)
  4043  	fc.Result = res
  4044  	return ec.marshalNInt2int(ctx, field.Selections, res)
  4045  }
  4046  
  4047  func (ec *executionContext) fieldContext_WorldWithMultipleKeys_bar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4048  	fc = &graphql.FieldContext{
  4049  		Object:     "WorldWithMultipleKeys",
  4050  		Field:      field,
  4051  		IsMethod:   false,
  4052  		IsResolver: false,
  4053  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4054  			return nil, errors.New("field of type Int does not have child fields")
  4055  		},
  4056  	}
  4057  	return fc, nil
  4058  }
  4059  
  4060  func (ec *executionContext) _WorldWithMultipleKeys_hello(ctx context.Context, field graphql.CollectedField, obj *WorldWithMultipleKeys) (ret graphql.Marshaler) {
  4061  	fc, err := ec.fieldContext_WorldWithMultipleKeys_hello(ctx, field)
  4062  	if err != nil {
  4063  		return graphql.Null
  4064  	}
  4065  	ctx = graphql.WithFieldContext(ctx, fc)
  4066  	defer func() {
  4067  		if r := recover(); r != nil {
  4068  			ec.Error(ctx, ec.Recover(ctx, r))
  4069  			ret = graphql.Null
  4070  		}
  4071  	}()
  4072  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4073  		ctx = rctx // use context from middleware stack in children
  4074  		return obj.Hello, nil
  4075  	})
  4076  	if err != nil {
  4077  		ec.Error(ctx, err)
  4078  		return graphql.Null
  4079  	}
  4080  	if resTmp == nil {
  4081  		return graphql.Null
  4082  	}
  4083  	res := resTmp.(*Hello)
  4084  	fc.Result = res
  4085  	return ec.marshalOHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHello(ctx, field.Selections, res)
  4086  }
  4087  
  4088  func (ec *executionContext) fieldContext_WorldWithMultipleKeys_hello(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4089  	fc = &graphql.FieldContext{
  4090  		Object:     "WorldWithMultipleKeys",
  4091  		Field:      field,
  4092  		IsMethod:   false,
  4093  		IsResolver: false,
  4094  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4095  			switch field.Name {
  4096  			case "name":
  4097  				return ec.fieldContext_Hello_name(ctx, field)
  4098  			case "secondary":
  4099  				return ec.fieldContext_Hello_secondary(ctx, field)
  4100  			}
  4101  			return nil, fmt.Errorf("no field named %q was found under type Hello", field.Name)
  4102  		},
  4103  	}
  4104  	return fc, nil
  4105  }
  4106  
  4107  func (ec *executionContext) __Service_sdl(ctx context.Context, field graphql.CollectedField, obj *fedruntime.Service) (ret graphql.Marshaler) {
  4108  	fc, err := ec.fieldContext__Service_sdl(ctx, field)
  4109  	if err != nil {
  4110  		return graphql.Null
  4111  	}
  4112  	ctx = graphql.WithFieldContext(ctx, fc)
  4113  	defer func() {
  4114  		if r := recover(); r != nil {
  4115  			ec.Error(ctx, ec.Recover(ctx, r))
  4116  			ret = graphql.Null
  4117  		}
  4118  	}()
  4119  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4120  		ctx = rctx // use context from middleware stack in children
  4121  		return obj.SDL, nil
  4122  	})
  4123  	if err != nil {
  4124  		ec.Error(ctx, err)
  4125  		return graphql.Null
  4126  	}
  4127  	if resTmp == nil {
  4128  		return graphql.Null
  4129  	}
  4130  	res := resTmp.(string)
  4131  	fc.Result = res
  4132  	return ec.marshalOString2string(ctx, field.Selections, res)
  4133  }
  4134  
  4135  func (ec *executionContext) fieldContext__Service_sdl(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4136  	fc = &graphql.FieldContext{
  4137  		Object:     "_Service",
  4138  		Field:      field,
  4139  		IsMethod:   false,
  4140  		IsResolver: false,
  4141  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4142  			return nil, errors.New("field of type String does not have child fields")
  4143  		},
  4144  	}
  4145  	return fc, nil
  4146  }
  4147  
  4148  func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  4149  	fc, err := ec.fieldContext___Directive_name(ctx, field)
  4150  	if err != nil {
  4151  		return graphql.Null
  4152  	}
  4153  	ctx = graphql.WithFieldContext(ctx, fc)
  4154  	defer func() {
  4155  		if r := recover(); r != nil {
  4156  			ec.Error(ctx, ec.Recover(ctx, r))
  4157  			ret = graphql.Null
  4158  		}
  4159  	}()
  4160  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4161  		ctx = rctx // use context from middleware stack in children
  4162  		return obj.Name, nil
  4163  	})
  4164  	if err != nil {
  4165  		ec.Error(ctx, err)
  4166  		return graphql.Null
  4167  	}
  4168  	if resTmp == nil {
  4169  		if !graphql.HasFieldError(ctx, fc) {
  4170  			ec.Errorf(ctx, "must not be null")
  4171  		}
  4172  		return graphql.Null
  4173  	}
  4174  	res := resTmp.(string)
  4175  	fc.Result = res
  4176  	return ec.marshalNString2string(ctx, field.Selections, res)
  4177  }
  4178  
  4179  func (ec *executionContext) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4180  	fc = &graphql.FieldContext{
  4181  		Object:     "__Directive",
  4182  		Field:      field,
  4183  		IsMethod:   false,
  4184  		IsResolver: false,
  4185  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4186  			return nil, errors.New("field of type String does not have child fields")
  4187  		},
  4188  	}
  4189  	return fc, nil
  4190  }
  4191  
  4192  func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  4193  	fc, err := ec.fieldContext___Directive_description(ctx, field)
  4194  	if err != nil {
  4195  		return graphql.Null
  4196  	}
  4197  	ctx = graphql.WithFieldContext(ctx, fc)
  4198  	defer func() {
  4199  		if r := recover(); r != nil {
  4200  			ec.Error(ctx, ec.Recover(ctx, r))
  4201  			ret = graphql.Null
  4202  		}
  4203  	}()
  4204  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4205  		ctx = rctx // use context from middleware stack in children
  4206  		return obj.Description(), nil
  4207  	})
  4208  	if err != nil {
  4209  		ec.Error(ctx, err)
  4210  		return graphql.Null
  4211  	}
  4212  	if resTmp == nil {
  4213  		return graphql.Null
  4214  	}
  4215  	res := resTmp.(*string)
  4216  	fc.Result = res
  4217  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  4218  }
  4219  
  4220  func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4221  	fc = &graphql.FieldContext{
  4222  		Object:     "__Directive",
  4223  		Field:      field,
  4224  		IsMethod:   true,
  4225  		IsResolver: false,
  4226  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4227  			return nil, errors.New("field of type String does not have child fields")
  4228  		},
  4229  	}
  4230  	return fc, nil
  4231  }
  4232  
  4233  func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  4234  	fc, err := ec.fieldContext___Directive_locations(ctx, field)
  4235  	if err != nil {
  4236  		return graphql.Null
  4237  	}
  4238  	ctx = graphql.WithFieldContext(ctx, fc)
  4239  	defer func() {
  4240  		if r := recover(); r != nil {
  4241  			ec.Error(ctx, ec.Recover(ctx, r))
  4242  			ret = graphql.Null
  4243  		}
  4244  	}()
  4245  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4246  		ctx = rctx // use context from middleware stack in children
  4247  		return obj.Locations, nil
  4248  	})
  4249  	if err != nil {
  4250  		ec.Error(ctx, err)
  4251  		return graphql.Null
  4252  	}
  4253  	if resTmp == nil {
  4254  		if !graphql.HasFieldError(ctx, fc) {
  4255  			ec.Errorf(ctx, "must not be null")
  4256  		}
  4257  		return graphql.Null
  4258  	}
  4259  	res := resTmp.([]string)
  4260  	fc.Result = res
  4261  	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
  4262  }
  4263  
  4264  func (ec *executionContext) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4265  	fc = &graphql.FieldContext{
  4266  		Object:     "__Directive",
  4267  		Field:      field,
  4268  		IsMethod:   false,
  4269  		IsResolver: false,
  4270  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4271  			return nil, errors.New("field of type __DirectiveLocation does not have child fields")
  4272  		},
  4273  	}
  4274  	return fc, nil
  4275  }
  4276  
  4277  func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  4278  	fc, err := ec.fieldContext___Directive_args(ctx, field)
  4279  	if err != nil {
  4280  		return graphql.Null
  4281  	}
  4282  	ctx = graphql.WithFieldContext(ctx, fc)
  4283  	defer func() {
  4284  		if r := recover(); r != nil {
  4285  			ec.Error(ctx, ec.Recover(ctx, r))
  4286  			ret = graphql.Null
  4287  		}
  4288  	}()
  4289  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4290  		ctx = rctx // use context from middleware stack in children
  4291  		return obj.Args, nil
  4292  	})
  4293  	if err != nil {
  4294  		ec.Error(ctx, err)
  4295  		return graphql.Null
  4296  	}
  4297  	if resTmp == nil {
  4298  		if !graphql.HasFieldError(ctx, fc) {
  4299  			ec.Errorf(ctx, "must not be null")
  4300  		}
  4301  		return graphql.Null
  4302  	}
  4303  	res := resTmp.([]introspection.InputValue)
  4304  	fc.Result = res
  4305  	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  4306  }
  4307  
  4308  func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4309  	fc = &graphql.FieldContext{
  4310  		Object:     "__Directive",
  4311  		Field:      field,
  4312  		IsMethod:   false,
  4313  		IsResolver: false,
  4314  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4315  			switch field.Name {
  4316  			case "name":
  4317  				return ec.fieldContext___InputValue_name(ctx, field)
  4318  			case "description":
  4319  				return ec.fieldContext___InputValue_description(ctx, field)
  4320  			case "type":
  4321  				return ec.fieldContext___InputValue_type(ctx, field)
  4322  			case "defaultValue":
  4323  				return ec.fieldContext___InputValue_defaultValue(ctx, field)
  4324  			}
  4325  			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
  4326  		},
  4327  	}
  4328  	return fc, nil
  4329  }
  4330  
  4331  func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  4332  	fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
  4333  	if err != nil {
  4334  		return graphql.Null
  4335  	}
  4336  	ctx = graphql.WithFieldContext(ctx, fc)
  4337  	defer func() {
  4338  		if r := recover(); r != nil {
  4339  			ec.Error(ctx, ec.Recover(ctx, r))
  4340  			ret = graphql.Null
  4341  		}
  4342  	}()
  4343  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4344  		ctx = rctx // use context from middleware stack in children
  4345  		return obj.IsRepeatable, nil
  4346  	})
  4347  	if err != nil {
  4348  		ec.Error(ctx, err)
  4349  		return graphql.Null
  4350  	}
  4351  	if resTmp == nil {
  4352  		if !graphql.HasFieldError(ctx, fc) {
  4353  			ec.Errorf(ctx, "must not be null")
  4354  		}
  4355  		return graphql.Null
  4356  	}
  4357  	res := resTmp.(bool)
  4358  	fc.Result = res
  4359  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  4360  }
  4361  
  4362  func (ec *executionContext) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4363  	fc = &graphql.FieldContext{
  4364  		Object:     "__Directive",
  4365  		Field:      field,
  4366  		IsMethod:   false,
  4367  		IsResolver: false,
  4368  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4369  			return nil, errors.New("field of type Boolean does not have child fields")
  4370  		},
  4371  	}
  4372  	return fc, nil
  4373  }
  4374  
  4375  func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  4376  	fc, err := ec.fieldContext___EnumValue_name(ctx, field)
  4377  	if err != nil {
  4378  		return graphql.Null
  4379  	}
  4380  	ctx = graphql.WithFieldContext(ctx, fc)
  4381  	defer func() {
  4382  		if r := recover(); r != nil {
  4383  			ec.Error(ctx, ec.Recover(ctx, r))
  4384  			ret = graphql.Null
  4385  		}
  4386  	}()
  4387  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4388  		ctx = rctx // use context from middleware stack in children
  4389  		return obj.Name, nil
  4390  	})
  4391  	if err != nil {
  4392  		ec.Error(ctx, err)
  4393  		return graphql.Null
  4394  	}
  4395  	if resTmp == nil {
  4396  		if !graphql.HasFieldError(ctx, fc) {
  4397  			ec.Errorf(ctx, "must not be null")
  4398  		}
  4399  		return graphql.Null
  4400  	}
  4401  	res := resTmp.(string)
  4402  	fc.Result = res
  4403  	return ec.marshalNString2string(ctx, field.Selections, res)
  4404  }
  4405  
  4406  func (ec *executionContext) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4407  	fc = &graphql.FieldContext{
  4408  		Object:     "__EnumValue",
  4409  		Field:      field,
  4410  		IsMethod:   false,
  4411  		IsResolver: false,
  4412  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4413  			return nil, errors.New("field of type String does not have child fields")
  4414  		},
  4415  	}
  4416  	return fc, nil
  4417  }
  4418  
  4419  func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  4420  	fc, err := ec.fieldContext___EnumValue_description(ctx, field)
  4421  	if err != nil {
  4422  		return graphql.Null
  4423  	}
  4424  	ctx = graphql.WithFieldContext(ctx, fc)
  4425  	defer func() {
  4426  		if r := recover(); r != nil {
  4427  			ec.Error(ctx, ec.Recover(ctx, r))
  4428  			ret = graphql.Null
  4429  		}
  4430  	}()
  4431  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4432  		ctx = rctx // use context from middleware stack in children
  4433  		return obj.Description(), nil
  4434  	})
  4435  	if err != nil {
  4436  		ec.Error(ctx, err)
  4437  		return graphql.Null
  4438  	}
  4439  	if resTmp == nil {
  4440  		return graphql.Null
  4441  	}
  4442  	res := resTmp.(*string)
  4443  	fc.Result = res
  4444  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  4445  }
  4446  
  4447  func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4448  	fc = &graphql.FieldContext{
  4449  		Object:     "__EnumValue",
  4450  		Field:      field,
  4451  		IsMethod:   true,
  4452  		IsResolver: false,
  4453  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4454  			return nil, errors.New("field of type String does not have child fields")
  4455  		},
  4456  	}
  4457  	return fc, nil
  4458  }
  4459  
  4460  func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  4461  	fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
  4462  	if err != nil {
  4463  		return graphql.Null
  4464  	}
  4465  	ctx = graphql.WithFieldContext(ctx, fc)
  4466  	defer func() {
  4467  		if r := recover(); r != nil {
  4468  			ec.Error(ctx, ec.Recover(ctx, r))
  4469  			ret = graphql.Null
  4470  		}
  4471  	}()
  4472  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4473  		ctx = rctx // use context from middleware stack in children
  4474  		return obj.IsDeprecated(), nil
  4475  	})
  4476  	if err != nil {
  4477  		ec.Error(ctx, err)
  4478  		return graphql.Null
  4479  	}
  4480  	if resTmp == nil {
  4481  		if !graphql.HasFieldError(ctx, fc) {
  4482  			ec.Errorf(ctx, "must not be null")
  4483  		}
  4484  		return graphql.Null
  4485  	}
  4486  	res := resTmp.(bool)
  4487  	fc.Result = res
  4488  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  4489  }
  4490  
  4491  func (ec *executionContext) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4492  	fc = &graphql.FieldContext{
  4493  		Object:     "__EnumValue",
  4494  		Field:      field,
  4495  		IsMethod:   true,
  4496  		IsResolver: false,
  4497  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4498  			return nil, errors.New("field of type Boolean does not have child fields")
  4499  		},
  4500  	}
  4501  	return fc, nil
  4502  }
  4503  
  4504  func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  4505  	fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
  4506  	if err != nil {
  4507  		return graphql.Null
  4508  	}
  4509  	ctx = graphql.WithFieldContext(ctx, fc)
  4510  	defer func() {
  4511  		if r := recover(); r != nil {
  4512  			ec.Error(ctx, ec.Recover(ctx, r))
  4513  			ret = graphql.Null
  4514  		}
  4515  	}()
  4516  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4517  		ctx = rctx // use context from middleware stack in children
  4518  		return obj.DeprecationReason(), nil
  4519  	})
  4520  	if err != nil {
  4521  		ec.Error(ctx, err)
  4522  		return graphql.Null
  4523  	}
  4524  	if resTmp == nil {
  4525  		return graphql.Null
  4526  	}
  4527  	res := resTmp.(*string)
  4528  	fc.Result = res
  4529  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  4530  }
  4531  
  4532  func (ec *executionContext) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4533  	fc = &graphql.FieldContext{
  4534  		Object:     "__EnumValue",
  4535  		Field:      field,
  4536  		IsMethod:   true,
  4537  		IsResolver: false,
  4538  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4539  			return nil, errors.New("field of type String does not have child fields")
  4540  		},
  4541  	}
  4542  	return fc, nil
  4543  }
  4544  
  4545  func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  4546  	fc, err := ec.fieldContext___Field_name(ctx, field)
  4547  	if err != nil {
  4548  		return graphql.Null
  4549  	}
  4550  	ctx = graphql.WithFieldContext(ctx, fc)
  4551  	defer func() {
  4552  		if r := recover(); r != nil {
  4553  			ec.Error(ctx, ec.Recover(ctx, r))
  4554  			ret = graphql.Null
  4555  		}
  4556  	}()
  4557  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4558  		ctx = rctx // use context from middleware stack in children
  4559  		return obj.Name, nil
  4560  	})
  4561  	if err != nil {
  4562  		ec.Error(ctx, err)
  4563  		return graphql.Null
  4564  	}
  4565  	if resTmp == nil {
  4566  		if !graphql.HasFieldError(ctx, fc) {
  4567  			ec.Errorf(ctx, "must not be null")
  4568  		}
  4569  		return graphql.Null
  4570  	}
  4571  	res := resTmp.(string)
  4572  	fc.Result = res
  4573  	return ec.marshalNString2string(ctx, field.Selections, res)
  4574  }
  4575  
  4576  func (ec *executionContext) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4577  	fc = &graphql.FieldContext{
  4578  		Object:     "__Field",
  4579  		Field:      field,
  4580  		IsMethod:   false,
  4581  		IsResolver: false,
  4582  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4583  			return nil, errors.New("field of type String does not have child fields")
  4584  		},
  4585  	}
  4586  	return fc, nil
  4587  }
  4588  
  4589  func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  4590  	fc, err := ec.fieldContext___Field_description(ctx, field)
  4591  	if err != nil {
  4592  		return graphql.Null
  4593  	}
  4594  	ctx = graphql.WithFieldContext(ctx, fc)
  4595  	defer func() {
  4596  		if r := recover(); r != nil {
  4597  			ec.Error(ctx, ec.Recover(ctx, r))
  4598  			ret = graphql.Null
  4599  		}
  4600  	}()
  4601  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4602  		ctx = rctx // use context from middleware stack in children
  4603  		return obj.Description(), nil
  4604  	})
  4605  	if err != nil {
  4606  		ec.Error(ctx, err)
  4607  		return graphql.Null
  4608  	}
  4609  	if resTmp == nil {
  4610  		return graphql.Null
  4611  	}
  4612  	res := resTmp.(*string)
  4613  	fc.Result = res
  4614  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  4615  }
  4616  
  4617  func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4618  	fc = &graphql.FieldContext{
  4619  		Object:     "__Field",
  4620  		Field:      field,
  4621  		IsMethod:   true,
  4622  		IsResolver: false,
  4623  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4624  			return nil, errors.New("field of type String does not have child fields")
  4625  		},
  4626  	}
  4627  	return fc, nil
  4628  }
  4629  
  4630  func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  4631  	fc, err := ec.fieldContext___Field_args(ctx, field)
  4632  	if err != nil {
  4633  		return graphql.Null
  4634  	}
  4635  	ctx = graphql.WithFieldContext(ctx, fc)
  4636  	defer func() {
  4637  		if r := recover(); r != nil {
  4638  			ec.Error(ctx, ec.Recover(ctx, r))
  4639  			ret = graphql.Null
  4640  		}
  4641  	}()
  4642  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4643  		ctx = rctx // use context from middleware stack in children
  4644  		return obj.Args, nil
  4645  	})
  4646  	if err != nil {
  4647  		ec.Error(ctx, err)
  4648  		return graphql.Null
  4649  	}
  4650  	if resTmp == nil {
  4651  		if !graphql.HasFieldError(ctx, fc) {
  4652  			ec.Errorf(ctx, "must not be null")
  4653  		}
  4654  		return graphql.Null
  4655  	}
  4656  	res := resTmp.([]introspection.InputValue)
  4657  	fc.Result = res
  4658  	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  4659  }
  4660  
  4661  func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4662  	fc = &graphql.FieldContext{
  4663  		Object:     "__Field",
  4664  		Field:      field,
  4665  		IsMethod:   false,
  4666  		IsResolver: false,
  4667  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4668  			switch field.Name {
  4669  			case "name":
  4670  				return ec.fieldContext___InputValue_name(ctx, field)
  4671  			case "description":
  4672  				return ec.fieldContext___InputValue_description(ctx, field)
  4673  			case "type":
  4674  				return ec.fieldContext___InputValue_type(ctx, field)
  4675  			case "defaultValue":
  4676  				return ec.fieldContext___InputValue_defaultValue(ctx, field)
  4677  			}
  4678  			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
  4679  		},
  4680  	}
  4681  	return fc, nil
  4682  }
  4683  
  4684  func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  4685  	fc, err := ec.fieldContext___Field_type(ctx, field)
  4686  	if err != nil {
  4687  		return graphql.Null
  4688  	}
  4689  	ctx = graphql.WithFieldContext(ctx, fc)
  4690  	defer func() {
  4691  		if r := recover(); r != nil {
  4692  			ec.Error(ctx, ec.Recover(ctx, r))
  4693  			ret = graphql.Null
  4694  		}
  4695  	}()
  4696  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4697  		ctx = rctx // use context from middleware stack in children
  4698  		return obj.Type, nil
  4699  	})
  4700  	if err != nil {
  4701  		ec.Error(ctx, err)
  4702  		return graphql.Null
  4703  	}
  4704  	if resTmp == nil {
  4705  		if !graphql.HasFieldError(ctx, fc) {
  4706  			ec.Errorf(ctx, "must not be null")
  4707  		}
  4708  		return graphql.Null
  4709  	}
  4710  	res := resTmp.(*introspection.Type)
  4711  	fc.Result = res
  4712  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  4713  }
  4714  
  4715  func (ec *executionContext) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4716  	fc = &graphql.FieldContext{
  4717  		Object:     "__Field",
  4718  		Field:      field,
  4719  		IsMethod:   false,
  4720  		IsResolver: false,
  4721  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4722  			switch field.Name {
  4723  			case "kind":
  4724  				return ec.fieldContext___Type_kind(ctx, field)
  4725  			case "name":
  4726  				return ec.fieldContext___Type_name(ctx, field)
  4727  			case "description":
  4728  				return ec.fieldContext___Type_description(ctx, field)
  4729  			case "fields":
  4730  				return ec.fieldContext___Type_fields(ctx, field)
  4731  			case "interfaces":
  4732  				return ec.fieldContext___Type_interfaces(ctx, field)
  4733  			case "possibleTypes":
  4734  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  4735  			case "enumValues":
  4736  				return ec.fieldContext___Type_enumValues(ctx, field)
  4737  			case "inputFields":
  4738  				return ec.fieldContext___Type_inputFields(ctx, field)
  4739  			case "ofType":
  4740  				return ec.fieldContext___Type_ofType(ctx, field)
  4741  			case "specifiedByURL":
  4742  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  4743  			}
  4744  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  4745  		},
  4746  	}
  4747  	return fc, nil
  4748  }
  4749  
  4750  func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  4751  	fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
  4752  	if err != nil {
  4753  		return graphql.Null
  4754  	}
  4755  	ctx = graphql.WithFieldContext(ctx, fc)
  4756  	defer func() {
  4757  		if r := recover(); r != nil {
  4758  			ec.Error(ctx, ec.Recover(ctx, r))
  4759  			ret = graphql.Null
  4760  		}
  4761  	}()
  4762  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4763  		ctx = rctx // use context from middleware stack in children
  4764  		return obj.IsDeprecated(), nil
  4765  	})
  4766  	if err != nil {
  4767  		ec.Error(ctx, err)
  4768  		return graphql.Null
  4769  	}
  4770  	if resTmp == nil {
  4771  		if !graphql.HasFieldError(ctx, fc) {
  4772  			ec.Errorf(ctx, "must not be null")
  4773  		}
  4774  		return graphql.Null
  4775  	}
  4776  	res := resTmp.(bool)
  4777  	fc.Result = res
  4778  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  4779  }
  4780  
  4781  func (ec *executionContext) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4782  	fc = &graphql.FieldContext{
  4783  		Object:     "__Field",
  4784  		Field:      field,
  4785  		IsMethod:   true,
  4786  		IsResolver: false,
  4787  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4788  			return nil, errors.New("field of type Boolean does not have child fields")
  4789  		},
  4790  	}
  4791  	return fc, nil
  4792  }
  4793  
  4794  func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  4795  	fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
  4796  	if err != nil {
  4797  		return graphql.Null
  4798  	}
  4799  	ctx = graphql.WithFieldContext(ctx, fc)
  4800  	defer func() {
  4801  		if r := recover(); r != nil {
  4802  			ec.Error(ctx, ec.Recover(ctx, r))
  4803  			ret = graphql.Null
  4804  		}
  4805  	}()
  4806  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4807  		ctx = rctx // use context from middleware stack in children
  4808  		return obj.DeprecationReason(), nil
  4809  	})
  4810  	if err != nil {
  4811  		ec.Error(ctx, err)
  4812  		return graphql.Null
  4813  	}
  4814  	if resTmp == nil {
  4815  		return graphql.Null
  4816  	}
  4817  	res := resTmp.(*string)
  4818  	fc.Result = res
  4819  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  4820  }
  4821  
  4822  func (ec *executionContext) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4823  	fc = &graphql.FieldContext{
  4824  		Object:     "__Field",
  4825  		Field:      field,
  4826  		IsMethod:   true,
  4827  		IsResolver: false,
  4828  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4829  			return nil, errors.New("field of type String does not have child fields")
  4830  		},
  4831  	}
  4832  	return fc, nil
  4833  }
  4834  
  4835  func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  4836  	fc, err := ec.fieldContext___InputValue_name(ctx, field)
  4837  	if err != nil {
  4838  		return graphql.Null
  4839  	}
  4840  	ctx = graphql.WithFieldContext(ctx, fc)
  4841  	defer func() {
  4842  		if r := recover(); r != nil {
  4843  			ec.Error(ctx, ec.Recover(ctx, r))
  4844  			ret = graphql.Null
  4845  		}
  4846  	}()
  4847  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4848  		ctx = rctx // use context from middleware stack in children
  4849  		return obj.Name, nil
  4850  	})
  4851  	if err != nil {
  4852  		ec.Error(ctx, err)
  4853  		return graphql.Null
  4854  	}
  4855  	if resTmp == nil {
  4856  		if !graphql.HasFieldError(ctx, fc) {
  4857  			ec.Errorf(ctx, "must not be null")
  4858  		}
  4859  		return graphql.Null
  4860  	}
  4861  	res := resTmp.(string)
  4862  	fc.Result = res
  4863  	return ec.marshalNString2string(ctx, field.Selections, res)
  4864  }
  4865  
  4866  func (ec *executionContext) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4867  	fc = &graphql.FieldContext{
  4868  		Object:     "__InputValue",
  4869  		Field:      field,
  4870  		IsMethod:   false,
  4871  		IsResolver: false,
  4872  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4873  			return nil, errors.New("field of type String does not have child fields")
  4874  		},
  4875  	}
  4876  	return fc, nil
  4877  }
  4878  
  4879  func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  4880  	fc, err := ec.fieldContext___InputValue_description(ctx, field)
  4881  	if err != nil {
  4882  		return graphql.Null
  4883  	}
  4884  	ctx = graphql.WithFieldContext(ctx, fc)
  4885  	defer func() {
  4886  		if r := recover(); r != nil {
  4887  			ec.Error(ctx, ec.Recover(ctx, r))
  4888  			ret = graphql.Null
  4889  		}
  4890  	}()
  4891  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4892  		ctx = rctx // use context from middleware stack in children
  4893  		return obj.Description(), nil
  4894  	})
  4895  	if err != nil {
  4896  		ec.Error(ctx, err)
  4897  		return graphql.Null
  4898  	}
  4899  	if resTmp == nil {
  4900  		return graphql.Null
  4901  	}
  4902  	res := resTmp.(*string)
  4903  	fc.Result = res
  4904  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  4905  }
  4906  
  4907  func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4908  	fc = &graphql.FieldContext{
  4909  		Object:     "__InputValue",
  4910  		Field:      field,
  4911  		IsMethod:   true,
  4912  		IsResolver: false,
  4913  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4914  			return nil, errors.New("field of type String does not have child fields")
  4915  		},
  4916  	}
  4917  	return fc, nil
  4918  }
  4919  
  4920  func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  4921  	fc, err := ec.fieldContext___InputValue_type(ctx, field)
  4922  	if err != nil {
  4923  		return graphql.Null
  4924  	}
  4925  	ctx = graphql.WithFieldContext(ctx, fc)
  4926  	defer func() {
  4927  		if r := recover(); r != nil {
  4928  			ec.Error(ctx, ec.Recover(ctx, r))
  4929  			ret = graphql.Null
  4930  		}
  4931  	}()
  4932  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4933  		ctx = rctx // use context from middleware stack in children
  4934  		return obj.Type, nil
  4935  	})
  4936  	if err != nil {
  4937  		ec.Error(ctx, err)
  4938  		return graphql.Null
  4939  	}
  4940  	if resTmp == nil {
  4941  		if !graphql.HasFieldError(ctx, fc) {
  4942  			ec.Errorf(ctx, "must not be null")
  4943  		}
  4944  		return graphql.Null
  4945  	}
  4946  	res := resTmp.(*introspection.Type)
  4947  	fc.Result = res
  4948  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  4949  }
  4950  
  4951  func (ec *executionContext) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4952  	fc = &graphql.FieldContext{
  4953  		Object:     "__InputValue",
  4954  		Field:      field,
  4955  		IsMethod:   false,
  4956  		IsResolver: false,
  4957  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4958  			switch field.Name {
  4959  			case "kind":
  4960  				return ec.fieldContext___Type_kind(ctx, field)
  4961  			case "name":
  4962  				return ec.fieldContext___Type_name(ctx, field)
  4963  			case "description":
  4964  				return ec.fieldContext___Type_description(ctx, field)
  4965  			case "fields":
  4966  				return ec.fieldContext___Type_fields(ctx, field)
  4967  			case "interfaces":
  4968  				return ec.fieldContext___Type_interfaces(ctx, field)
  4969  			case "possibleTypes":
  4970  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  4971  			case "enumValues":
  4972  				return ec.fieldContext___Type_enumValues(ctx, field)
  4973  			case "inputFields":
  4974  				return ec.fieldContext___Type_inputFields(ctx, field)
  4975  			case "ofType":
  4976  				return ec.fieldContext___Type_ofType(ctx, field)
  4977  			case "specifiedByURL":
  4978  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  4979  			}
  4980  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  4981  		},
  4982  	}
  4983  	return fc, nil
  4984  }
  4985  
  4986  func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  4987  	fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
  4988  	if err != nil {
  4989  		return graphql.Null
  4990  	}
  4991  	ctx = graphql.WithFieldContext(ctx, fc)
  4992  	defer func() {
  4993  		if r := recover(); r != nil {
  4994  			ec.Error(ctx, ec.Recover(ctx, r))
  4995  			ret = graphql.Null
  4996  		}
  4997  	}()
  4998  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  4999  		ctx = rctx // use context from middleware stack in children
  5000  		return obj.DefaultValue, nil
  5001  	})
  5002  	if err != nil {
  5003  		ec.Error(ctx, err)
  5004  		return graphql.Null
  5005  	}
  5006  	if resTmp == nil {
  5007  		return graphql.Null
  5008  	}
  5009  	res := resTmp.(*string)
  5010  	fc.Result = res
  5011  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  5012  }
  5013  
  5014  func (ec *executionContext) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5015  	fc = &graphql.FieldContext{
  5016  		Object:     "__InputValue",
  5017  		Field:      field,
  5018  		IsMethod:   false,
  5019  		IsResolver: false,
  5020  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5021  			return nil, errors.New("field of type String does not have child fields")
  5022  		},
  5023  	}
  5024  	return fc, nil
  5025  }
  5026  
  5027  func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  5028  	fc, err := ec.fieldContext___Schema_description(ctx, field)
  5029  	if err != nil {
  5030  		return graphql.Null
  5031  	}
  5032  	ctx = graphql.WithFieldContext(ctx, fc)
  5033  	defer func() {
  5034  		if r := recover(); r != nil {
  5035  			ec.Error(ctx, ec.Recover(ctx, r))
  5036  			ret = graphql.Null
  5037  		}
  5038  	}()
  5039  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5040  		ctx = rctx // use context from middleware stack in children
  5041  		return obj.Description(), nil
  5042  	})
  5043  	if err != nil {
  5044  		ec.Error(ctx, err)
  5045  		return graphql.Null
  5046  	}
  5047  	if resTmp == nil {
  5048  		return graphql.Null
  5049  	}
  5050  	res := resTmp.(*string)
  5051  	fc.Result = res
  5052  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  5053  }
  5054  
  5055  func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5056  	fc = &graphql.FieldContext{
  5057  		Object:     "__Schema",
  5058  		Field:      field,
  5059  		IsMethod:   true,
  5060  		IsResolver: false,
  5061  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5062  			return nil, errors.New("field of type String does not have child fields")
  5063  		},
  5064  	}
  5065  	return fc, nil
  5066  }
  5067  
  5068  func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  5069  	fc, err := ec.fieldContext___Schema_types(ctx, field)
  5070  	if err != nil {
  5071  		return graphql.Null
  5072  	}
  5073  	ctx = graphql.WithFieldContext(ctx, fc)
  5074  	defer func() {
  5075  		if r := recover(); r != nil {
  5076  			ec.Error(ctx, ec.Recover(ctx, r))
  5077  			ret = graphql.Null
  5078  		}
  5079  	}()
  5080  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5081  		ctx = rctx // use context from middleware stack in children
  5082  		return obj.Types(), nil
  5083  	})
  5084  	if err != nil {
  5085  		ec.Error(ctx, err)
  5086  		return graphql.Null
  5087  	}
  5088  	if resTmp == nil {
  5089  		if !graphql.HasFieldError(ctx, fc) {
  5090  			ec.Errorf(ctx, "must not be null")
  5091  		}
  5092  		return graphql.Null
  5093  	}
  5094  	res := resTmp.([]introspection.Type)
  5095  	fc.Result = res
  5096  	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  5097  }
  5098  
  5099  func (ec *executionContext) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5100  	fc = &graphql.FieldContext{
  5101  		Object:     "__Schema",
  5102  		Field:      field,
  5103  		IsMethod:   true,
  5104  		IsResolver: false,
  5105  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5106  			switch field.Name {
  5107  			case "kind":
  5108  				return ec.fieldContext___Type_kind(ctx, field)
  5109  			case "name":
  5110  				return ec.fieldContext___Type_name(ctx, field)
  5111  			case "description":
  5112  				return ec.fieldContext___Type_description(ctx, field)
  5113  			case "fields":
  5114  				return ec.fieldContext___Type_fields(ctx, field)
  5115  			case "interfaces":
  5116  				return ec.fieldContext___Type_interfaces(ctx, field)
  5117  			case "possibleTypes":
  5118  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5119  			case "enumValues":
  5120  				return ec.fieldContext___Type_enumValues(ctx, field)
  5121  			case "inputFields":
  5122  				return ec.fieldContext___Type_inputFields(ctx, field)
  5123  			case "ofType":
  5124  				return ec.fieldContext___Type_ofType(ctx, field)
  5125  			case "specifiedByURL":
  5126  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5127  			}
  5128  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5129  		},
  5130  	}
  5131  	return fc, nil
  5132  }
  5133  
  5134  func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  5135  	fc, err := ec.fieldContext___Schema_queryType(ctx, field)
  5136  	if err != nil {
  5137  		return graphql.Null
  5138  	}
  5139  	ctx = graphql.WithFieldContext(ctx, fc)
  5140  	defer func() {
  5141  		if r := recover(); r != nil {
  5142  			ec.Error(ctx, ec.Recover(ctx, r))
  5143  			ret = graphql.Null
  5144  		}
  5145  	}()
  5146  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5147  		ctx = rctx // use context from middleware stack in children
  5148  		return obj.QueryType(), nil
  5149  	})
  5150  	if err != nil {
  5151  		ec.Error(ctx, err)
  5152  		return graphql.Null
  5153  	}
  5154  	if resTmp == nil {
  5155  		if !graphql.HasFieldError(ctx, fc) {
  5156  			ec.Errorf(ctx, "must not be null")
  5157  		}
  5158  		return graphql.Null
  5159  	}
  5160  	res := resTmp.(*introspection.Type)
  5161  	fc.Result = res
  5162  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  5163  }
  5164  
  5165  func (ec *executionContext) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5166  	fc = &graphql.FieldContext{
  5167  		Object:     "__Schema",
  5168  		Field:      field,
  5169  		IsMethod:   true,
  5170  		IsResolver: false,
  5171  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5172  			switch field.Name {
  5173  			case "kind":
  5174  				return ec.fieldContext___Type_kind(ctx, field)
  5175  			case "name":
  5176  				return ec.fieldContext___Type_name(ctx, field)
  5177  			case "description":
  5178  				return ec.fieldContext___Type_description(ctx, field)
  5179  			case "fields":
  5180  				return ec.fieldContext___Type_fields(ctx, field)
  5181  			case "interfaces":
  5182  				return ec.fieldContext___Type_interfaces(ctx, field)
  5183  			case "possibleTypes":
  5184  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5185  			case "enumValues":
  5186  				return ec.fieldContext___Type_enumValues(ctx, field)
  5187  			case "inputFields":
  5188  				return ec.fieldContext___Type_inputFields(ctx, field)
  5189  			case "ofType":
  5190  				return ec.fieldContext___Type_ofType(ctx, field)
  5191  			case "specifiedByURL":
  5192  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5193  			}
  5194  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5195  		},
  5196  	}
  5197  	return fc, nil
  5198  }
  5199  
  5200  func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  5201  	fc, err := ec.fieldContext___Schema_mutationType(ctx, field)
  5202  	if err != nil {
  5203  		return graphql.Null
  5204  	}
  5205  	ctx = graphql.WithFieldContext(ctx, fc)
  5206  	defer func() {
  5207  		if r := recover(); r != nil {
  5208  			ec.Error(ctx, ec.Recover(ctx, r))
  5209  			ret = graphql.Null
  5210  		}
  5211  	}()
  5212  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5213  		ctx = rctx // use context from middleware stack in children
  5214  		return obj.MutationType(), nil
  5215  	})
  5216  	if err != nil {
  5217  		ec.Error(ctx, err)
  5218  		return graphql.Null
  5219  	}
  5220  	if resTmp == nil {
  5221  		return graphql.Null
  5222  	}
  5223  	res := resTmp.(*introspection.Type)
  5224  	fc.Result = res
  5225  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  5226  }
  5227  
  5228  func (ec *executionContext) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5229  	fc = &graphql.FieldContext{
  5230  		Object:     "__Schema",
  5231  		Field:      field,
  5232  		IsMethod:   true,
  5233  		IsResolver: false,
  5234  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5235  			switch field.Name {
  5236  			case "kind":
  5237  				return ec.fieldContext___Type_kind(ctx, field)
  5238  			case "name":
  5239  				return ec.fieldContext___Type_name(ctx, field)
  5240  			case "description":
  5241  				return ec.fieldContext___Type_description(ctx, field)
  5242  			case "fields":
  5243  				return ec.fieldContext___Type_fields(ctx, field)
  5244  			case "interfaces":
  5245  				return ec.fieldContext___Type_interfaces(ctx, field)
  5246  			case "possibleTypes":
  5247  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5248  			case "enumValues":
  5249  				return ec.fieldContext___Type_enumValues(ctx, field)
  5250  			case "inputFields":
  5251  				return ec.fieldContext___Type_inputFields(ctx, field)
  5252  			case "ofType":
  5253  				return ec.fieldContext___Type_ofType(ctx, field)
  5254  			case "specifiedByURL":
  5255  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5256  			}
  5257  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5258  		},
  5259  	}
  5260  	return fc, nil
  5261  }
  5262  
  5263  func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  5264  	fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
  5265  	if err != nil {
  5266  		return graphql.Null
  5267  	}
  5268  	ctx = graphql.WithFieldContext(ctx, fc)
  5269  	defer func() {
  5270  		if r := recover(); r != nil {
  5271  			ec.Error(ctx, ec.Recover(ctx, r))
  5272  			ret = graphql.Null
  5273  		}
  5274  	}()
  5275  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5276  		ctx = rctx // use context from middleware stack in children
  5277  		return obj.SubscriptionType(), nil
  5278  	})
  5279  	if err != nil {
  5280  		ec.Error(ctx, err)
  5281  		return graphql.Null
  5282  	}
  5283  	if resTmp == nil {
  5284  		return graphql.Null
  5285  	}
  5286  	res := resTmp.(*introspection.Type)
  5287  	fc.Result = res
  5288  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  5289  }
  5290  
  5291  func (ec *executionContext) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5292  	fc = &graphql.FieldContext{
  5293  		Object:     "__Schema",
  5294  		Field:      field,
  5295  		IsMethod:   true,
  5296  		IsResolver: false,
  5297  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5298  			switch field.Name {
  5299  			case "kind":
  5300  				return ec.fieldContext___Type_kind(ctx, field)
  5301  			case "name":
  5302  				return ec.fieldContext___Type_name(ctx, field)
  5303  			case "description":
  5304  				return ec.fieldContext___Type_description(ctx, field)
  5305  			case "fields":
  5306  				return ec.fieldContext___Type_fields(ctx, field)
  5307  			case "interfaces":
  5308  				return ec.fieldContext___Type_interfaces(ctx, field)
  5309  			case "possibleTypes":
  5310  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5311  			case "enumValues":
  5312  				return ec.fieldContext___Type_enumValues(ctx, field)
  5313  			case "inputFields":
  5314  				return ec.fieldContext___Type_inputFields(ctx, field)
  5315  			case "ofType":
  5316  				return ec.fieldContext___Type_ofType(ctx, field)
  5317  			case "specifiedByURL":
  5318  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5319  			}
  5320  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5321  		},
  5322  	}
  5323  	return fc, nil
  5324  }
  5325  
  5326  func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  5327  	fc, err := ec.fieldContext___Schema_directives(ctx, field)
  5328  	if err != nil {
  5329  		return graphql.Null
  5330  	}
  5331  	ctx = graphql.WithFieldContext(ctx, fc)
  5332  	defer func() {
  5333  		if r := recover(); r != nil {
  5334  			ec.Error(ctx, ec.Recover(ctx, r))
  5335  			ret = graphql.Null
  5336  		}
  5337  	}()
  5338  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5339  		ctx = rctx // use context from middleware stack in children
  5340  		return obj.Directives(), nil
  5341  	})
  5342  	if err != nil {
  5343  		ec.Error(ctx, err)
  5344  		return graphql.Null
  5345  	}
  5346  	if resTmp == nil {
  5347  		if !graphql.HasFieldError(ctx, fc) {
  5348  			ec.Errorf(ctx, "must not be null")
  5349  		}
  5350  		return graphql.Null
  5351  	}
  5352  	res := resTmp.([]introspection.Directive)
  5353  	fc.Result = res
  5354  	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
  5355  }
  5356  
  5357  func (ec *executionContext) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5358  	fc = &graphql.FieldContext{
  5359  		Object:     "__Schema",
  5360  		Field:      field,
  5361  		IsMethod:   true,
  5362  		IsResolver: false,
  5363  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5364  			switch field.Name {
  5365  			case "name":
  5366  				return ec.fieldContext___Directive_name(ctx, field)
  5367  			case "description":
  5368  				return ec.fieldContext___Directive_description(ctx, field)
  5369  			case "locations":
  5370  				return ec.fieldContext___Directive_locations(ctx, field)
  5371  			case "args":
  5372  				return ec.fieldContext___Directive_args(ctx, field)
  5373  			case "isRepeatable":
  5374  				return ec.fieldContext___Directive_isRepeatable(ctx, field)
  5375  			}
  5376  			return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
  5377  		},
  5378  	}
  5379  	return fc, nil
  5380  }
  5381  
  5382  func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5383  	fc, err := ec.fieldContext___Type_kind(ctx, field)
  5384  	if err != nil {
  5385  		return graphql.Null
  5386  	}
  5387  	ctx = graphql.WithFieldContext(ctx, fc)
  5388  	defer func() {
  5389  		if r := recover(); r != nil {
  5390  			ec.Error(ctx, ec.Recover(ctx, r))
  5391  			ret = graphql.Null
  5392  		}
  5393  	}()
  5394  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5395  		ctx = rctx // use context from middleware stack in children
  5396  		return obj.Kind(), nil
  5397  	})
  5398  	if err != nil {
  5399  		ec.Error(ctx, err)
  5400  		return graphql.Null
  5401  	}
  5402  	if resTmp == nil {
  5403  		if !graphql.HasFieldError(ctx, fc) {
  5404  			ec.Errorf(ctx, "must not be null")
  5405  		}
  5406  		return graphql.Null
  5407  	}
  5408  	res := resTmp.(string)
  5409  	fc.Result = res
  5410  	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
  5411  }
  5412  
  5413  func (ec *executionContext) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5414  	fc = &graphql.FieldContext{
  5415  		Object:     "__Type",
  5416  		Field:      field,
  5417  		IsMethod:   true,
  5418  		IsResolver: false,
  5419  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5420  			return nil, errors.New("field of type __TypeKind does not have child fields")
  5421  		},
  5422  	}
  5423  	return fc, nil
  5424  }
  5425  
  5426  func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5427  	fc, err := ec.fieldContext___Type_name(ctx, field)
  5428  	if err != nil {
  5429  		return graphql.Null
  5430  	}
  5431  	ctx = graphql.WithFieldContext(ctx, fc)
  5432  	defer func() {
  5433  		if r := recover(); r != nil {
  5434  			ec.Error(ctx, ec.Recover(ctx, r))
  5435  			ret = graphql.Null
  5436  		}
  5437  	}()
  5438  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5439  		ctx = rctx // use context from middleware stack in children
  5440  		return obj.Name(), nil
  5441  	})
  5442  	if err != nil {
  5443  		ec.Error(ctx, err)
  5444  		return graphql.Null
  5445  	}
  5446  	if resTmp == nil {
  5447  		return graphql.Null
  5448  	}
  5449  	res := resTmp.(*string)
  5450  	fc.Result = res
  5451  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  5452  }
  5453  
  5454  func (ec *executionContext) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5455  	fc = &graphql.FieldContext{
  5456  		Object:     "__Type",
  5457  		Field:      field,
  5458  		IsMethod:   true,
  5459  		IsResolver: false,
  5460  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5461  			return nil, errors.New("field of type String does not have child fields")
  5462  		},
  5463  	}
  5464  	return fc, nil
  5465  }
  5466  
  5467  func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5468  	fc, err := ec.fieldContext___Type_description(ctx, field)
  5469  	if err != nil {
  5470  		return graphql.Null
  5471  	}
  5472  	ctx = graphql.WithFieldContext(ctx, fc)
  5473  	defer func() {
  5474  		if r := recover(); r != nil {
  5475  			ec.Error(ctx, ec.Recover(ctx, r))
  5476  			ret = graphql.Null
  5477  		}
  5478  	}()
  5479  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5480  		ctx = rctx // use context from middleware stack in children
  5481  		return obj.Description(), nil
  5482  	})
  5483  	if err != nil {
  5484  		ec.Error(ctx, err)
  5485  		return graphql.Null
  5486  	}
  5487  	if resTmp == nil {
  5488  		return graphql.Null
  5489  	}
  5490  	res := resTmp.(*string)
  5491  	fc.Result = res
  5492  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  5493  }
  5494  
  5495  func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5496  	fc = &graphql.FieldContext{
  5497  		Object:     "__Type",
  5498  		Field:      field,
  5499  		IsMethod:   true,
  5500  		IsResolver: false,
  5501  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5502  			return nil, errors.New("field of type String does not have child fields")
  5503  		},
  5504  	}
  5505  	return fc, nil
  5506  }
  5507  
  5508  func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5509  	fc, err := ec.fieldContext___Type_fields(ctx, field)
  5510  	if err != nil {
  5511  		return graphql.Null
  5512  	}
  5513  	ctx = graphql.WithFieldContext(ctx, fc)
  5514  	defer func() {
  5515  		if r := recover(); r != nil {
  5516  			ec.Error(ctx, ec.Recover(ctx, r))
  5517  			ret = graphql.Null
  5518  		}
  5519  	}()
  5520  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5521  		ctx = rctx // use context from middleware stack in children
  5522  		return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
  5523  	})
  5524  	if err != nil {
  5525  		ec.Error(ctx, err)
  5526  		return graphql.Null
  5527  	}
  5528  	if resTmp == nil {
  5529  		return graphql.Null
  5530  	}
  5531  	res := resTmp.([]introspection.Field)
  5532  	fc.Result = res
  5533  	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
  5534  }
  5535  
  5536  func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5537  	fc = &graphql.FieldContext{
  5538  		Object:     "__Type",
  5539  		Field:      field,
  5540  		IsMethod:   true,
  5541  		IsResolver: false,
  5542  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5543  			switch field.Name {
  5544  			case "name":
  5545  				return ec.fieldContext___Field_name(ctx, field)
  5546  			case "description":
  5547  				return ec.fieldContext___Field_description(ctx, field)
  5548  			case "args":
  5549  				return ec.fieldContext___Field_args(ctx, field)
  5550  			case "type":
  5551  				return ec.fieldContext___Field_type(ctx, field)
  5552  			case "isDeprecated":
  5553  				return ec.fieldContext___Field_isDeprecated(ctx, field)
  5554  			case "deprecationReason":
  5555  				return ec.fieldContext___Field_deprecationReason(ctx, field)
  5556  			}
  5557  			return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
  5558  		},
  5559  	}
  5560  	defer func() {
  5561  		if r := recover(); r != nil {
  5562  			err = ec.Recover(ctx, r)
  5563  			ec.Error(ctx, err)
  5564  		}
  5565  	}()
  5566  	ctx = graphql.WithFieldContext(ctx, fc)
  5567  	if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  5568  		ec.Error(ctx, err)
  5569  		return fc, err
  5570  	}
  5571  	return fc, nil
  5572  }
  5573  
  5574  func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5575  	fc, err := ec.fieldContext___Type_interfaces(ctx, field)
  5576  	if err != nil {
  5577  		return graphql.Null
  5578  	}
  5579  	ctx = graphql.WithFieldContext(ctx, fc)
  5580  	defer func() {
  5581  		if r := recover(); r != nil {
  5582  			ec.Error(ctx, ec.Recover(ctx, r))
  5583  			ret = graphql.Null
  5584  		}
  5585  	}()
  5586  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5587  		ctx = rctx // use context from middleware stack in children
  5588  		return obj.Interfaces(), nil
  5589  	})
  5590  	if err != nil {
  5591  		ec.Error(ctx, err)
  5592  		return graphql.Null
  5593  	}
  5594  	if resTmp == nil {
  5595  		return graphql.Null
  5596  	}
  5597  	res := resTmp.([]introspection.Type)
  5598  	fc.Result = res
  5599  	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  5600  }
  5601  
  5602  func (ec *executionContext) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5603  	fc = &graphql.FieldContext{
  5604  		Object:     "__Type",
  5605  		Field:      field,
  5606  		IsMethod:   true,
  5607  		IsResolver: false,
  5608  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5609  			switch field.Name {
  5610  			case "kind":
  5611  				return ec.fieldContext___Type_kind(ctx, field)
  5612  			case "name":
  5613  				return ec.fieldContext___Type_name(ctx, field)
  5614  			case "description":
  5615  				return ec.fieldContext___Type_description(ctx, field)
  5616  			case "fields":
  5617  				return ec.fieldContext___Type_fields(ctx, field)
  5618  			case "interfaces":
  5619  				return ec.fieldContext___Type_interfaces(ctx, field)
  5620  			case "possibleTypes":
  5621  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5622  			case "enumValues":
  5623  				return ec.fieldContext___Type_enumValues(ctx, field)
  5624  			case "inputFields":
  5625  				return ec.fieldContext___Type_inputFields(ctx, field)
  5626  			case "ofType":
  5627  				return ec.fieldContext___Type_ofType(ctx, field)
  5628  			case "specifiedByURL":
  5629  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5630  			}
  5631  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5632  		},
  5633  	}
  5634  	return fc, nil
  5635  }
  5636  
  5637  func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5638  	fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
  5639  	if err != nil {
  5640  		return graphql.Null
  5641  	}
  5642  	ctx = graphql.WithFieldContext(ctx, fc)
  5643  	defer func() {
  5644  		if r := recover(); r != nil {
  5645  			ec.Error(ctx, ec.Recover(ctx, r))
  5646  			ret = graphql.Null
  5647  		}
  5648  	}()
  5649  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5650  		ctx = rctx // use context from middleware stack in children
  5651  		return obj.PossibleTypes(), nil
  5652  	})
  5653  	if err != nil {
  5654  		ec.Error(ctx, err)
  5655  		return graphql.Null
  5656  	}
  5657  	if resTmp == nil {
  5658  		return graphql.Null
  5659  	}
  5660  	res := resTmp.([]introspection.Type)
  5661  	fc.Result = res
  5662  	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  5663  }
  5664  
  5665  func (ec *executionContext) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5666  	fc = &graphql.FieldContext{
  5667  		Object:     "__Type",
  5668  		Field:      field,
  5669  		IsMethod:   true,
  5670  		IsResolver: false,
  5671  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5672  			switch field.Name {
  5673  			case "kind":
  5674  				return ec.fieldContext___Type_kind(ctx, field)
  5675  			case "name":
  5676  				return ec.fieldContext___Type_name(ctx, field)
  5677  			case "description":
  5678  				return ec.fieldContext___Type_description(ctx, field)
  5679  			case "fields":
  5680  				return ec.fieldContext___Type_fields(ctx, field)
  5681  			case "interfaces":
  5682  				return ec.fieldContext___Type_interfaces(ctx, field)
  5683  			case "possibleTypes":
  5684  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5685  			case "enumValues":
  5686  				return ec.fieldContext___Type_enumValues(ctx, field)
  5687  			case "inputFields":
  5688  				return ec.fieldContext___Type_inputFields(ctx, field)
  5689  			case "ofType":
  5690  				return ec.fieldContext___Type_ofType(ctx, field)
  5691  			case "specifiedByURL":
  5692  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5693  			}
  5694  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5695  		},
  5696  	}
  5697  	return fc, nil
  5698  }
  5699  
  5700  func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5701  	fc, err := ec.fieldContext___Type_enumValues(ctx, field)
  5702  	if err != nil {
  5703  		return graphql.Null
  5704  	}
  5705  	ctx = graphql.WithFieldContext(ctx, fc)
  5706  	defer func() {
  5707  		if r := recover(); r != nil {
  5708  			ec.Error(ctx, ec.Recover(ctx, r))
  5709  			ret = graphql.Null
  5710  		}
  5711  	}()
  5712  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5713  		ctx = rctx // use context from middleware stack in children
  5714  		return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
  5715  	})
  5716  	if err != nil {
  5717  		ec.Error(ctx, err)
  5718  		return graphql.Null
  5719  	}
  5720  	if resTmp == nil {
  5721  		return graphql.Null
  5722  	}
  5723  	res := resTmp.([]introspection.EnumValue)
  5724  	fc.Result = res
  5725  	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
  5726  }
  5727  
  5728  func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5729  	fc = &graphql.FieldContext{
  5730  		Object:     "__Type",
  5731  		Field:      field,
  5732  		IsMethod:   true,
  5733  		IsResolver: false,
  5734  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5735  			switch field.Name {
  5736  			case "name":
  5737  				return ec.fieldContext___EnumValue_name(ctx, field)
  5738  			case "description":
  5739  				return ec.fieldContext___EnumValue_description(ctx, field)
  5740  			case "isDeprecated":
  5741  				return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
  5742  			case "deprecationReason":
  5743  				return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
  5744  			}
  5745  			return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
  5746  		},
  5747  	}
  5748  	defer func() {
  5749  		if r := recover(); r != nil {
  5750  			err = ec.Recover(ctx, r)
  5751  			ec.Error(ctx, err)
  5752  		}
  5753  	}()
  5754  	ctx = graphql.WithFieldContext(ctx, fc)
  5755  	if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  5756  		ec.Error(ctx, err)
  5757  		return fc, err
  5758  	}
  5759  	return fc, nil
  5760  }
  5761  
  5762  func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5763  	fc, err := ec.fieldContext___Type_inputFields(ctx, field)
  5764  	if err != nil {
  5765  		return graphql.Null
  5766  	}
  5767  	ctx = graphql.WithFieldContext(ctx, fc)
  5768  	defer func() {
  5769  		if r := recover(); r != nil {
  5770  			ec.Error(ctx, ec.Recover(ctx, r))
  5771  			ret = graphql.Null
  5772  		}
  5773  	}()
  5774  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5775  		ctx = rctx // use context from middleware stack in children
  5776  		return obj.InputFields(), nil
  5777  	})
  5778  	if err != nil {
  5779  		ec.Error(ctx, err)
  5780  		return graphql.Null
  5781  	}
  5782  	if resTmp == nil {
  5783  		return graphql.Null
  5784  	}
  5785  	res := resTmp.([]introspection.InputValue)
  5786  	fc.Result = res
  5787  	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  5788  }
  5789  
  5790  func (ec *executionContext) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5791  	fc = &graphql.FieldContext{
  5792  		Object:     "__Type",
  5793  		Field:      field,
  5794  		IsMethod:   true,
  5795  		IsResolver: false,
  5796  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5797  			switch field.Name {
  5798  			case "name":
  5799  				return ec.fieldContext___InputValue_name(ctx, field)
  5800  			case "description":
  5801  				return ec.fieldContext___InputValue_description(ctx, field)
  5802  			case "type":
  5803  				return ec.fieldContext___InputValue_type(ctx, field)
  5804  			case "defaultValue":
  5805  				return ec.fieldContext___InputValue_defaultValue(ctx, field)
  5806  			}
  5807  			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
  5808  		},
  5809  	}
  5810  	return fc, nil
  5811  }
  5812  
  5813  func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5814  	fc, err := ec.fieldContext___Type_ofType(ctx, field)
  5815  	if err != nil {
  5816  		return graphql.Null
  5817  	}
  5818  	ctx = graphql.WithFieldContext(ctx, fc)
  5819  	defer func() {
  5820  		if r := recover(); r != nil {
  5821  			ec.Error(ctx, ec.Recover(ctx, r))
  5822  			ret = graphql.Null
  5823  		}
  5824  	}()
  5825  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5826  		ctx = rctx // use context from middleware stack in children
  5827  		return obj.OfType(), nil
  5828  	})
  5829  	if err != nil {
  5830  		ec.Error(ctx, err)
  5831  		return graphql.Null
  5832  	}
  5833  	if resTmp == nil {
  5834  		return graphql.Null
  5835  	}
  5836  	res := resTmp.(*introspection.Type)
  5837  	fc.Result = res
  5838  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  5839  }
  5840  
  5841  func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5842  	fc = &graphql.FieldContext{
  5843  		Object:     "__Type",
  5844  		Field:      field,
  5845  		IsMethod:   true,
  5846  		IsResolver: false,
  5847  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5848  			switch field.Name {
  5849  			case "kind":
  5850  				return ec.fieldContext___Type_kind(ctx, field)
  5851  			case "name":
  5852  				return ec.fieldContext___Type_name(ctx, field)
  5853  			case "description":
  5854  				return ec.fieldContext___Type_description(ctx, field)
  5855  			case "fields":
  5856  				return ec.fieldContext___Type_fields(ctx, field)
  5857  			case "interfaces":
  5858  				return ec.fieldContext___Type_interfaces(ctx, field)
  5859  			case "possibleTypes":
  5860  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  5861  			case "enumValues":
  5862  				return ec.fieldContext___Type_enumValues(ctx, field)
  5863  			case "inputFields":
  5864  				return ec.fieldContext___Type_inputFields(ctx, field)
  5865  			case "ofType":
  5866  				return ec.fieldContext___Type_ofType(ctx, field)
  5867  			case "specifiedByURL":
  5868  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  5869  			}
  5870  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  5871  		},
  5872  	}
  5873  	return fc, nil
  5874  }
  5875  
  5876  func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  5877  	fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
  5878  	if err != nil {
  5879  		return graphql.Null
  5880  	}
  5881  	ctx = graphql.WithFieldContext(ctx, fc)
  5882  	defer func() {
  5883  		if r := recover(); r != nil {
  5884  			ec.Error(ctx, ec.Recover(ctx, r))
  5885  			ret = graphql.Null
  5886  		}
  5887  	}()
  5888  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  5889  		ctx = rctx // use context from middleware stack in children
  5890  		return obj.SpecifiedByURL(), nil
  5891  	})
  5892  	if err != nil {
  5893  		ec.Error(ctx, err)
  5894  		return graphql.Null
  5895  	}
  5896  	if resTmp == nil {
  5897  		return graphql.Null
  5898  	}
  5899  	res := resTmp.(*string)
  5900  	fc.Result = res
  5901  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  5902  }
  5903  
  5904  func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5905  	fc = &graphql.FieldContext{
  5906  		Object:     "__Type",
  5907  		Field:      field,
  5908  		IsMethod:   true,
  5909  		IsResolver: false,
  5910  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5911  			return nil, errors.New("field of type String does not have child fields")
  5912  		},
  5913  	}
  5914  	return fc, nil
  5915  }
  5916  
  5917  // endregion **************************** field.gotpl *****************************
  5918  
  5919  // region    **************************** input.gotpl *****************************
  5920  
  5921  func (ec *executionContext) unmarshalInputMultiHelloByNamesInput(ctx context.Context, obj interface{}) (MultiHelloByNamesInput, error) {
  5922  	var it MultiHelloByNamesInput
  5923  	asMap := map[string]interface{}{}
  5924  	for k, v := range obj.(map[string]interface{}) {
  5925  		asMap[k] = v
  5926  	}
  5927  
  5928  	fieldsInOrder := [...]string{"Name"}
  5929  	for _, k := range fieldsInOrder {
  5930  		v, ok := asMap[k]
  5931  		if !ok {
  5932  			continue
  5933  		}
  5934  		switch k {
  5935  		case "Name":
  5936  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Name"))
  5937  			data, err := ec.unmarshalNString2string(ctx, v)
  5938  			if err != nil {
  5939  				return it, err
  5940  			}
  5941  			it.Name = data
  5942  		}
  5943  	}
  5944  
  5945  	return it, nil
  5946  }
  5947  
  5948  func (ec *executionContext) unmarshalInputMultiHelloMultipleRequiresByNamesInput(ctx context.Context, obj interface{}) (MultiHelloMultipleRequiresByNamesInput, error) {
  5949  	var it MultiHelloMultipleRequiresByNamesInput
  5950  	asMap := map[string]interface{}{}
  5951  	for k, v := range obj.(map[string]interface{}) {
  5952  		asMap[k] = v
  5953  	}
  5954  
  5955  	fieldsInOrder := [...]string{"Name"}
  5956  	for _, k := range fieldsInOrder {
  5957  		v, ok := asMap[k]
  5958  		if !ok {
  5959  			continue
  5960  		}
  5961  		switch k {
  5962  		case "Name":
  5963  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Name"))
  5964  			data, err := ec.unmarshalNString2string(ctx, v)
  5965  			if err != nil {
  5966  				return it, err
  5967  			}
  5968  			it.Name = data
  5969  		}
  5970  	}
  5971  
  5972  	return it, nil
  5973  }
  5974  
  5975  func (ec *executionContext) unmarshalInputMultiHelloRequiresByNamesInput(ctx context.Context, obj interface{}) (MultiHelloRequiresByNamesInput, error) {
  5976  	var it MultiHelloRequiresByNamesInput
  5977  	asMap := map[string]interface{}{}
  5978  	for k, v := range obj.(map[string]interface{}) {
  5979  		asMap[k] = v
  5980  	}
  5981  
  5982  	fieldsInOrder := [...]string{"Name"}
  5983  	for _, k := range fieldsInOrder {
  5984  		v, ok := asMap[k]
  5985  		if !ok {
  5986  			continue
  5987  		}
  5988  		switch k {
  5989  		case "Name":
  5990  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Name"))
  5991  			data, err := ec.unmarshalNString2string(ctx, v)
  5992  			if err != nil {
  5993  				return it, err
  5994  			}
  5995  			it.Name = data
  5996  		}
  5997  	}
  5998  
  5999  	return it, nil
  6000  }
  6001  
  6002  func (ec *executionContext) unmarshalInputMultiHelloWithErrorByNamesInput(ctx context.Context, obj interface{}) (MultiHelloWithErrorByNamesInput, error) {
  6003  	var it MultiHelloWithErrorByNamesInput
  6004  	asMap := map[string]interface{}{}
  6005  	for k, v := range obj.(map[string]interface{}) {
  6006  		asMap[k] = v
  6007  	}
  6008  
  6009  	fieldsInOrder := [...]string{"Name"}
  6010  	for _, k := range fieldsInOrder {
  6011  		v, ok := asMap[k]
  6012  		if !ok {
  6013  			continue
  6014  		}
  6015  		switch k {
  6016  		case "Name":
  6017  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Name"))
  6018  			data, err := ec.unmarshalNString2string(ctx, v)
  6019  			if err != nil {
  6020  				return it, err
  6021  			}
  6022  			it.Name = data
  6023  		}
  6024  	}
  6025  
  6026  	return it, nil
  6027  }
  6028  
  6029  func (ec *executionContext) unmarshalInputMultiPlanetRequiresNestedByNamesInput(ctx context.Context, obj interface{}) (MultiPlanetRequiresNestedByNamesInput, error) {
  6030  	var it MultiPlanetRequiresNestedByNamesInput
  6031  	asMap := map[string]interface{}{}
  6032  	for k, v := range obj.(map[string]interface{}) {
  6033  		asMap[k] = v
  6034  	}
  6035  
  6036  	fieldsInOrder := [...]string{"Name"}
  6037  	for _, k := range fieldsInOrder {
  6038  		v, ok := asMap[k]
  6039  		if !ok {
  6040  			continue
  6041  		}
  6042  		switch k {
  6043  		case "Name":
  6044  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Name"))
  6045  			data, err := ec.unmarshalNString2string(ctx, v)
  6046  			if err != nil {
  6047  				return it, err
  6048  			}
  6049  			it.Name = data
  6050  		}
  6051  	}
  6052  
  6053  	return it, nil
  6054  }
  6055  
  6056  // endregion **************************** input.gotpl *****************************
  6057  
  6058  // region    ************************** interface.gotpl ***************************
  6059  
  6060  func (ec *executionContext) __Entity(ctx context.Context, sel ast.SelectionSet, obj fedruntime.Entity) graphql.Marshaler {
  6061  	switch obj := (obj).(type) {
  6062  	case nil:
  6063  		return graphql.Null
  6064  	case Hello:
  6065  		return ec._Hello(ctx, sel, &obj)
  6066  	case *Hello:
  6067  		if obj == nil {
  6068  			return graphql.Null
  6069  		}
  6070  		return ec._Hello(ctx, sel, obj)
  6071  	case HelloMultiSingleKeys:
  6072  		return ec._HelloMultiSingleKeys(ctx, sel, &obj)
  6073  	case *HelloMultiSingleKeys:
  6074  		if obj == nil {
  6075  			return graphql.Null
  6076  		}
  6077  		return ec._HelloMultiSingleKeys(ctx, sel, obj)
  6078  	case HelloWithErrors:
  6079  		return ec._HelloWithErrors(ctx, sel, &obj)
  6080  	case *HelloWithErrors:
  6081  		if obj == nil {
  6082  			return graphql.Null
  6083  		}
  6084  		return ec._HelloWithErrors(ctx, sel, obj)
  6085  	case MultiHello:
  6086  		return ec._MultiHello(ctx, sel, &obj)
  6087  	case *MultiHello:
  6088  		if obj == nil {
  6089  			return graphql.Null
  6090  		}
  6091  		return ec._MultiHello(ctx, sel, obj)
  6092  	case MultiHelloMultipleRequires:
  6093  		return ec._MultiHelloMultipleRequires(ctx, sel, &obj)
  6094  	case *MultiHelloMultipleRequires:
  6095  		if obj == nil {
  6096  			return graphql.Null
  6097  		}
  6098  		return ec._MultiHelloMultipleRequires(ctx, sel, obj)
  6099  	case MultiHelloRequires:
  6100  		return ec._MultiHelloRequires(ctx, sel, &obj)
  6101  	case *MultiHelloRequires:
  6102  		if obj == nil {
  6103  			return graphql.Null
  6104  		}
  6105  		return ec._MultiHelloRequires(ctx, sel, obj)
  6106  	case MultiHelloWithError:
  6107  		return ec._MultiHelloWithError(ctx, sel, &obj)
  6108  	case *MultiHelloWithError:
  6109  		if obj == nil {
  6110  			return graphql.Null
  6111  		}
  6112  		return ec._MultiHelloWithError(ctx, sel, obj)
  6113  	case MultiPlanetRequiresNested:
  6114  		return ec._MultiPlanetRequiresNested(ctx, sel, &obj)
  6115  	case *MultiPlanetRequiresNested:
  6116  		if obj == nil {
  6117  			return graphql.Null
  6118  		}
  6119  		return ec._MultiPlanetRequiresNested(ctx, sel, obj)
  6120  	case PlanetMultipleRequires:
  6121  		return ec._PlanetMultipleRequires(ctx, sel, &obj)
  6122  	case *PlanetMultipleRequires:
  6123  		if obj == nil {
  6124  			return graphql.Null
  6125  		}
  6126  		return ec._PlanetMultipleRequires(ctx, sel, obj)
  6127  	case PlanetRequires:
  6128  		return ec._PlanetRequires(ctx, sel, &obj)
  6129  	case *PlanetRequires:
  6130  		if obj == nil {
  6131  			return graphql.Null
  6132  		}
  6133  		return ec._PlanetRequires(ctx, sel, obj)
  6134  	case PlanetRequiresNested:
  6135  		return ec._PlanetRequiresNested(ctx, sel, &obj)
  6136  	case *PlanetRequiresNested:
  6137  		if obj == nil {
  6138  			return graphql.Null
  6139  		}
  6140  		return ec._PlanetRequiresNested(ctx, sel, obj)
  6141  	case World:
  6142  		return ec._World(ctx, sel, &obj)
  6143  	case *World:
  6144  		if obj == nil {
  6145  			return graphql.Null
  6146  		}
  6147  		return ec._World(ctx, sel, obj)
  6148  	case WorldName:
  6149  		return ec._WorldName(ctx, sel, &obj)
  6150  	case *WorldName:
  6151  		if obj == nil {
  6152  			return graphql.Null
  6153  		}
  6154  		return ec._WorldName(ctx, sel, obj)
  6155  	case WorldWithMultipleKeys:
  6156  		return ec._WorldWithMultipleKeys(ctx, sel, &obj)
  6157  	case *WorldWithMultipleKeys:
  6158  		if obj == nil {
  6159  			return graphql.Null
  6160  		}
  6161  		return ec._WorldWithMultipleKeys(ctx, sel, obj)
  6162  	default:
  6163  		panic(fmt.Errorf("unexpected type %T", obj))
  6164  	}
  6165  }
  6166  
  6167  // endregion ************************** interface.gotpl ***************************
  6168  
  6169  // region    **************************** object.gotpl ****************************
  6170  
  6171  var entityImplementors = []string{"Entity"}
  6172  
  6173  func (ec *executionContext) _Entity(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  6174  	fields := graphql.CollectFields(ec.OperationContext, sel, entityImplementors)
  6175  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  6176  		Object: "Entity",
  6177  	})
  6178  
  6179  	out := graphql.NewFieldSet(fields)
  6180  	deferred := make(map[string]*graphql.FieldSet)
  6181  	for i, field := range fields {
  6182  		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
  6183  			Object: field.Name,
  6184  			Field:  field,
  6185  		})
  6186  
  6187  		switch field.Name {
  6188  		case "__typename":
  6189  			out.Values[i] = graphql.MarshalString("Entity")
  6190  		case "findHelloByName":
  6191  			field := field
  6192  
  6193  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6194  				defer func() {
  6195  					if r := recover(); r != nil {
  6196  						ec.Error(ctx, ec.Recover(ctx, r))
  6197  					}
  6198  				}()
  6199  				res = ec._Entity_findHelloByName(ctx, field)
  6200  				if res == graphql.Null {
  6201  					atomic.AddUint32(&fs.Invalids, 1)
  6202  				}
  6203  				return res
  6204  			}
  6205  
  6206  			rrm := func(ctx context.Context) graphql.Marshaler {
  6207  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6208  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6209  			}
  6210  
  6211  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6212  		case "findHelloMultiSingleKeysByKey1AndKey2":
  6213  			field := field
  6214  
  6215  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6216  				defer func() {
  6217  					if r := recover(); r != nil {
  6218  						ec.Error(ctx, ec.Recover(ctx, r))
  6219  					}
  6220  				}()
  6221  				res = ec._Entity_findHelloMultiSingleKeysByKey1AndKey2(ctx, field)
  6222  				if res == graphql.Null {
  6223  					atomic.AddUint32(&fs.Invalids, 1)
  6224  				}
  6225  				return res
  6226  			}
  6227  
  6228  			rrm := func(ctx context.Context) graphql.Marshaler {
  6229  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6230  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6231  			}
  6232  
  6233  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6234  		case "findHelloWithErrorsByName":
  6235  			field := field
  6236  
  6237  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6238  				defer func() {
  6239  					if r := recover(); r != nil {
  6240  						ec.Error(ctx, ec.Recover(ctx, r))
  6241  					}
  6242  				}()
  6243  				res = ec._Entity_findHelloWithErrorsByName(ctx, field)
  6244  				if res == graphql.Null {
  6245  					atomic.AddUint32(&fs.Invalids, 1)
  6246  				}
  6247  				return res
  6248  			}
  6249  
  6250  			rrm := func(ctx context.Context) graphql.Marshaler {
  6251  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6252  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6253  			}
  6254  
  6255  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6256  		case "findManyMultiHelloByNames":
  6257  			field := field
  6258  
  6259  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6260  				defer func() {
  6261  					if r := recover(); r != nil {
  6262  						ec.Error(ctx, ec.Recover(ctx, r))
  6263  					}
  6264  				}()
  6265  				res = ec._Entity_findManyMultiHelloByNames(ctx, field)
  6266  				return res
  6267  			}
  6268  
  6269  			rrm := func(ctx context.Context) graphql.Marshaler {
  6270  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6271  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6272  			}
  6273  
  6274  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6275  		case "findManyMultiHelloMultipleRequiresByNames":
  6276  			field := field
  6277  
  6278  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6279  				defer func() {
  6280  					if r := recover(); r != nil {
  6281  						ec.Error(ctx, ec.Recover(ctx, r))
  6282  					}
  6283  				}()
  6284  				res = ec._Entity_findManyMultiHelloMultipleRequiresByNames(ctx, field)
  6285  				return res
  6286  			}
  6287  
  6288  			rrm := func(ctx context.Context) graphql.Marshaler {
  6289  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6290  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6291  			}
  6292  
  6293  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6294  		case "findManyMultiHelloRequiresByNames":
  6295  			field := field
  6296  
  6297  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6298  				defer func() {
  6299  					if r := recover(); r != nil {
  6300  						ec.Error(ctx, ec.Recover(ctx, r))
  6301  					}
  6302  				}()
  6303  				res = ec._Entity_findManyMultiHelloRequiresByNames(ctx, field)
  6304  				return res
  6305  			}
  6306  
  6307  			rrm := func(ctx context.Context) graphql.Marshaler {
  6308  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6309  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6310  			}
  6311  
  6312  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6313  		case "findManyMultiHelloWithErrorByNames":
  6314  			field := field
  6315  
  6316  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6317  				defer func() {
  6318  					if r := recover(); r != nil {
  6319  						ec.Error(ctx, ec.Recover(ctx, r))
  6320  					}
  6321  				}()
  6322  				res = ec._Entity_findManyMultiHelloWithErrorByNames(ctx, field)
  6323  				return res
  6324  			}
  6325  
  6326  			rrm := func(ctx context.Context) graphql.Marshaler {
  6327  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6328  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6329  			}
  6330  
  6331  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6332  		case "findManyMultiPlanetRequiresNestedByNames":
  6333  			field := field
  6334  
  6335  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6336  				defer func() {
  6337  					if r := recover(); r != nil {
  6338  						ec.Error(ctx, ec.Recover(ctx, r))
  6339  					}
  6340  				}()
  6341  				res = ec._Entity_findManyMultiPlanetRequiresNestedByNames(ctx, field)
  6342  				return res
  6343  			}
  6344  
  6345  			rrm := func(ctx context.Context) graphql.Marshaler {
  6346  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6347  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6348  			}
  6349  
  6350  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6351  		case "findPlanetMultipleRequiresByName":
  6352  			field := field
  6353  
  6354  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6355  				defer func() {
  6356  					if r := recover(); r != nil {
  6357  						ec.Error(ctx, ec.Recover(ctx, r))
  6358  					}
  6359  				}()
  6360  				res = ec._Entity_findPlanetMultipleRequiresByName(ctx, field)
  6361  				if res == graphql.Null {
  6362  					atomic.AddUint32(&fs.Invalids, 1)
  6363  				}
  6364  				return res
  6365  			}
  6366  
  6367  			rrm := func(ctx context.Context) graphql.Marshaler {
  6368  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6369  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6370  			}
  6371  
  6372  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6373  		case "findPlanetRequiresByName":
  6374  			field := field
  6375  
  6376  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6377  				defer func() {
  6378  					if r := recover(); r != nil {
  6379  						ec.Error(ctx, ec.Recover(ctx, r))
  6380  					}
  6381  				}()
  6382  				res = ec._Entity_findPlanetRequiresByName(ctx, field)
  6383  				if res == graphql.Null {
  6384  					atomic.AddUint32(&fs.Invalids, 1)
  6385  				}
  6386  				return res
  6387  			}
  6388  
  6389  			rrm := func(ctx context.Context) graphql.Marshaler {
  6390  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6391  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6392  			}
  6393  
  6394  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6395  		case "findPlanetRequiresNestedByName":
  6396  			field := field
  6397  
  6398  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6399  				defer func() {
  6400  					if r := recover(); r != nil {
  6401  						ec.Error(ctx, ec.Recover(ctx, r))
  6402  					}
  6403  				}()
  6404  				res = ec._Entity_findPlanetRequiresNestedByName(ctx, field)
  6405  				if res == graphql.Null {
  6406  					atomic.AddUint32(&fs.Invalids, 1)
  6407  				}
  6408  				return res
  6409  			}
  6410  
  6411  			rrm := func(ctx context.Context) graphql.Marshaler {
  6412  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6413  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6414  			}
  6415  
  6416  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6417  		case "findWorldByHelloNameAndFoo":
  6418  			field := field
  6419  
  6420  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6421  				defer func() {
  6422  					if r := recover(); r != nil {
  6423  						ec.Error(ctx, ec.Recover(ctx, r))
  6424  					}
  6425  				}()
  6426  				res = ec._Entity_findWorldByHelloNameAndFoo(ctx, field)
  6427  				if res == graphql.Null {
  6428  					atomic.AddUint32(&fs.Invalids, 1)
  6429  				}
  6430  				return res
  6431  			}
  6432  
  6433  			rrm := func(ctx context.Context) graphql.Marshaler {
  6434  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6435  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6436  			}
  6437  
  6438  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6439  		case "findWorldNameByName":
  6440  			field := field
  6441  
  6442  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6443  				defer func() {
  6444  					if r := recover(); r != nil {
  6445  						ec.Error(ctx, ec.Recover(ctx, r))
  6446  					}
  6447  				}()
  6448  				res = ec._Entity_findWorldNameByName(ctx, field)
  6449  				if res == graphql.Null {
  6450  					atomic.AddUint32(&fs.Invalids, 1)
  6451  				}
  6452  				return res
  6453  			}
  6454  
  6455  			rrm := func(ctx context.Context) graphql.Marshaler {
  6456  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6457  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6458  			}
  6459  
  6460  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6461  		case "findWorldWithMultipleKeysByHelloNameAndFoo":
  6462  			field := field
  6463  
  6464  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6465  				defer func() {
  6466  					if r := recover(); r != nil {
  6467  						ec.Error(ctx, ec.Recover(ctx, r))
  6468  					}
  6469  				}()
  6470  				res = ec._Entity_findWorldWithMultipleKeysByHelloNameAndFoo(ctx, field)
  6471  				if res == graphql.Null {
  6472  					atomic.AddUint32(&fs.Invalids, 1)
  6473  				}
  6474  				return res
  6475  			}
  6476  
  6477  			rrm := func(ctx context.Context) graphql.Marshaler {
  6478  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6479  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6480  			}
  6481  
  6482  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6483  		case "findWorldWithMultipleKeysByBar":
  6484  			field := field
  6485  
  6486  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  6487  				defer func() {
  6488  					if r := recover(); r != nil {
  6489  						ec.Error(ctx, ec.Recover(ctx, r))
  6490  					}
  6491  				}()
  6492  				res = ec._Entity_findWorldWithMultipleKeysByBar(ctx, field)
  6493  				if res == graphql.Null {
  6494  					atomic.AddUint32(&fs.Invalids, 1)
  6495  				}
  6496  				return res
  6497  			}
  6498  
  6499  			rrm := func(ctx context.Context) graphql.Marshaler {
  6500  				return ec.OperationContext.RootResolverMiddleware(ctx,
  6501  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  6502  			}
  6503  
  6504  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  6505  		default:
  6506  			panic("unknown field " + strconv.Quote(field.Name))
  6507  		}
  6508  	}
  6509  	out.Dispatch(ctx)
  6510  	if out.Invalids > 0 {
  6511  		return graphql.Null
  6512  	}
  6513  
  6514  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6515  
  6516  	for label, dfs := range deferred {
  6517  		ec.processDeferredGroup(graphql.DeferredGroup{
  6518  			Label:    label,
  6519  			Path:     graphql.GetPath(ctx),
  6520  			FieldSet: dfs,
  6521  			Context:  ctx,
  6522  		})
  6523  	}
  6524  
  6525  	return out
  6526  }
  6527  
  6528  var helloImplementors = []string{"Hello", "_Entity"}
  6529  
  6530  func (ec *executionContext) _Hello(ctx context.Context, sel ast.SelectionSet, obj *Hello) graphql.Marshaler {
  6531  	fields := graphql.CollectFields(ec.OperationContext, sel, helloImplementors)
  6532  
  6533  	out := graphql.NewFieldSet(fields)
  6534  	deferred := make(map[string]*graphql.FieldSet)
  6535  	for i, field := range fields {
  6536  		switch field.Name {
  6537  		case "__typename":
  6538  			out.Values[i] = graphql.MarshalString("Hello")
  6539  		case "name":
  6540  			out.Values[i] = ec._Hello_name(ctx, field, obj)
  6541  			if out.Values[i] == graphql.Null {
  6542  				out.Invalids++
  6543  			}
  6544  		case "secondary":
  6545  			out.Values[i] = ec._Hello_secondary(ctx, field, obj)
  6546  			if out.Values[i] == graphql.Null {
  6547  				out.Invalids++
  6548  			}
  6549  		default:
  6550  			panic("unknown field " + strconv.Quote(field.Name))
  6551  		}
  6552  	}
  6553  	out.Dispatch(ctx)
  6554  	if out.Invalids > 0 {
  6555  		return graphql.Null
  6556  	}
  6557  
  6558  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6559  
  6560  	for label, dfs := range deferred {
  6561  		ec.processDeferredGroup(graphql.DeferredGroup{
  6562  			Label:    label,
  6563  			Path:     graphql.GetPath(ctx),
  6564  			FieldSet: dfs,
  6565  			Context:  ctx,
  6566  		})
  6567  	}
  6568  
  6569  	return out
  6570  }
  6571  
  6572  var helloMultiSingleKeysImplementors = []string{"HelloMultiSingleKeys", "_Entity"}
  6573  
  6574  func (ec *executionContext) _HelloMultiSingleKeys(ctx context.Context, sel ast.SelectionSet, obj *HelloMultiSingleKeys) graphql.Marshaler {
  6575  	fields := graphql.CollectFields(ec.OperationContext, sel, helloMultiSingleKeysImplementors)
  6576  
  6577  	out := graphql.NewFieldSet(fields)
  6578  	deferred := make(map[string]*graphql.FieldSet)
  6579  	for i, field := range fields {
  6580  		switch field.Name {
  6581  		case "__typename":
  6582  			out.Values[i] = graphql.MarshalString("HelloMultiSingleKeys")
  6583  		case "key1":
  6584  			out.Values[i] = ec._HelloMultiSingleKeys_key1(ctx, field, obj)
  6585  			if out.Values[i] == graphql.Null {
  6586  				out.Invalids++
  6587  			}
  6588  		case "key2":
  6589  			out.Values[i] = ec._HelloMultiSingleKeys_key2(ctx, field, obj)
  6590  			if out.Values[i] == graphql.Null {
  6591  				out.Invalids++
  6592  			}
  6593  		default:
  6594  			panic("unknown field " + strconv.Quote(field.Name))
  6595  		}
  6596  	}
  6597  	out.Dispatch(ctx)
  6598  	if out.Invalids > 0 {
  6599  		return graphql.Null
  6600  	}
  6601  
  6602  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6603  
  6604  	for label, dfs := range deferred {
  6605  		ec.processDeferredGroup(graphql.DeferredGroup{
  6606  			Label:    label,
  6607  			Path:     graphql.GetPath(ctx),
  6608  			FieldSet: dfs,
  6609  			Context:  ctx,
  6610  		})
  6611  	}
  6612  
  6613  	return out
  6614  }
  6615  
  6616  var helloWithErrorsImplementors = []string{"HelloWithErrors", "_Entity"}
  6617  
  6618  func (ec *executionContext) _HelloWithErrors(ctx context.Context, sel ast.SelectionSet, obj *HelloWithErrors) graphql.Marshaler {
  6619  	fields := graphql.CollectFields(ec.OperationContext, sel, helloWithErrorsImplementors)
  6620  
  6621  	out := graphql.NewFieldSet(fields)
  6622  	deferred := make(map[string]*graphql.FieldSet)
  6623  	for i, field := range fields {
  6624  		switch field.Name {
  6625  		case "__typename":
  6626  			out.Values[i] = graphql.MarshalString("HelloWithErrors")
  6627  		case "name":
  6628  			out.Values[i] = ec._HelloWithErrors_name(ctx, field, obj)
  6629  			if out.Values[i] == graphql.Null {
  6630  				out.Invalids++
  6631  			}
  6632  		default:
  6633  			panic("unknown field " + strconv.Quote(field.Name))
  6634  		}
  6635  	}
  6636  	out.Dispatch(ctx)
  6637  	if out.Invalids > 0 {
  6638  		return graphql.Null
  6639  	}
  6640  
  6641  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6642  
  6643  	for label, dfs := range deferred {
  6644  		ec.processDeferredGroup(graphql.DeferredGroup{
  6645  			Label:    label,
  6646  			Path:     graphql.GetPath(ctx),
  6647  			FieldSet: dfs,
  6648  			Context:  ctx,
  6649  		})
  6650  	}
  6651  
  6652  	return out
  6653  }
  6654  
  6655  var multiHelloImplementors = []string{"MultiHello", "_Entity"}
  6656  
  6657  func (ec *executionContext) _MultiHello(ctx context.Context, sel ast.SelectionSet, obj *MultiHello) graphql.Marshaler {
  6658  	fields := graphql.CollectFields(ec.OperationContext, sel, multiHelloImplementors)
  6659  
  6660  	out := graphql.NewFieldSet(fields)
  6661  	deferred := make(map[string]*graphql.FieldSet)
  6662  	for i, field := range fields {
  6663  		switch field.Name {
  6664  		case "__typename":
  6665  			out.Values[i] = graphql.MarshalString("MultiHello")
  6666  		case "name":
  6667  			out.Values[i] = ec._MultiHello_name(ctx, field, obj)
  6668  			if out.Values[i] == graphql.Null {
  6669  				out.Invalids++
  6670  			}
  6671  		default:
  6672  			panic("unknown field " + strconv.Quote(field.Name))
  6673  		}
  6674  	}
  6675  	out.Dispatch(ctx)
  6676  	if out.Invalids > 0 {
  6677  		return graphql.Null
  6678  	}
  6679  
  6680  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6681  
  6682  	for label, dfs := range deferred {
  6683  		ec.processDeferredGroup(graphql.DeferredGroup{
  6684  			Label:    label,
  6685  			Path:     graphql.GetPath(ctx),
  6686  			FieldSet: dfs,
  6687  			Context:  ctx,
  6688  		})
  6689  	}
  6690  
  6691  	return out
  6692  }
  6693  
  6694  var multiHelloMultipleRequiresImplementors = []string{"MultiHelloMultipleRequires", "_Entity"}
  6695  
  6696  func (ec *executionContext) _MultiHelloMultipleRequires(ctx context.Context, sel ast.SelectionSet, obj *MultiHelloMultipleRequires) graphql.Marshaler {
  6697  	fields := graphql.CollectFields(ec.OperationContext, sel, multiHelloMultipleRequiresImplementors)
  6698  
  6699  	out := graphql.NewFieldSet(fields)
  6700  	deferred := make(map[string]*graphql.FieldSet)
  6701  	for i, field := range fields {
  6702  		switch field.Name {
  6703  		case "__typename":
  6704  			out.Values[i] = graphql.MarshalString("MultiHelloMultipleRequires")
  6705  		case "name":
  6706  			out.Values[i] = ec._MultiHelloMultipleRequires_name(ctx, field, obj)
  6707  			if out.Values[i] == graphql.Null {
  6708  				out.Invalids++
  6709  			}
  6710  		case "key1":
  6711  			out.Values[i] = ec._MultiHelloMultipleRequires_key1(ctx, field, obj)
  6712  			if out.Values[i] == graphql.Null {
  6713  				out.Invalids++
  6714  			}
  6715  		case "key2":
  6716  			out.Values[i] = ec._MultiHelloMultipleRequires_key2(ctx, field, obj)
  6717  			if out.Values[i] == graphql.Null {
  6718  				out.Invalids++
  6719  			}
  6720  		case "key3":
  6721  			out.Values[i] = ec._MultiHelloMultipleRequires_key3(ctx, field, obj)
  6722  			if out.Values[i] == graphql.Null {
  6723  				out.Invalids++
  6724  			}
  6725  		default:
  6726  			panic("unknown field " + strconv.Quote(field.Name))
  6727  		}
  6728  	}
  6729  	out.Dispatch(ctx)
  6730  	if out.Invalids > 0 {
  6731  		return graphql.Null
  6732  	}
  6733  
  6734  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6735  
  6736  	for label, dfs := range deferred {
  6737  		ec.processDeferredGroup(graphql.DeferredGroup{
  6738  			Label:    label,
  6739  			Path:     graphql.GetPath(ctx),
  6740  			FieldSet: dfs,
  6741  			Context:  ctx,
  6742  		})
  6743  	}
  6744  
  6745  	return out
  6746  }
  6747  
  6748  var multiHelloRequiresImplementors = []string{"MultiHelloRequires", "_Entity"}
  6749  
  6750  func (ec *executionContext) _MultiHelloRequires(ctx context.Context, sel ast.SelectionSet, obj *MultiHelloRequires) graphql.Marshaler {
  6751  	fields := graphql.CollectFields(ec.OperationContext, sel, multiHelloRequiresImplementors)
  6752  
  6753  	out := graphql.NewFieldSet(fields)
  6754  	deferred := make(map[string]*graphql.FieldSet)
  6755  	for i, field := range fields {
  6756  		switch field.Name {
  6757  		case "__typename":
  6758  			out.Values[i] = graphql.MarshalString("MultiHelloRequires")
  6759  		case "name":
  6760  			out.Values[i] = ec._MultiHelloRequires_name(ctx, field, obj)
  6761  			if out.Values[i] == graphql.Null {
  6762  				out.Invalids++
  6763  			}
  6764  		case "key1":
  6765  			out.Values[i] = ec._MultiHelloRequires_key1(ctx, field, obj)
  6766  			if out.Values[i] == graphql.Null {
  6767  				out.Invalids++
  6768  			}
  6769  		case "key2":
  6770  			out.Values[i] = ec._MultiHelloRequires_key2(ctx, field, obj)
  6771  			if out.Values[i] == graphql.Null {
  6772  				out.Invalids++
  6773  			}
  6774  		default:
  6775  			panic("unknown field " + strconv.Quote(field.Name))
  6776  		}
  6777  	}
  6778  	out.Dispatch(ctx)
  6779  	if out.Invalids > 0 {
  6780  		return graphql.Null
  6781  	}
  6782  
  6783  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6784  
  6785  	for label, dfs := range deferred {
  6786  		ec.processDeferredGroup(graphql.DeferredGroup{
  6787  			Label:    label,
  6788  			Path:     graphql.GetPath(ctx),
  6789  			FieldSet: dfs,
  6790  			Context:  ctx,
  6791  		})
  6792  	}
  6793  
  6794  	return out
  6795  }
  6796  
  6797  var multiHelloWithErrorImplementors = []string{"MultiHelloWithError", "_Entity"}
  6798  
  6799  func (ec *executionContext) _MultiHelloWithError(ctx context.Context, sel ast.SelectionSet, obj *MultiHelloWithError) graphql.Marshaler {
  6800  	fields := graphql.CollectFields(ec.OperationContext, sel, multiHelloWithErrorImplementors)
  6801  
  6802  	out := graphql.NewFieldSet(fields)
  6803  	deferred := make(map[string]*graphql.FieldSet)
  6804  	for i, field := range fields {
  6805  		switch field.Name {
  6806  		case "__typename":
  6807  			out.Values[i] = graphql.MarshalString("MultiHelloWithError")
  6808  		case "name":
  6809  			out.Values[i] = ec._MultiHelloWithError_name(ctx, field, obj)
  6810  			if out.Values[i] == graphql.Null {
  6811  				out.Invalids++
  6812  			}
  6813  		default:
  6814  			panic("unknown field " + strconv.Quote(field.Name))
  6815  		}
  6816  	}
  6817  	out.Dispatch(ctx)
  6818  	if out.Invalids > 0 {
  6819  		return graphql.Null
  6820  	}
  6821  
  6822  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6823  
  6824  	for label, dfs := range deferred {
  6825  		ec.processDeferredGroup(graphql.DeferredGroup{
  6826  			Label:    label,
  6827  			Path:     graphql.GetPath(ctx),
  6828  			FieldSet: dfs,
  6829  			Context:  ctx,
  6830  		})
  6831  	}
  6832  
  6833  	return out
  6834  }
  6835  
  6836  var multiPlanetRequiresNestedImplementors = []string{"MultiPlanetRequiresNested", "_Entity"}
  6837  
  6838  func (ec *executionContext) _MultiPlanetRequiresNested(ctx context.Context, sel ast.SelectionSet, obj *MultiPlanetRequiresNested) graphql.Marshaler {
  6839  	fields := graphql.CollectFields(ec.OperationContext, sel, multiPlanetRequiresNestedImplementors)
  6840  
  6841  	out := graphql.NewFieldSet(fields)
  6842  	deferred := make(map[string]*graphql.FieldSet)
  6843  	for i, field := range fields {
  6844  		switch field.Name {
  6845  		case "__typename":
  6846  			out.Values[i] = graphql.MarshalString("MultiPlanetRequiresNested")
  6847  		case "name":
  6848  			out.Values[i] = ec._MultiPlanetRequiresNested_name(ctx, field, obj)
  6849  			if out.Values[i] == graphql.Null {
  6850  				out.Invalids++
  6851  			}
  6852  		case "world":
  6853  			out.Values[i] = ec._MultiPlanetRequiresNested_world(ctx, field, obj)
  6854  			if out.Values[i] == graphql.Null {
  6855  				out.Invalids++
  6856  			}
  6857  		case "size":
  6858  			out.Values[i] = ec._MultiPlanetRequiresNested_size(ctx, field, obj)
  6859  			if out.Values[i] == graphql.Null {
  6860  				out.Invalids++
  6861  			}
  6862  		default:
  6863  			panic("unknown field " + strconv.Quote(field.Name))
  6864  		}
  6865  	}
  6866  	out.Dispatch(ctx)
  6867  	if out.Invalids > 0 {
  6868  		return graphql.Null
  6869  	}
  6870  
  6871  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6872  
  6873  	for label, dfs := range deferred {
  6874  		ec.processDeferredGroup(graphql.DeferredGroup{
  6875  			Label:    label,
  6876  			Path:     graphql.GetPath(ctx),
  6877  			FieldSet: dfs,
  6878  			Context:  ctx,
  6879  		})
  6880  	}
  6881  
  6882  	return out
  6883  }
  6884  
  6885  var planetMultipleRequiresImplementors = []string{"PlanetMultipleRequires", "_Entity"}
  6886  
  6887  func (ec *executionContext) _PlanetMultipleRequires(ctx context.Context, sel ast.SelectionSet, obj *PlanetMultipleRequires) graphql.Marshaler {
  6888  	fields := graphql.CollectFields(ec.OperationContext, sel, planetMultipleRequiresImplementors)
  6889  
  6890  	out := graphql.NewFieldSet(fields)
  6891  	deferred := make(map[string]*graphql.FieldSet)
  6892  	for i, field := range fields {
  6893  		switch field.Name {
  6894  		case "__typename":
  6895  			out.Values[i] = graphql.MarshalString("PlanetMultipleRequires")
  6896  		case "name":
  6897  			out.Values[i] = ec._PlanetMultipleRequires_name(ctx, field, obj)
  6898  			if out.Values[i] == graphql.Null {
  6899  				out.Invalids++
  6900  			}
  6901  		case "diameter":
  6902  			out.Values[i] = ec._PlanetMultipleRequires_diameter(ctx, field, obj)
  6903  			if out.Values[i] == graphql.Null {
  6904  				out.Invalids++
  6905  			}
  6906  		case "density":
  6907  			out.Values[i] = ec._PlanetMultipleRequires_density(ctx, field, obj)
  6908  			if out.Values[i] == graphql.Null {
  6909  				out.Invalids++
  6910  			}
  6911  		case "weight":
  6912  			out.Values[i] = ec._PlanetMultipleRequires_weight(ctx, field, obj)
  6913  			if out.Values[i] == graphql.Null {
  6914  				out.Invalids++
  6915  			}
  6916  		default:
  6917  			panic("unknown field " + strconv.Quote(field.Name))
  6918  		}
  6919  	}
  6920  	out.Dispatch(ctx)
  6921  	if out.Invalids > 0 {
  6922  		return graphql.Null
  6923  	}
  6924  
  6925  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6926  
  6927  	for label, dfs := range deferred {
  6928  		ec.processDeferredGroup(graphql.DeferredGroup{
  6929  			Label:    label,
  6930  			Path:     graphql.GetPath(ctx),
  6931  			FieldSet: dfs,
  6932  			Context:  ctx,
  6933  		})
  6934  	}
  6935  
  6936  	return out
  6937  }
  6938  
  6939  var planetRequiresImplementors = []string{"PlanetRequires", "_Entity"}
  6940  
  6941  func (ec *executionContext) _PlanetRequires(ctx context.Context, sel ast.SelectionSet, obj *PlanetRequires) graphql.Marshaler {
  6942  	fields := graphql.CollectFields(ec.OperationContext, sel, planetRequiresImplementors)
  6943  
  6944  	out := graphql.NewFieldSet(fields)
  6945  	deferred := make(map[string]*graphql.FieldSet)
  6946  	for i, field := range fields {
  6947  		switch field.Name {
  6948  		case "__typename":
  6949  			out.Values[i] = graphql.MarshalString("PlanetRequires")
  6950  		case "name":
  6951  			out.Values[i] = ec._PlanetRequires_name(ctx, field, obj)
  6952  			if out.Values[i] == graphql.Null {
  6953  				out.Invalids++
  6954  			}
  6955  		case "size":
  6956  			out.Values[i] = ec._PlanetRequires_size(ctx, field, obj)
  6957  			if out.Values[i] == graphql.Null {
  6958  				out.Invalids++
  6959  			}
  6960  		case "diameter":
  6961  			out.Values[i] = ec._PlanetRequires_diameter(ctx, field, obj)
  6962  			if out.Values[i] == graphql.Null {
  6963  				out.Invalids++
  6964  			}
  6965  		default:
  6966  			panic("unknown field " + strconv.Quote(field.Name))
  6967  		}
  6968  	}
  6969  	out.Dispatch(ctx)
  6970  	if out.Invalids > 0 {
  6971  		return graphql.Null
  6972  	}
  6973  
  6974  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  6975  
  6976  	for label, dfs := range deferred {
  6977  		ec.processDeferredGroup(graphql.DeferredGroup{
  6978  			Label:    label,
  6979  			Path:     graphql.GetPath(ctx),
  6980  			FieldSet: dfs,
  6981  			Context:  ctx,
  6982  		})
  6983  	}
  6984  
  6985  	return out
  6986  }
  6987  
  6988  var planetRequiresNestedImplementors = []string{"PlanetRequiresNested", "_Entity"}
  6989  
  6990  func (ec *executionContext) _PlanetRequiresNested(ctx context.Context, sel ast.SelectionSet, obj *PlanetRequiresNested) graphql.Marshaler {
  6991  	fields := graphql.CollectFields(ec.OperationContext, sel, planetRequiresNestedImplementors)
  6992  
  6993  	out := graphql.NewFieldSet(fields)
  6994  	deferred := make(map[string]*graphql.FieldSet)
  6995  	for i, field := range fields {
  6996  		switch field.Name {
  6997  		case "__typename":
  6998  			out.Values[i] = graphql.MarshalString("PlanetRequiresNested")
  6999  		case "name":
  7000  			out.Values[i] = ec._PlanetRequiresNested_name(ctx, field, obj)
  7001  			if out.Values[i] == graphql.Null {
  7002  				out.Invalids++
  7003  			}
  7004  		case "world":
  7005  			out.Values[i] = ec._PlanetRequiresNested_world(ctx, field, obj)
  7006  			if out.Values[i] == graphql.Null {
  7007  				out.Invalids++
  7008  			}
  7009  		case "worlds":
  7010  			out.Values[i] = ec._PlanetRequiresNested_worlds(ctx, field, obj)
  7011  		case "size":
  7012  			out.Values[i] = ec._PlanetRequiresNested_size(ctx, field, obj)
  7013  			if out.Values[i] == graphql.Null {
  7014  				out.Invalids++
  7015  			}
  7016  		case "sizes":
  7017  			out.Values[i] = ec._PlanetRequiresNested_sizes(ctx, field, obj)
  7018  		default:
  7019  			panic("unknown field " + strconv.Quote(field.Name))
  7020  		}
  7021  	}
  7022  	out.Dispatch(ctx)
  7023  	if out.Invalids > 0 {
  7024  		return graphql.Null
  7025  	}
  7026  
  7027  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7028  
  7029  	for label, dfs := range deferred {
  7030  		ec.processDeferredGroup(graphql.DeferredGroup{
  7031  			Label:    label,
  7032  			Path:     graphql.GetPath(ctx),
  7033  			FieldSet: dfs,
  7034  			Context:  ctx,
  7035  		})
  7036  	}
  7037  
  7038  	return out
  7039  }
  7040  
  7041  var queryImplementors = []string{"Query"}
  7042  
  7043  func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  7044  	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
  7045  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  7046  		Object: "Query",
  7047  	})
  7048  
  7049  	out := graphql.NewFieldSet(fields)
  7050  	deferred := make(map[string]*graphql.FieldSet)
  7051  	for i, field := range fields {
  7052  		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
  7053  			Object: field.Name,
  7054  			Field:  field,
  7055  		})
  7056  
  7057  		switch field.Name {
  7058  		case "__typename":
  7059  			out.Values[i] = graphql.MarshalString("Query")
  7060  		case "_entities":
  7061  			field := field
  7062  
  7063  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  7064  				defer func() {
  7065  					if r := recover(); r != nil {
  7066  						ec.Error(ctx, ec.Recover(ctx, r))
  7067  					}
  7068  				}()
  7069  				res = ec._Query__entities(ctx, field)
  7070  				if res == graphql.Null {
  7071  					atomic.AddUint32(&fs.Invalids, 1)
  7072  				}
  7073  				return res
  7074  			}
  7075  
  7076  			rrm := func(ctx context.Context) graphql.Marshaler {
  7077  				return ec.OperationContext.RootResolverMiddleware(ctx,
  7078  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  7079  			}
  7080  
  7081  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  7082  		case "_service":
  7083  			field := field
  7084  
  7085  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  7086  				defer func() {
  7087  					if r := recover(); r != nil {
  7088  						ec.Error(ctx, ec.Recover(ctx, r))
  7089  					}
  7090  				}()
  7091  				res = ec._Query__service(ctx, field)
  7092  				if res == graphql.Null {
  7093  					atomic.AddUint32(&fs.Invalids, 1)
  7094  				}
  7095  				return res
  7096  			}
  7097  
  7098  			rrm := func(ctx context.Context) graphql.Marshaler {
  7099  				return ec.OperationContext.RootResolverMiddleware(ctx,
  7100  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  7101  			}
  7102  
  7103  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  7104  		case "__type":
  7105  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  7106  				return ec._Query___type(ctx, field)
  7107  			})
  7108  		case "__schema":
  7109  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  7110  				return ec._Query___schema(ctx, field)
  7111  			})
  7112  		default:
  7113  			panic("unknown field " + strconv.Quote(field.Name))
  7114  		}
  7115  	}
  7116  	out.Dispatch(ctx)
  7117  	if out.Invalids > 0 {
  7118  		return graphql.Null
  7119  	}
  7120  
  7121  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7122  
  7123  	for label, dfs := range deferred {
  7124  		ec.processDeferredGroup(graphql.DeferredGroup{
  7125  			Label:    label,
  7126  			Path:     graphql.GetPath(ctx),
  7127  			FieldSet: dfs,
  7128  			Context:  ctx,
  7129  		})
  7130  	}
  7131  
  7132  	return out
  7133  }
  7134  
  7135  var worldImplementors = []string{"World", "_Entity"}
  7136  
  7137  func (ec *executionContext) _World(ctx context.Context, sel ast.SelectionSet, obj *World) graphql.Marshaler {
  7138  	fields := graphql.CollectFields(ec.OperationContext, sel, worldImplementors)
  7139  
  7140  	out := graphql.NewFieldSet(fields)
  7141  	deferred := make(map[string]*graphql.FieldSet)
  7142  	for i, field := range fields {
  7143  		switch field.Name {
  7144  		case "__typename":
  7145  			out.Values[i] = graphql.MarshalString("World")
  7146  		case "foo":
  7147  			out.Values[i] = ec._World_foo(ctx, field, obj)
  7148  			if out.Values[i] == graphql.Null {
  7149  				out.Invalids++
  7150  			}
  7151  		case "bar":
  7152  			out.Values[i] = ec._World_bar(ctx, field, obj)
  7153  			if out.Values[i] == graphql.Null {
  7154  				out.Invalids++
  7155  			}
  7156  		case "hello":
  7157  			out.Values[i] = ec._World_hello(ctx, field, obj)
  7158  		default:
  7159  			panic("unknown field " + strconv.Quote(field.Name))
  7160  		}
  7161  	}
  7162  	out.Dispatch(ctx)
  7163  	if out.Invalids > 0 {
  7164  		return graphql.Null
  7165  	}
  7166  
  7167  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7168  
  7169  	for label, dfs := range deferred {
  7170  		ec.processDeferredGroup(graphql.DeferredGroup{
  7171  			Label:    label,
  7172  			Path:     graphql.GetPath(ctx),
  7173  			FieldSet: dfs,
  7174  			Context:  ctx,
  7175  		})
  7176  	}
  7177  
  7178  	return out
  7179  }
  7180  
  7181  var worldNameImplementors = []string{"WorldName", "_Entity"}
  7182  
  7183  func (ec *executionContext) _WorldName(ctx context.Context, sel ast.SelectionSet, obj *WorldName) graphql.Marshaler {
  7184  	fields := graphql.CollectFields(ec.OperationContext, sel, worldNameImplementors)
  7185  
  7186  	out := graphql.NewFieldSet(fields)
  7187  	deferred := make(map[string]*graphql.FieldSet)
  7188  	for i, field := range fields {
  7189  		switch field.Name {
  7190  		case "__typename":
  7191  			out.Values[i] = graphql.MarshalString("WorldName")
  7192  		case "name":
  7193  			out.Values[i] = ec._WorldName_name(ctx, field, obj)
  7194  			if out.Values[i] == graphql.Null {
  7195  				out.Invalids++
  7196  			}
  7197  		default:
  7198  			panic("unknown field " + strconv.Quote(field.Name))
  7199  		}
  7200  	}
  7201  	out.Dispatch(ctx)
  7202  	if out.Invalids > 0 {
  7203  		return graphql.Null
  7204  	}
  7205  
  7206  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7207  
  7208  	for label, dfs := range deferred {
  7209  		ec.processDeferredGroup(graphql.DeferredGroup{
  7210  			Label:    label,
  7211  			Path:     graphql.GetPath(ctx),
  7212  			FieldSet: dfs,
  7213  			Context:  ctx,
  7214  		})
  7215  	}
  7216  
  7217  	return out
  7218  }
  7219  
  7220  var worldWithMultipleKeysImplementors = []string{"WorldWithMultipleKeys", "_Entity"}
  7221  
  7222  func (ec *executionContext) _WorldWithMultipleKeys(ctx context.Context, sel ast.SelectionSet, obj *WorldWithMultipleKeys) graphql.Marshaler {
  7223  	fields := graphql.CollectFields(ec.OperationContext, sel, worldWithMultipleKeysImplementors)
  7224  
  7225  	out := graphql.NewFieldSet(fields)
  7226  	deferred := make(map[string]*graphql.FieldSet)
  7227  	for i, field := range fields {
  7228  		switch field.Name {
  7229  		case "__typename":
  7230  			out.Values[i] = graphql.MarshalString("WorldWithMultipleKeys")
  7231  		case "foo":
  7232  			out.Values[i] = ec._WorldWithMultipleKeys_foo(ctx, field, obj)
  7233  			if out.Values[i] == graphql.Null {
  7234  				out.Invalids++
  7235  			}
  7236  		case "bar":
  7237  			out.Values[i] = ec._WorldWithMultipleKeys_bar(ctx, field, obj)
  7238  			if out.Values[i] == graphql.Null {
  7239  				out.Invalids++
  7240  			}
  7241  		case "hello":
  7242  			out.Values[i] = ec._WorldWithMultipleKeys_hello(ctx, field, obj)
  7243  		default:
  7244  			panic("unknown field " + strconv.Quote(field.Name))
  7245  		}
  7246  	}
  7247  	out.Dispatch(ctx)
  7248  	if out.Invalids > 0 {
  7249  		return graphql.Null
  7250  	}
  7251  
  7252  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7253  
  7254  	for label, dfs := range deferred {
  7255  		ec.processDeferredGroup(graphql.DeferredGroup{
  7256  			Label:    label,
  7257  			Path:     graphql.GetPath(ctx),
  7258  			FieldSet: dfs,
  7259  			Context:  ctx,
  7260  		})
  7261  	}
  7262  
  7263  	return out
  7264  }
  7265  
  7266  var _ServiceImplementors = []string{"_Service"}
  7267  
  7268  func (ec *executionContext) __Service(ctx context.Context, sel ast.SelectionSet, obj *fedruntime.Service) graphql.Marshaler {
  7269  	fields := graphql.CollectFields(ec.OperationContext, sel, _ServiceImplementors)
  7270  
  7271  	out := graphql.NewFieldSet(fields)
  7272  	deferred := make(map[string]*graphql.FieldSet)
  7273  	for i, field := range fields {
  7274  		switch field.Name {
  7275  		case "__typename":
  7276  			out.Values[i] = graphql.MarshalString("_Service")
  7277  		case "sdl":
  7278  			out.Values[i] = ec.__Service_sdl(ctx, field, obj)
  7279  		default:
  7280  			panic("unknown field " + strconv.Quote(field.Name))
  7281  		}
  7282  	}
  7283  	out.Dispatch(ctx)
  7284  	if out.Invalids > 0 {
  7285  		return graphql.Null
  7286  	}
  7287  
  7288  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7289  
  7290  	for label, dfs := range deferred {
  7291  		ec.processDeferredGroup(graphql.DeferredGroup{
  7292  			Label:    label,
  7293  			Path:     graphql.GetPath(ctx),
  7294  			FieldSet: dfs,
  7295  			Context:  ctx,
  7296  		})
  7297  	}
  7298  
  7299  	return out
  7300  }
  7301  
  7302  var __DirectiveImplementors = []string{"__Directive"}
  7303  
  7304  func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
  7305  	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
  7306  
  7307  	out := graphql.NewFieldSet(fields)
  7308  	deferred := make(map[string]*graphql.FieldSet)
  7309  	for i, field := range fields {
  7310  		switch field.Name {
  7311  		case "__typename":
  7312  			out.Values[i] = graphql.MarshalString("__Directive")
  7313  		case "name":
  7314  			out.Values[i] = ec.___Directive_name(ctx, field, obj)
  7315  			if out.Values[i] == graphql.Null {
  7316  				out.Invalids++
  7317  			}
  7318  		case "description":
  7319  			out.Values[i] = ec.___Directive_description(ctx, field, obj)
  7320  		case "locations":
  7321  			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
  7322  			if out.Values[i] == graphql.Null {
  7323  				out.Invalids++
  7324  			}
  7325  		case "args":
  7326  			out.Values[i] = ec.___Directive_args(ctx, field, obj)
  7327  			if out.Values[i] == graphql.Null {
  7328  				out.Invalids++
  7329  			}
  7330  		case "isRepeatable":
  7331  			out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
  7332  			if out.Values[i] == graphql.Null {
  7333  				out.Invalids++
  7334  			}
  7335  		default:
  7336  			panic("unknown field " + strconv.Quote(field.Name))
  7337  		}
  7338  	}
  7339  	out.Dispatch(ctx)
  7340  	if out.Invalids > 0 {
  7341  		return graphql.Null
  7342  	}
  7343  
  7344  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7345  
  7346  	for label, dfs := range deferred {
  7347  		ec.processDeferredGroup(graphql.DeferredGroup{
  7348  			Label:    label,
  7349  			Path:     graphql.GetPath(ctx),
  7350  			FieldSet: dfs,
  7351  			Context:  ctx,
  7352  		})
  7353  	}
  7354  
  7355  	return out
  7356  }
  7357  
  7358  var __EnumValueImplementors = []string{"__EnumValue"}
  7359  
  7360  func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
  7361  	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
  7362  
  7363  	out := graphql.NewFieldSet(fields)
  7364  	deferred := make(map[string]*graphql.FieldSet)
  7365  	for i, field := range fields {
  7366  		switch field.Name {
  7367  		case "__typename":
  7368  			out.Values[i] = graphql.MarshalString("__EnumValue")
  7369  		case "name":
  7370  			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
  7371  			if out.Values[i] == graphql.Null {
  7372  				out.Invalids++
  7373  			}
  7374  		case "description":
  7375  			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
  7376  		case "isDeprecated":
  7377  			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
  7378  			if out.Values[i] == graphql.Null {
  7379  				out.Invalids++
  7380  			}
  7381  		case "deprecationReason":
  7382  			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
  7383  		default:
  7384  			panic("unknown field " + strconv.Quote(field.Name))
  7385  		}
  7386  	}
  7387  	out.Dispatch(ctx)
  7388  	if out.Invalids > 0 {
  7389  		return graphql.Null
  7390  	}
  7391  
  7392  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7393  
  7394  	for label, dfs := range deferred {
  7395  		ec.processDeferredGroup(graphql.DeferredGroup{
  7396  			Label:    label,
  7397  			Path:     graphql.GetPath(ctx),
  7398  			FieldSet: dfs,
  7399  			Context:  ctx,
  7400  		})
  7401  	}
  7402  
  7403  	return out
  7404  }
  7405  
  7406  var __FieldImplementors = []string{"__Field"}
  7407  
  7408  func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
  7409  	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
  7410  
  7411  	out := graphql.NewFieldSet(fields)
  7412  	deferred := make(map[string]*graphql.FieldSet)
  7413  	for i, field := range fields {
  7414  		switch field.Name {
  7415  		case "__typename":
  7416  			out.Values[i] = graphql.MarshalString("__Field")
  7417  		case "name":
  7418  			out.Values[i] = ec.___Field_name(ctx, field, obj)
  7419  			if out.Values[i] == graphql.Null {
  7420  				out.Invalids++
  7421  			}
  7422  		case "description":
  7423  			out.Values[i] = ec.___Field_description(ctx, field, obj)
  7424  		case "args":
  7425  			out.Values[i] = ec.___Field_args(ctx, field, obj)
  7426  			if out.Values[i] == graphql.Null {
  7427  				out.Invalids++
  7428  			}
  7429  		case "type":
  7430  			out.Values[i] = ec.___Field_type(ctx, field, obj)
  7431  			if out.Values[i] == graphql.Null {
  7432  				out.Invalids++
  7433  			}
  7434  		case "isDeprecated":
  7435  			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
  7436  			if out.Values[i] == graphql.Null {
  7437  				out.Invalids++
  7438  			}
  7439  		case "deprecationReason":
  7440  			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
  7441  		default:
  7442  			panic("unknown field " + strconv.Quote(field.Name))
  7443  		}
  7444  	}
  7445  	out.Dispatch(ctx)
  7446  	if out.Invalids > 0 {
  7447  		return graphql.Null
  7448  	}
  7449  
  7450  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7451  
  7452  	for label, dfs := range deferred {
  7453  		ec.processDeferredGroup(graphql.DeferredGroup{
  7454  			Label:    label,
  7455  			Path:     graphql.GetPath(ctx),
  7456  			FieldSet: dfs,
  7457  			Context:  ctx,
  7458  		})
  7459  	}
  7460  
  7461  	return out
  7462  }
  7463  
  7464  var __InputValueImplementors = []string{"__InputValue"}
  7465  
  7466  func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
  7467  	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
  7468  
  7469  	out := graphql.NewFieldSet(fields)
  7470  	deferred := make(map[string]*graphql.FieldSet)
  7471  	for i, field := range fields {
  7472  		switch field.Name {
  7473  		case "__typename":
  7474  			out.Values[i] = graphql.MarshalString("__InputValue")
  7475  		case "name":
  7476  			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
  7477  			if out.Values[i] == graphql.Null {
  7478  				out.Invalids++
  7479  			}
  7480  		case "description":
  7481  			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
  7482  		case "type":
  7483  			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
  7484  			if out.Values[i] == graphql.Null {
  7485  				out.Invalids++
  7486  			}
  7487  		case "defaultValue":
  7488  			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
  7489  		default:
  7490  			panic("unknown field " + strconv.Quote(field.Name))
  7491  		}
  7492  	}
  7493  	out.Dispatch(ctx)
  7494  	if out.Invalids > 0 {
  7495  		return graphql.Null
  7496  	}
  7497  
  7498  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7499  
  7500  	for label, dfs := range deferred {
  7501  		ec.processDeferredGroup(graphql.DeferredGroup{
  7502  			Label:    label,
  7503  			Path:     graphql.GetPath(ctx),
  7504  			FieldSet: dfs,
  7505  			Context:  ctx,
  7506  		})
  7507  	}
  7508  
  7509  	return out
  7510  }
  7511  
  7512  var __SchemaImplementors = []string{"__Schema"}
  7513  
  7514  func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
  7515  	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
  7516  
  7517  	out := graphql.NewFieldSet(fields)
  7518  	deferred := make(map[string]*graphql.FieldSet)
  7519  	for i, field := range fields {
  7520  		switch field.Name {
  7521  		case "__typename":
  7522  			out.Values[i] = graphql.MarshalString("__Schema")
  7523  		case "description":
  7524  			out.Values[i] = ec.___Schema_description(ctx, field, obj)
  7525  		case "types":
  7526  			out.Values[i] = ec.___Schema_types(ctx, field, obj)
  7527  			if out.Values[i] == graphql.Null {
  7528  				out.Invalids++
  7529  			}
  7530  		case "queryType":
  7531  			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
  7532  			if out.Values[i] == graphql.Null {
  7533  				out.Invalids++
  7534  			}
  7535  		case "mutationType":
  7536  			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
  7537  		case "subscriptionType":
  7538  			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
  7539  		case "directives":
  7540  			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
  7541  			if out.Values[i] == graphql.Null {
  7542  				out.Invalids++
  7543  			}
  7544  		default:
  7545  			panic("unknown field " + strconv.Quote(field.Name))
  7546  		}
  7547  	}
  7548  	out.Dispatch(ctx)
  7549  	if out.Invalids > 0 {
  7550  		return graphql.Null
  7551  	}
  7552  
  7553  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7554  
  7555  	for label, dfs := range deferred {
  7556  		ec.processDeferredGroup(graphql.DeferredGroup{
  7557  			Label:    label,
  7558  			Path:     graphql.GetPath(ctx),
  7559  			FieldSet: dfs,
  7560  			Context:  ctx,
  7561  		})
  7562  	}
  7563  
  7564  	return out
  7565  }
  7566  
  7567  var __TypeImplementors = []string{"__Type"}
  7568  
  7569  func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
  7570  	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
  7571  
  7572  	out := graphql.NewFieldSet(fields)
  7573  	deferred := make(map[string]*graphql.FieldSet)
  7574  	for i, field := range fields {
  7575  		switch field.Name {
  7576  		case "__typename":
  7577  			out.Values[i] = graphql.MarshalString("__Type")
  7578  		case "kind":
  7579  			out.Values[i] = ec.___Type_kind(ctx, field, obj)
  7580  			if out.Values[i] == graphql.Null {
  7581  				out.Invalids++
  7582  			}
  7583  		case "name":
  7584  			out.Values[i] = ec.___Type_name(ctx, field, obj)
  7585  		case "description":
  7586  			out.Values[i] = ec.___Type_description(ctx, field, obj)
  7587  		case "fields":
  7588  			out.Values[i] = ec.___Type_fields(ctx, field, obj)
  7589  		case "interfaces":
  7590  			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
  7591  		case "possibleTypes":
  7592  			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
  7593  		case "enumValues":
  7594  			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
  7595  		case "inputFields":
  7596  			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
  7597  		case "ofType":
  7598  			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
  7599  		case "specifiedByURL":
  7600  			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
  7601  		default:
  7602  			panic("unknown field " + strconv.Quote(field.Name))
  7603  		}
  7604  	}
  7605  	out.Dispatch(ctx)
  7606  	if out.Invalids > 0 {
  7607  		return graphql.Null
  7608  	}
  7609  
  7610  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  7611  
  7612  	for label, dfs := range deferred {
  7613  		ec.processDeferredGroup(graphql.DeferredGroup{
  7614  			Label:    label,
  7615  			Path:     graphql.GetPath(ctx),
  7616  			FieldSet: dfs,
  7617  			Context:  ctx,
  7618  		})
  7619  	}
  7620  
  7621  	return out
  7622  }
  7623  
  7624  // endregion **************************** object.gotpl ****************************
  7625  
  7626  // region    ***************************** type.gotpl *****************************
  7627  
  7628  func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
  7629  	res, err := graphql.UnmarshalBoolean(v)
  7630  	return res, graphql.ErrorOnPath(ctx, err)
  7631  }
  7632  
  7633  func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
  7634  	res := graphql.MarshalBoolean(v)
  7635  	if res == graphql.Null {
  7636  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7637  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7638  		}
  7639  	}
  7640  	return res
  7641  }
  7642  
  7643  func (ec *executionContext) marshalNHello2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHello(ctx context.Context, sel ast.SelectionSet, v Hello) graphql.Marshaler {
  7644  	return ec._Hello(ctx, sel, &v)
  7645  }
  7646  
  7647  func (ec *executionContext) marshalNHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHello(ctx context.Context, sel ast.SelectionSet, v *Hello) graphql.Marshaler {
  7648  	if v == nil {
  7649  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7650  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7651  		}
  7652  		return graphql.Null
  7653  	}
  7654  	return ec._Hello(ctx, sel, v)
  7655  }
  7656  
  7657  func (ec *executionContext) marshalNHelloMultiSingleKeys2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHelloMultiSingleKeys(ctx context.Context, sel ast.SelectionSet, v HelloMultiSingleKeys) graphql.Marshaler {
  7658  	return ec._HelloMultiSingleKeys(ctx, sel, &v)
  7659  }
  7660  
  7661  func (ec *executionContext) marshalNHelloMultiSingleKeys2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHelloMultiSingleKeys(ctx context.Context, sel ast.SelectionSet, v *HelloMultiSingleKeys) graphql.Marshaler {
  7662  	if v == nil {
  7663  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7664  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7665  		}
  7666  		return graphql.Null
  7667  	}
  7668  	return ec._HelloMultiSingleKeys(ctx, sel, v)
  7669  }
  7670  
  7671  func (ec *executionContext) marshalNHelloWithErrors2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHelloWithErrors(ctx context.Context, sel ast.SelectionSet, v HelloWithErrors) graphql.Marshaler {
  7672  	return ec._HelloWithErrors(ctx, sel, &v)
  7673  }
  7674  
  7675  func (ec *executionContext) marshalNHelloWithErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHelloWithErrors(ctx context.Context, sel ast.SelectionSet, v *HelloWithErrors) graphql.Marshaler {
  7676  	if v == nil {
  7677  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7678  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7679  		}
  7680  		return graphql.Null
  7681  	}
  7682  	return ec._HelloWithErrors(ctx, sel, v)
  7683  }
  7684  
  7685  func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
  7686  	res, err := graphql.UnmarshalInt(v)
  7687  	return res, graphql.ErrorOnPath(ctx, err)
  7688  }
  7689  
  7690  func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
  7691  	res := graphql.MarshalInt(v)
  7692  	if res == graphql.Null {
  7693  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7694  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7695  		}
  7696  	}
  7697  	return res
  7698  }
  7699  
  7700  func (ec *executionContext) unmarshalNMultiHelloByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloByNamesInput(ctx context.Context, v interface{}) ([]*MultiHelloByNamesInput, error) {
  7701  	var vSlice []interface{}
  7702  	if v != nil {
  7703  		vSlice = graphql.CoerceList(v)
  7704  	}
  7705  	var err error
  7706  	res := make([]*MultiHelloByNamesInput, len(vSlice))
  7707  	for i := range vSlice {
  7708  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7709  		res[i], err = ec.unmarshalOMultiHelloByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloByNamesInput(ctx, vSlice[i])
  7710  		if err != nil {
  7711  			return nil, err
  7712  		}
  7713  	}
  7714  	return res, nil
  7715  }
  7716  
  7717  func (ec *executionContext) unmarshalNMultiHelloMultipleRequiresByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequiresByNamesInput(ctx context.Context, v interface{}) ([]*MultiHelloMultipleRequiresByNamesInput, error) {
  7718  	var vSlice []interface{}
  7719  	if v != nil {
  7720  		vSlice = graphql.CoerceList(v)
  7721  	}
  7722  	var err error
  7723  	res := make([]*MultiHelloMultipleRequiresByNamesInput, len(vSlice))
  7724  	for i := range vSlice {
  7725  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7726  		res[i], err = ec.unmarshalOMultiHelloMultipleRequiresByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequiresByNamesInput(ctx, vSlice[i])
  7727  		if err != nil {
  7728  			return nil, err
  7729  		}
  7730  	}
  7731  	return res, nil
  7732  }
  7733  
  7734  func (ec *executionContext) unmarshalNMultiHelloRequiresByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequiresByNamesInput(ctx context.Context, v interface{}) ([]*MultiHelloRequiresByNamesInput, error) {
  7735  	var vSlice []interface{}
  7736  	if v != nil {
  7737  		vSlice = graphql.CoerceList(v)
  7738  	}
  7739  	var err error
  7740  	res := make([]*MultiHelloRequiresByNamesInput, len(vSlice))
  7741  	for i := range vSlice {
  7742  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7743  		res[i], err = ec.unmarshalOMultiHelloRequiresByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequiresByNamesInput(ctx, vSlice[i])
  7744  		if err != nil {
  7745  			return nil, err
  7746  		}
  7747  	}
  7748  	return res, nil
  7749  }
  7750  
  7751  func (ec *executionContext) unmarshalNMultiHelloWithErrorByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithErrorByNamesInput(ctx context.Context, v interface{}) ([]*MultiHelloWithErrorByNamesInput, error) {
  7752  	var vSlice []interface{}
  7753  	if v != nil {
  7754  		vSlice = graphql.CoerceList(v)
  7755  	}
  7756  	var err error
  7757  	res := make([]*MultiHelloWithErrorByNamesInput, len(vSlice))
  7758  	for i := range vSlice {
  7759  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7760  		res[i], err = ec.unmarshalOMultiHelloWithErrorByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithErrorByNamesInput(ctx, vSlice[i])
  7761  		if err != nil {
  7762  			return nil, err
  7763  		}
  7764  	}
  7765  	return res, nil
  7766  }
  7767  
  7768  func (ec *executionContext) unmarshalNMultiPlanetRequiresNestedByNamesInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNestedByNamesInput(ctx context.Context, v interface{}) ([]*MultiPlanetRequiresNestedByNamesInput, error) {
  7769  	var vSlice []interface{}
  7770  	if v != nil {
  7771  		vSlice = graphql.CoerceList(v)
  7772  	}
  7773  	var err error
  7774  	res := make([]*MultiPlanetRequiresNestedByNamesInput, len(vSlice))
  7775  	for i := range vSlice {
  7776  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7777  		res[i], err = ec.unmarshalOMultiPlanetRequiresNestedByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNestedByNamesInput(ctx, vSlice[i])
  7778  		if err != nil {
  7779  			return nil, err
  7780  		}
  7781  	}
  7782  	return res, nil
  7783  }
  7784  
  7785  func (ec *executionContext) marshalNPlanetMultipleRequires2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetMultipleRequires(ctx context.Context, sel ast.SelectionSet, v PlanetMultipleRequires) graphql.Marshaler {
  7786  	return ec._PlanetMultipleRequires(ctx, sel, &v)
  7787  }
  7788  
  7789  func (ec *executionContext) marshalNPlanetMultipleRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetMultipleRequires(ctx context.Context, sel ast.SelectionSet, v *PlanetMultipleRequires) graphql.Marshaler {
  7790  	if v == nil {
  7791  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7792  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7793  		}
  7794  		return graphql.Null
  7795  	}
  7796  	return ec._PlanetMultipleRequires(ctx, sel, v)
  7797  }
  7798  
  7799  func (ec *executionContext) marshalNPlanetRequires2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetRequires(ctx context.Context, sel ast.SelectionSet, v PlanetRequires) graphql.Marshaler {
  7800  	return ec._PlanetRequires(ctx, sel, &v)
  7801  }
  7802  
  7803  func (ec *executionContext) marshalNPlanetRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetRequires(ctx context.Context, sel ast.SelectionSet, v *PlanetRequires) graphql.Marshaler {
  7804  	if v == nil {
  7805  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7806  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7807  		}
  7808  		return graphql.Null
  7809  	}
  7810  	return ec._PlanetRequires(ctx, sel, v)
  7811  }
  7812  
  7813  func (ec *executionContext) marshalNPlanetRequiresNested2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetRequiresNested(ctx context.Context, sel ast.SelectionSet, v PlanetRequiresNested) graphql.Marshaler {
  7814  	return ec._PlanetRequiresNested(ctx, sel, &v)
  7815  }
  7816  
  7817  func (ec *executionContext) marshalNPlanetRequiresNested2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐPlanetRequiresNested(ctx context.Context, sel ast.SelectionSet, v *PlanetRequiresNested) graphql.Marshaler {
  7818  	if v == nil {
  7819  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7820  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7821  		}
  7822  		return graphql.Null
  7823  	}
  7824  	return ec._PlanetRequiresNested(ctx, sel, v)
  7825  }
  7826  
  7827  func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
  7828  	res, err := graphql.UnmarshalString(v)
  7829  	return res, graphql.ErrorOnPath(ctx, err)
  7830  }
  7831  
  7832  func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  7833  	res := graphql.MarshalString(v)
  7834  	if res == graphql.Null {
  7835  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7836  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7837  		}
  7838  	}
  7839  	return res
  7840  }
  7841  
  7842  func (ec *executionContext) marshalNWorld2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorld(ctx context.Context, sel ast.SelectionSet, v World) graphql.Marshaler {
  7843  	return ec._World(ctx, sel, &v)
  7844  }
  7845  
  7846  func (ec *executionContext) marshalNWorld2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorld(ctx context.Context, sel ast.SelectionSet, v *World) graphql.Marshaler {
  7847  	if v == nil {
  7848  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7849  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7850  		}
  7851  		return graphql.Null
  7852  	}
  7853  	return ec._World(ctx, sel, v)
  7854  }
  7855  
  7856  func (ec *executionContext) marshalNWorldName2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldName(ctx context.Context, sel ast.SelectionSet, v WorldName) graphql.Marshaler {
  7857  	return ec._WorldName(ctx, sel, &v)
  7858  }
  7859  
  7860  func (ec *executionContext) marshalNWorldName2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldName(ctx context.Context, sel ast.SelectionSet, v *WorldName) graphql.Marshaler {
  7861  	if v == nil {
  7862  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7863  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7864  		}
  7865  		return graphql.Null
  7866  	}
  7867  	return ec._WorldName(ctx, sel, v)
  7868  }
  7869  
  7870  func (ec *executionContext) marshalNWorldWithMultipleKeys2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldWithMultipleKeys(ctx context.Context, sel ast.SelectionSet, v WorldWithMultipleKeys) graphql.Marshaler {
  7871  	return ec._WorldWithMultipleKeys(ctx, sel, &v)
  7872  }
  7873  
  7874  func (ec *executionContext) marshalNWorldWithMultipleKeys2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldWithMultipleKeys(ctx context.Context, sel ast.SelectionSet, v *WorldWithMultipleKeys) graphql.Marshaler {
  7875  	if v == nil {
  7876  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7877  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7878  		}
  7879  		return graphql.Null
  7880  	}
  7881  	return ec._WorldWithMultipleKeys(ctx, sel, v)
  7882  }
  7883  
  7884  func (ec *executionContext) unmarshalN_Any2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
  7885  	res, err := graphql.UnmarshalMap(v)
  7886  	return res, graphql.ErrorOnPath(ctx, err)
  7887  }
  7888  
  7889  func (ec *executionContext) marshalN_Any2map(ctx context.Context, sel ast.SelectionSet, v map[string]interface{}) graphql.Marshaler {
  7890  	if v == nil {
  7891  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7892  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7893  		}
  7894  		return graphql.Null
  7895  	}
  7896  	res := graphql.MarshalMap(v)
  7897  	if res == graphql.Null {
  7898  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7899  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7900  		}
  7901  	}
  7902  	return res
  7903  }
  7904  
  7905  func (ec *executionContext) unmarshalN_Any2ᚕmapᚄ(ctx context.Context, v interface{}) ([]map[string]interface{}, error) {
  7906  	var vSlice []interface{}
  7907  	if v != nil {
  7908  		vSlice = graphql.CoerceList(v)
  7909  	}
  7910  	var err error
  7911  	res := make([]map[string]interface{}, len(vSlice))
  7912  	for i := range vSlice {
  7913  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7914  		res[i], err = ec.unmarshalN_Any2map(ctx, vSlice[i])
  7915  		if err != nil {
  7916  			return nil, err
  7917  		}
  7918  	}
  7919  	return res, nil
  7920  }
  7921  
  7922  func (ec *executionContext) marshalN_Any2ᚕmapᚄ(ctx context.Context, sel ast.SelectionSet, v []map[string]interface{}) graphql.Marshaler {
  7923  	ret := make(graphql.Array, len(v))
  7924  	for i := range v {
  7925  		ret[i] = ec.marshalN_Any2map(ctx, sel, v[i])
  7926  	}
  7927  
  7928  	for _, e := range ret {
  7929  		if e == graphql.Null {
  7930  			return graphql.Null
  7931  		}
  7932  	}
  7933  
  7934  	return ret
  7935  }
  7936  
  7937  func (ec *executionContext) marshalN_Entity2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐEntity(ctx context.Context, sel ast.SelectionSet, v []fedruntime.Entity) graphql.Marshaler {
  7938  	ret := make(graphql.Array, len(v))
  7939  	var wg sync.WaitGroup
  7940  	isLen1 := len(v) == 1
  7941  	if !isLen1 {
  7942  		wg.Add(len(v))
  7943  	}
  7944  	for i := range v {
  7945  		i := i
  7946  		fc := &graphql.FieldContext{
  7947  			Index:  &i,
  7948  			Result: &v[i],
  7949  		}
  7950  		ctx := graphql.WithFieldContext(ctx, fc)
  7951  		f := func(i int) {
  7952  			defer func() {
  7953  				if r := recover(); r != nil {
  7954  					ec.Error(ctx, ec.Recover(ctx, r))
  7955  					ret = nil
  7956  				}
  7957  			}()
  7958  			if !isLen1 {
  7959  				defer wg.Done()
  7960  			}
  7961  			ret[i] = ec.marshalO_Entity2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐEntity(ctx, sel, v[i])
  7962  		}
  7963  		if isLen1 {
  7964  			f(i)
  7965  		} else {
  7966  			go f(i)
  7967  		}
  7968  
  7969  	}
  7970  	wg.Wait()
  7971  
  7972  	return ret
  7973  }
  7974  
  7975  func (ec *executionContext) unmarshalN_FieldSet2string(ctx context.Context, v interface{}) (string, error) {
  7976  	res, err := graphql.UnmarshalString(v)
  7977  	return res, graphql.ErrorOnPath(ctx, err)
  7978  }
  7979  
  7980  func (ec *executionContext) marshalN_FieldSet2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  7981  	res := graphql.MarshalString(v)
  7982  	if res == graphql.Null {
  7983  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7984  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7985  		}
  7986  	}
  7987  	return res
  7988  }
  7989  
  7990  func (ec *executionContext) marshalN_Service2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐService(ctx context.Context, sel ast.SelectionSet, v fedruntime.Service) graphql.Marshaler {
  7991  	return ec.__Service(ctx, sel, &v)
  7992  }
  7993  
  7994  func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
  7995  	return ec.___Directive(ctx, sel, &v)
  7996  }
  7997  
  7998  func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
  7999  	ret := make(graphql.Array, len(v))
  8000  	var wg sync.WaitGroup
  8001  	isLen1 := len(v) == 1
  8002  	if !isLen1 {
  8003  		wg.Add(len(v))
  8004  	}
  8005  	for i := range v {
  8006  		i := i
  8007  		fc := &graphql.FieldContext{
  8008  			Index:  &i,
  8009  			Result: &v[i],
  8010  		}
  8011  		ctx := graphql.WithFieldContext(ctx, fc)
  8012  		f := func(i int) {
  8013  			defer func() {
  8014  				if r := recover(); r != nil {
  8015  					ec.Error(ctx, ec.Recover(ctx, r))
  8016  					ret = nil
  8017  				}
  8018  			}()
  8019  			if !isLen1 {
  8020  				defer wg.Done()
  8021  			}
  8022  			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
  8023  		}
  8024  		if isLen1 {
  8025  			f(i)
  8026  		} else {
  8027  			go f(i)
  8028  		}
  8029  
  8030  	}
  8031  	wg.Wait()
  8032  
  8033  	for _, e := range ret {
  8034  		if e == graphql.Null {
  8035  			return graphql.Null
  8036  		}
  8037  	}
  8038  
  8039  	return ret
  8040  }
  8041  
  8042  func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
  8043  	res, err := graphql.UnmarshalString(v)
  8044  	return res, graphql.ErrorOnPath(ctx, err)
  8045  }
  8046  
  8047  func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  8048  	res := graphql.MarshalString(v)
  8049  	if res == graphql.Null {
  8050  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  8051  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  8052  		}
  8053  	}
  8054  	return res
  8055  }
  8056  
  8057  func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
  8058  	var vSlice []interface{}
  8059  	if v != nil {
  8060  		vSlice = graphql.CoerceList(v)
  8061  	}
  8062  	var err error
  8063  	res := make([]string, len(vSlice))
  8064  	for i := range vSlice {
  8065  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  8066  		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
  8067  		if err != nil {
  8068  			return nil, err
  8069  		}
  8070  	}
  8071  	return res, nil
  8072  }
  8073  
  8074  func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
  8075  	ret := make(graphql.Array, len(v))
  8076  	var wg sync.WaitGroup
  8077  	isLen1 := len(v) == 1
  8078  	if !isLen1 {
  8079  		wg.Add(len(v))
  8080  	}
  8081  	for i := range v {
  8082  		i := i
  8083  		fc := &graphql.FieldContext{
  8084  			Index:  &i,
  8085  			Result: &v[i],
  8086  		}
  8087  		ctx := graphql.WithFieldContext(ctx, fc)
  8088  		f := func(i int) {
  8089  			defer func() {
  8090  				if r := recover(); r != nil {
  8091  					ec.Error(ctx, ec.Recover(ctx, r))
  8092  					ret = nil
  8093  				}
  8094  			}()
  8095  			if !isLen1 {
  8096  				defer wg.Done()
  8097  			}
  8098  			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
  8099  		}
  8100  		if isLen1 {
  8101  			f(i)
  8102  		} else {
  8103  			go f(i)
  8104  		}
  8105  
  8106  	}
  8107  	wg.Wait()
  8108  
  8109  	for _, e := range ret {
  8110  		if e == graphql.Null {
  8111  			return graphql.Null
  8112  		}
  8113  	}
  8114  
  8115  	return ret
  8116  }
  8117  
  8118  func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
  8119  	return ec.___EnumValue(ctx, sel, &v)
  8120  }
  8121  
  8122  func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
  8123  	return ec.___Field(ctx, sel, &v)
  8124  }
  8125  
  8126  func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
  8127  	return ec.___InputValue(ctx, sel, &v)
  8128  }
  8129  
  8130  func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
  8131  	ret := make(graphql.Array, len(v))
  8132  	var wg sync.WaitGroup
  8133  	isLen1 := len(v) == 1
  8134  	if !isLen1 {
  8135  		wg.Add(len(v))
  8136  	}
  8137  	for i := range v {
  8138  		i := i
  8139  		fc := &graphql.FieldContext{
  8140  			Index:  &i,
  8141  			Result: &v[i],
  8142  		}
  8143  		ctx := graphql.WithFieldContext(ctx, fc)
  8144  		f := func(i int) {
  8145  			defer func() {
  8146  				if r := recover(); r != nil {
  8147  					ec.Error(ctx, ec.Recover(ctx, r))
  8148  					ret = nil
  8149  				}
  8150  			}()
  8151  			if !isLen1 {
  8152  				defer wg.Done()
  8153  			}
  8154  			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
  8155  		}
  8156  		if isLen1 {
  8157  			f(i)
  8158  		} else {
  8159  			go f(i)
  8160  		}
  8161  
  8162  	}
  8163  	wg.Wait()
  8164  
  8165  	for _, e := range ret {
  8166  		if e == graphql.Null {
  8167  			return graphql.Null
  8168  		}
  8169  	}
  8170  
  8171  	return ret
  8172  }
  8173  
  8174  func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
  8175  	return ec.___Type(ctx, sel, &v)
  8176  }
  8177  
  8178  func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
  8179  	ret := make(graphql.Array, len(v))
  8180  	var wg sync.WaitGroup
  8181  	isLen1 := len(v) == 1
  8182  	if !isLen1 {
  8183  		wg.Add(len(v))
  8184  	}
  8185  	for i := range v {
  8186  		i := i
  8187  		fc := &graphql.FieldContext{
  8188  			Index:  &i,
  8189  			Result: &v[i],
  8190  		}
  8191  		ctx := graphql.WithFieldContext(ctx, fc)
  8192  		f := func(i int) {
  8193  			defer func() {
  8194  				if r := recover(); r != nil {
  8195  					ec.Error(ctx, ec.Recover(ctx, r))
  8196  					ret = nil
  8197  				}
  8198  			}()
  8199  			if !isLen1 {
  8200  				defer wg.Done()
  8201  			}
  8202  			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
  8203  		}
  8204  		if isLen1 {
  8205  			f(i)
  8206  		} else {
  8207  			go f(i)
  8208  		}
  8209  
  8210  	}
  8211  	wg.Wait()
  8212  
  8213  	for _, e := range ret {
  8214  		if e == graphql.Null {
  8215  			return graphql.Null
  8216  		}
  8217  	}
  8218  
  8219  	return ret
  8220  }
  8221  
  8222  func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
  8223  	if v == nil {
  8224  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  8225  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  8226  		}
  8227  		return graphql.Null
  8228  	}
  8229  	return ec.___Type(ctx, sel, v)
  8230  }
  8231  
  8232  func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
  8233  	res, err := graphql.UnmarshalString(v)
  8234  	return res, graphql.ErrorOnPath(ctx, err)
  8235  }
  8236  
  8237  func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  8238  	res := graphql.MarshalString(v)
  8239  	if res == graphql.Null {
  8240  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  8241  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  8242  		}
  8243  	}
  8244  	return res
  8245  }
  8246  
  8247  func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
  8248  	res, err := graphql.UnmarshalBoolean(v)
  8249  	return res, graphql.ErrorOnPath(ctx, err)
  8250  }
  8251  
  8252  func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
  8253  	res := graphql.MarshalBoolean(v)
  8254  	return res
  8255  }
  8256  
  8257  func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
  8258  	if v == nil {
  8259  		return nil, nil
  8260  	}
  8261  	res, err := graphql.UnmarshalBoolean(v)
  8262  	return &res, graphql.ErrorOnPath(ctx, err)
  8263  }
  8264  
  8265  func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
  8266  	if v == nil {
  8267  		return graphql.Null
  8268  	}
  8269  	res := graphql.MarshalBoolean(*v)
  8270  	return res
  8271  }
  8272  
  8273  func (ec *executionContext) marshalOHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐHello(ctx context.Context, sel ast.SelectionSet, v *Hello) graphql.Marshaler {
  8274  	if v == nil {
  8275  		return graphql.Null
  8276  	}
  8277  	return ec._Hello(ctx, sel, v)
  8278  }
  8279  
  8280  func (ec *executionContext) unmarshalOInt2ᚕintᚄ(ctx context.Context, v interface{}) ([]int, error) {
  8281  	if v == nil {
  8282  		return nil, nil
  8283  	}
  8284  	var vSlice []interface{}
  8285  	if v != nil {
  8286  		vSlice = graphql.CoerceList(v)
  8287  	}
  8288  	var err error
  8289  	res := make([]int, len(vSlice))
  8290  	for i := range vSlice {
  8291  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  8292  		res[i], err = ec.unmarshalNInt2int(ctx, vSlice[i])
  8293  		if err != nil {
  8294  			return nil, err
  8295  		}
  8296  	}
  8297  	return res, nil
  8298  }
  8299  
  8300  func (ec *executionContext) marshalOInt2ᚕintᚄ(ctx context.Context, sel ast.SelectionSet, v []int) graphql.Marshaler {
  8301  	if v == nil {
  8302  		return graphql.Null
  8303  	}
  8304  	ret := make(graphql.Array, len(v))
  8305  	for i := range v {
  8306  		ret[i] = ec.marshalNInt2int(ctx, sel, v[i])
  8307  	}
  8308  
  8309  	for _, e := range ret {
  8310  		if e == graphql.Null {
  8311  			return graphql.Null
  8312  		}
  8313  	}
  8314  
  8315  	return ret
  8316  }
  8317  
  8318  func (ec *executionContext) marshalOMultiHello2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHello(ctx context.Context, sel ast.SelectionSet, v []*MultiHello) graphql.Marshaler {
  8319  	if v == nil {
  8320  		return graphql.Null
  8321  	}
  8322  	ret := make(graphql.Array, len(v))
  8323  	var wg sync.WaitGroup
  8324  	isLen1 := len(v) == 1
  8325  	if !isLen1 {
  8326  		wg.Add(len(v))
  8327  	}
  8328  	for i := range v {
  8329  		i := i
  8330  		fc := &graphql.FieldContext{
  8331  			Index:  &i,
  8332  			Result: &v[i],
  8333  		}
  8334  		ctx := graphql.WithFieldContext(ctx, fc)
  8335  		f := func(i int) {
  8336  			defer func() {
  8337  				if r := recover(); r != nil {
  8338  					ec.Error(ctx, ec.Recover(ctx, r))
  8339  					ret = nil
  8340  				}
  8341  			}()
  8342  			if !isLen1 {
  8343  				defer wg.Done()
  8344  			}
  8345  			ret[i] = ec.marshalOMultiHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHello(ctx, sel, v[i])
  8346  		}
  8347  		if isLen1 {
  8348  			f(i)
  8349  		} else {
  8350  			go f(i)
  8351  		}
  8352  
  8353  	}
  8354  	wg.Wait()
  8355  
  8356  	return ret
  8357  }
  8358  
  8359  func (ec *executionContext) marshalOMultiHello2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHello(ctx context.Context, sel ast.SelectionSet, v *MultiHello) graphql.Marshaler {
  8360  	if v == nil {
  8361  		return graphql.Null
  8362  	}
  8363  	return ec._MultiHello(ctx, sel, v)
  8364  }
  8365  
  8366  func (ec *executionContext) unmarshalOMultiHelloByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloByNamesInput(ctx context.Context, v interface{}) (*MultiHelloByNamesInput, error) {
  8367  	if v == nil {
  8368  		return nil, nil
  8369  	}
  8370  	res, err := ec.unmarshalInputMultiHelloByNamesInput(ctx, v)
  8371  	return &res, graphql.ErrorOnPath(ctx, err)
  8372  }
  8373  
  8374  func (ec *executionContext) marshalOMultiHelloMultipleRequires2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequires(ctx context.Context, sel ast.SelectionSet, v []*MultiHelloMultipleRequires) graphql.Marshaler {
  8375  	if v == nil {
  8376  		return graphql.Null
  8377  	}
  8378  	ret := make(graphql.Array, len(v))
  8379  	var wg sync.WaitGroup
  8380  	isLen1 := len(v) == 1
  8381  	if !isLen1 {
  8382  		wg.Add(len(v))
  8383  	}
  8384  	for i := range v {
  8385  		i := i
  8386  		fc := &graphql.FieldContext{
  8387  			Index:  &i,
  8388  			Result: &v[i],
  8389  		}
  8390  		ctx := graphql.WithFieldContext(ctx, fc)
  8391  		f := func(i int) {
  8392  			defer func() {
  8393  				if r := recover(); r != nil {
  8394  					ec.Error(ctx, ec.Recover(ctx, r))
  8395  					ret = nil
  8396  				}
  8397  			}()
  8398  			if !isLen1 {
  8399  				defer wg.Done()
  8400  			}
  8401  			ret[i] = ec.marshalOMultiHelloMultipleRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequires(ctx, sel, v[i])
  8402  		}
  8403  		if isLen1 {
  8404  			f(i)
  8405  		} else {
  8406  			go f(i)
  8407  		}
  8408  
  8409  	}
  8410  	wg.Wait()
  8411  
  8412  	return ret
  8413  }
  8414  
  8415  func (ec *executionContext) marshalOMultiHelloMultipleRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequires(ctx context.Context, sel ast.SelectionSet, v *MultiHelloMultipleRequires) graphql.Marshaler {
  8416  	if v == nil {
  8417  		return graphql.Null
  8418  	}
  8419  	return ec._MultiHelloMultipleRequires(ctx, sel, v)
  8420  }
  8421  
  8422  func (ec *executionContext) unmarshalOMultiHelloMultipleRequiresByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloMultipleRequiresByNamesInput(ctx context.Context, v interface{}) (*MultiHelloMultipleRequiresByNamesInput, error) {
  8423  	if v == nil {
  8424  		return nil, nil
  8425  	}
  8426  	res, err := ec.unmarshalInputMultiHelloMultipleRequiresByNamesInput(ctx, v)
  8427  	return &res, graphql.ErrorOnPath(ctx, err)
  8428  }
  8429  
  8430  func (ec *executionContext) marshalOMultiHelloRequires2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequires(ctx context.Context, sel ast.SelectionSet, v []*MultiHelloRequires) graphql.Marshaler {
  8431  	if v == nil {
  8432  		return graphql.Null
  8433  	}
  8434  	ret := make(graphql.Array, len(v))
  8435  	var wg sync.WaitGroup
  8436  	isLen1 := len(v) == 1
  8437  	if !isLen1 {
  8438  		wg.Add(len(v))
  8439  	}
  8440  	for i := range v {
  8441  		i := i
  8442  		fc := &graphql.FieldContext{
  8443  			Index:  &i,
  8444  			Result: &v[i],
  8445  		}
  8446  		ctx := graphql.WithFieldContext(ctx, fc)
  8447  		f := func(i int) {
  8448  			defer func() {
  8449  				if r := recover(); r != nil {
  8450  					ec.Error(ctx, ec.Recover(ctx, r))
  8451  					ret = nil
  8452  				}
  8453  			}()
  8454  			if !isLen1 {
  8455  				defer wg.Done()
  8456  			}
  8457  			ret[i] = ec.marshalOMultiHelloRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequires(ctx, sel, v[i])
  8458  		}
  8459  		if isLen1 {
  8460  			f(i)
  8461  		} else {
  8462  			go f(i)
  8463  		}
  8464  
  8465  	}
  8466  	wg.Wait()
  8467  
  8468  	return ret
  8469  }
  8470  
  8471  func (ec *executionContext) marshalOMultiHelloRequires2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequires(ctx context.Context, sel ast.SelectionSet, v *MultiHelloRequires) graphql.Marshaler {
  8472  	if v == nil {
  8473  		return graphql.Null
  8474  	}
  8475  	return ec._MultiHelloRequires(ctx, sel, v)
  8476  }
  8477  
  8478  func (ec *executionContext) unmarshalOMultiHelloRequiresByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloRequiresByNamesInput(ctx context.Context, v interface{}) (*MultiHelloRequiresByNamesInput, error) {
  8479  	if v == nil {
  8480  		return nil, nil
  8481  	}
  8482  	res, err := ec.unmarshalInputMultiHelloRequiresByNamesInput(ctx, v)
  8483  	return &res, graphql.ErrorOnPath(ctx, err)
  8484  }
  8485  
  8486  func (ec *executionContext) marshalOMultiHelloWithError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithError(ctx context.Context, sel ast.SelectionSet, v []*MultiHelloWithError) graphql.Marshaler {
  8487  	if v == nil {
  8488  		return graphql.Null
  8489  	}
  8490  	ret := make(graphql.Array, len(v))
  8491  	var wg sync.WaitGroup
  8492  	isLen1 := len(v) == 1
  8493  	if !isLen1 {
  8494  		wg.Add(len(v))
  8495  	}
  8496  	for i := range v {
  8497  		i := i
  8498  		fc := &graphql.FieldContext{
  8499  			Index:  &i,
  8500  			Result: &v[i],
  8501  		}
  8502  		ctx := graphql.WithFieldContext(ctx, fc)
  8503  		f := func(i int) {
  8504  			defer func() {
  8505  				if r := recover(); r != nil {
  8506  					ec.Error(ctx, ec.Recover(ctx, r))
  8507  					ret = nil
  8508  				}
  8509  			}()
  8510  			if !isLen1 {
  8511  				defer wg.Done()
  8512  			}
  8513  			ret[i] = ec.marshalOMultiHelloWithError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithError(ctx, sel, v[i])
  8514  		}
  8515  		if isLen1 {
  8516  			f(i)
  8517  		} else {
  8518  			go f(i)
  8519  		}
  8520  
  8521  	}
  8522  	wg.Wait()
  8523  
  8524  	return ret
  8525  }
  8526  
  8527  func (ec *executionContext) marshalOMultiHelloWithError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithError(ctx context.Context, sel ast.SelectionSet, v *MultiHelloWithError) graphql.Marshaler {
  8528  	if v == nil {
  8529  		return graphql.Null
  8530  	}
  8531  	return ec._MultiHelloWithError(ctx, sel, v)
  8532  }
  8533  
  8534  func (ec *executionContext) unmarshalOMultiHelloWithErrorByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiHelloWithErrorByNamesInput(ctx context.Context, v interface{}) (*MultiHelloWithErrorByNamesInput, error) {
  8535  	if v == nil {
  8536  		return nil, nil
  8537  	}
  8538  	res, err := ec.unmarshalInputMultiHelloWithErrorByNamesInput(ctx, v)
  8539  	return &res, graphql.ErrorOnPath(ctx, err)
  8540  }
  8541  
  8542  func (ec *executionContext) marshalOMultiPlanetRequiresNested2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNested(ctx context.Context, sel ast.SelectionSet, v []*MultiPlanetRequiresNested) graphql.Marshaler {
  8543  	if v == nil {
  8544  		return graphql.Null
  8545  	}
  8546  	ret := make(graphql.Array, len(v))
  8547  	var wg sync.WaitGroup
  8548  	isLen1 := len(v) == 1
  8549  	if !isLen1 {
  8550  		wg.Add(len(v))
  8551  	}
  8552  	for i := range v {
  8553  		i := i
  8554  		fc := &graphql.FieldContext{
  8555  			Index:  &i,
  8556  			Result: &v[i],
  8557  		}
  8558  		ctx := graphql.WithFieldContext(ctx, fc)
  8559  		f := func(i int) {
  8560  			defer func() {
  8561  				if r := recover(); r != nil {
  8562  					ec.Error(ctx, ec.Recover(ctx, r))
  8563  					ret = nil
  8564  				}
  8565  			}()
  8566  			if !isLen1 {
  8567  				defer wg.Done()
  8568  			}
  8569  			ret[i] = ec.marshalOMultiPlanetRequiresNested2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNested(ctx, sel, v[i])
  8570  		}
  8571  		if isLen1 {
  8572  			f(i)
  8573  		} else {
  8574  			go f(i)
  8575  		}
  8576  
  8577  	}
  8578  	wg.Wait()
  8579  
  8580  	return ret
  8581  }
  8582  
  8583  func (ec *executionContext) marshalOMultiPlanetRequiresNested2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNested(ctx context.Context, sel ast.SelectionSet, v *MultiPlanetRequiresNested) graphql.Marshaler {
  8584  	if v == nil {
  8585  		return graphql.Null
  8586  	}
  8587  	return ec._MultiPlanetRequiresNested(ctx, sel, v)
  8588  }
  8589  
  8590  func (ec *executionContext) unmarshalOMultiPlanetRequiresNestedByNamesInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐMultiPlanetRequiresNestedByNamesInput(ctx context.Context, v interface{}) (*MultiPlanetRequiresNestedByNamesInput, error) {
  8591  	if v == nil {
  8592  		return nil, nil
  8593  	}
  8594  	res, err := ec.unmarshalInputMultiPlanetRequiresNestedByNamesInput(ctx, v)
  8595  	return &res, graphql.ErrorOnPath(ctx, err)
  8596  }
  8597  
  8598  func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
  8599  	res, err := graphql.UnmarshalString(v)
  8600  	return res, graphql.ErrorOnPath(ctx, err)
  8601  }
  8602  
  8603  func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  8604  	res := graphql.MarshalString(v)
  8605  	return res
  8606  }
  8607  
  8608  func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
  8609  	if v == nil {
  8610  		return nil, nil
  8611  	}
  8612  	res, err := graphql.UnmarshalString(v)
  8613  	return &res, graphql.ErrorOnPath(ctx, err)
  8614  }
  8615  
  8616  func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
  8617  	if v == nil {
  8618  		return graphql.Null
  8619  	}
  8620  	res := graphql.MarshalString(*v)
  8621  	return res
  8622  }
  8623  
  8624  func (ec *executionContext) marshalOWorld2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorldᚄ(ctx context.Context, sel ast.SelectionSet, v []*World) graphql.Marshaler {
  8625  	if v == nil {
  8626  		return graphql.Null
  8627  	}
  8628  	ret := make(graphql.Array, len(v))
  8629  	var wg sync.WaitGroup
  8630  	isLen1 := len(v) == 1
  8631  	if !isLen1 {
  8632  		wg.Add(len(v))
  8633  	}
  8634  	for i := range v {
  8635  		i := i
  8636  		fc := &graphql.FieldContext{
  8637  			Index:  &i,
  8638  			Result: &v[i],
  8639  		}
  8640  		ctx := graphql.WithFieldContext(ctx, fc)
  8641  		f := func(i int) {
  8642  			defer func() {
  8643  				if r := recover(); r != nil {
  8644  					ec.Error(ctx, ec.Recover(ctx, r))
  8645  					ret = nil
  8646  				}
  8647  			}()
  8648  			if !isLen1 {
  8649  				defer wg.Done()
  8650  			}
  8651  			ret[i] = ec.marshalNWorld2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋtestdataᚋexplicitrequiresᚋgeneratedᚐWorld(ctx, sel, v[i])
  8652  		}
  8653  		if isLen1 {
  8654  			f(i)
  8655  		} else {
  8656  			go f(i)
  8657  		}
  8658  
  8659  	}
  8660  	wg.Wait()
  8661  
  8662  	for _, e := range ret {
  8663  		if e == graphql.Null {
  8664  			return graphql.Null
  8665  		}
  8666  	}
  8667  
  8668  	return ret
  8669  }
  8670  
  8671  func (ec *executionContext) marshalO_Entity2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐEntity(ctx context.Context, sel ast.SelectionSet, v fedruntime.Entity) graphql.Marshaler {
  8672  	if v == nil {
  8673  		return graphql.Null
  8674  	}
  8675  	return ec.__Entity(ctx, sel, v)
  8676  }
  8677  
  8678  func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
  8679  	if v == nil {
  8680  		return graphql.Null
  8681  	}
  8682  	ret := make(graphql.Array, len(v))
  8683  	var wg sync.WaitGroup
  8684  	isLen1 := len(v) == 1
  8685  	if !isLen1 {
  8686  		wg.Add(len(v))
  8687  	}
  8688  	for i := range v {
  8689  		i := i
  8690  		fc := &graphql.FieldContext{
  8691  			Index:  &i,
  8692  			Result: &v[i],
  8693  		}
  8694  		ctx := graphql.WithFieldContext(ctx, fc)
  8695  		f := func(i int) {
  8696  			defer func() {
  8697  				if r := recover(); r != nil {
  8698  					ec.Error(ctx, ec.Recover(ctx, r))
  8699  					ret = nil
  8700  				}
  8701  			}()
  8702  			if !isLen1 {
  8703  				defer wg.Done()
  8704  			}
  8705  			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
  8706  		}
  8707  		if isLen1 {
  8708  			f(i)
  8709  		} else {
  8710  			go f(i)
  8711  		}
  8712  
  8713  	}
  8714  	wg.Wait()
  8715  
  8716  	for _, e := range ret {
  8717  		if e == graphql.Null {
  8718  			return graphql.Null
  8719  		}
  8720  	}
  8721  
  8722  	return ret
  8723  }
  8724  
  8725  func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
  8726  	if v == nil {
  8727  		return graphql.Null
  8728  	}
  8729  	ret := make(graphql.Array, len(v))
  8730  	var wg sync.WaitGroup
  8731  	isLen1 := len(v) == 1
  8732  	if !isLen1 {
  8733  		wg.Add(len(v))
  8734  	}
  8735  	for i := range v {
  8736  		i := i
  8737  		fc := &graphql.FieldContext{
  8738  			Index:  &i,
  8739  			Result: &v[i],
  8740  		}
  8741  		ctx := graphql.WithFieldContext(ctx, fc)
  8742  		f := func(i int) {
  8743  			defer func() {
  8744  				if r := recover(); r != nil {
  8745  					ec.Error(ctx, ec.Recover(ctx, r))
  8746  					ret = nil
  8747  				}
  8748  			}()
  8749  			if !isLen1 {
  8750  				defer wg.Done()
  8751  			}
  8752  			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
  8753  		}
  8754  		if isLen1 {
  8755  			f(i)
  8756  		} else {
  8757  			go f(i)
  8758  		}
  8759  
  8760  	}
  8761  	wg.Wait()
  8762  
  8763  	for _, e := range ret {
  8764  		if e == graphql.Null {
  8765  			return graphql.Null
  8766  		}
  8767  	}
  8768  
  8769  	return ret
  8770  }
  8771  
  8772  func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
  8773  	if v == nil {
  8774  		return graphql.Null
  8775  	}
  8776  	ret := make(graphql.Array, len(v))
  8777  	var wg sync.WaitGroup
  8778  	isLen1 := len(v) == 1
  8779  	if !isLen1 {
  8780  		wg.Add(len(v))
  8781  	}
  8782  	for i := range v {
  8783  		i := i
  8784  		fc := &graphql.FieldContext{
  8785  			Index:  &i,
  8786  			Result: &v[i],
  8787  		}
  8788  		ctx := graphql.WithFieldContext(ctx, fc)
  8789  		f := func(i int) {
  8790  			defer func() {
  8791  				if r := recover(); r != nil {
  8792  					ec.Error(ctx, ec.Recover(ctx, r))
  8793  					ret = nil
  8794  				}
  8795  			}()
  8796  			if !isLen1 {
  8797  				defer wg.Done()
  8798  			}
  8799  			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
  8800  		}
  8801  		if isLen1 {
  8802  			f(i)
  8803  		} else {
  8804  			go f(i)
  8805  		}
  8806  
  8807  	}
  8808  	wg.Wait()
  8809  
  8810  	for _, e := range ret {
  8811  		if e == graphql.Null {
  8812  			return graphql.Null
  8813  		}
  8814  	}
  8815  
  8816  	return ret
  8817  }
  8818  
  8819  func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
  8820  	if v == nil {
  8821  		return graphql.Null
  8822  	}
  8823  	return ec.___Schema(ctx, sel, v)
  8824  }
  8825  
  8826  func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
  8827  	if v == nil {
  8828  		return graphql.Null
  8829  	}
  8830  	ret := make(graphql.Array, len(v))
  8831  	var wg sync.WaitGroup
  8832  	isLen1 := len(v) == 1
  8833  	if !isLen1 {
  8834  		wg.Add(len(v))
  8835  	}
  8836  	for i := range v {
  8837  		i := i
  8838  		fc := &graphql.FieldContext{
  8839  			Index:  &i,
  8840  			Result: &v[i],
  8841  		}
  8842  		ctx := graphql.WithFieldContext(ctx, fc)
  8843  		f := func(i int) {
  8844  			defer func() {
  8845  				if r := recover(); r != nil {
  8846  					ec.Error(ctx, ec.Recover(ctx, r))
  8847  					ret = nil
  8848  				}
  8849  			}()
  8850  			if !isLen1 {
  8851  				defer wg.Done()
  8852  			}
  8853  			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
  8854  		}
  8855  		if isLen1 {
  8856  			f(i)
  8857  		} else {
  8858  			go f(i)
  8859  		}
  8860  
  8861  	}
  8862  	wg.Wait()
  8863  
  8864  	for _, e := range ret {
  8865  		if e == graphql.Null {
  8866  			return graphql.Null
  8867  		}
  8868  	}
  8869  
  8870  	return ret
  8871  }
  8872  
  8873  func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
  8874  	if v == nil {
  8875  		return graphql.Null
  8876  	}
  8877  	return ec.___Type(ctx, sel, v)
  8878  }
  8879  
  8880  // endregion ***************************** type.gotpl *****************************
  8881  

View as plain text