Source file src/github.com/99designs/gqlgen/integration/server/generated.go

Documentation: github.com/99designs/gqlgen/integration/server

     1  // Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
     2  
     3  package server
     4  
     5  import (
     6  	"bytes"
     7  	"context"
     8  	"embed"
     9  	"errors"
    10  	"fmt"
    11  	"strconv"
    12  	"sync"
    13  	"sync/atomic"
    14  
    15  	"github.com/99designs/gqlgen/graphql"
    16  	"github.com/99designs/gqlgen/graphql/introspection"
    17  	models "github.com/99designs/gqlgen/integration/server/models-go"
    18  	"github.com/99designs/gqlgen/integration/server/remote_api"
    19  	"github.com/99designs/gqlgen/integration/server/testomitempty"
    20  	gqlparser "github.com/vektah/gqlparser/v2"
    21  	"github.com/vektah/gqlparser/v2/ast"
    22  )
    23  
    24  // region    ************************** generated!.gotpl **************************
    25  
    26  // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
    27  func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
    28  	return &executableSchema{
    29  		schema:     cfg.Schema,
    30  		resolvers:  cfg.Resolvers,
    31  		directives: cfg.Directives,
    32  		complexity: cfg.Complexity,
    33  	}
    34  }
    35  
    36  type Config struct {
    37  	Schema     *ast.Schema
    38  	Resolvers  ResolverRoot
    39  	Directives DirectiveRoot
    40  	Complexity ComplexityRoot
    41  }
    42  
    43  type ResolverRoot interface {
    44  	Element() ElementResolver
    45  	Query() QueryResolver
    46  	User() UserResolver
    47  }
    48  
    49  type DirectiveRoot struct {
    50  	Magic func(ctx context.Context, obj interface{}, next graphql.Resolver, kind *int) (res interface{}, err error)
    51  }
    52  
    53  type ComplexityRoot struct {
    54  	Element struct {
    55  		Child      func(childComplexity int) int
    56  		Error      func(childComplexity int) int
    57  		Mismatched func(childComplexity int) int
    58  	}
    59  
    60  	Query struct {
    61  		Coercion     func(childComplexity int, value []*models.ListCoercion) int
    62  		Complexity   func(childComplexity int, value int) int
    63  		Date         func(childComplexity int, filter models.DateFilter) int
    64  		Error        func(childComplexity int, typeArg *models.ErrorType) int
    65  		JSONEncoding func(childComplexity int) int
    66  		Path         func(childComplexity int) int
    67  		Viewer       func(childComplexity int) int
    68  	}
    69  
    70  	RemoteModelWithOmitempty struct {
    71  		Description func(childComplexity int) int
    72  	}
    73  
    74  	User struct {
    75  		Likes       func(childComplexity int) int
    76  		Name        func(childComplexity int) int
    77  		PhoneNumber func(childComplexity int) int
    78  		Query       func(childComplexity int) int
    79  	}
    80  
    81  	Viewer struct {
    82  		User func(childComplexity int) int
    83  	}
    84  }
    85  
    86  type ElementResolver interface {
    87  	Child(ctx context.Context, obj *models.Element) (*models.Element, error)
    88  	Error(ctx context.Context, obj *models.Element) (bool, error)
    89  	Mismatched(ctx context.Context, obj *models.Element) ([]bool, error)
    90  }
    91  type QueryResolver interface {
    92  	Path(ctx context.Context) ([]*models.Element, error)
    93  	Date(ctx context.Context, filter models.DateFilter) (bool, error)
    94  	Viewer(ctx context.Context) (*models.Viewer, error)
    95  	JSONEncoding(ctx context.Context) (string, error)
    96  	Error(ctx context.Context, typeArg *models.ErrorType) (bool, error)
    97  	Complexity(ctx context.Context, value int) (bool, error)
    98  	Coercion(ctx context.Context, value []*models.ListCoercion) (bool, error)
    99  }
   100  type UserResolver interface {
   101  	Likes(ctx context.Context, obj *remote_api.User) ([]string, error)
   102  }
   103  
   104  type executableSchema struct {
   105  	schema     *ast.Schema
   106  	resolvers  ResolverRoot
   107  	directives DirectiveRoot
   108  	complexity ComplexityRoot
   109  }
   110  
   111  func (e *executableSchema) Schema() *ast.Schema {
   112  	if e.schema != nil {
   113  		return e.schema
   114  	}
   115  	return parsedSchema
   116  }
   117  
   118  func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
   119  	ec := executionContext{nil, e, 0, 0, nil}
   120  	_ = ec
   121  	switch typeName + "." + field {
   122  
   123  	case "Element.child":
   124  		if e.complexity.Element.Child == nil {
   125  			break
   126  		}
   127  
   128  		return e.complexity.Element.Child(childComplexity), true
   129  
   130  	case "Element.error":
   131  		if e.complexity.Element.Error == nil {
   132  			break
   133  		}
   134  
   135  		return e.complexity.Element.Error(childComplexity), true
   136  
   137  	case "Element.mismatched":
   138  		if e.complexity.Element.Mismatched == nil {
   139  			break
   140  		}
   141  
   142  		return e.complexity.Element.Mismatched(childComplexity), true
   143  
   144  	case "Query.coercion":
   145  		if e.complexity.Query.Coercion == nil {
   146  			break
   147  		}
   148  
   149  		args, err := ec.field_Query_coercion_args(context.TODO(), rawArgs)
   150  		if err != nil {
   151  			return 0, false
   152  		}
   153  
   154  		return e.complexity.Query.Coercion(childComplexity, args["value"].([]*models.ListCoercion)), true
   155  
   156  	case "Query.complexity":
   157  		if e.complexity.Query.Complexity == nil {
   158  			break
   159  		}
   160  
   161  		args, err := ec.field_Query_complexity_args(context.TODO(), rawArgs)
   162  		if err != nil {
   163  			return 0, false
   164  		}
   165  
   166  		return e.complexity.Query.Complexity(childComplexity, args["value"].(int)), true
   167  
   168  	case "Query.date":
   169  		if e.complexity.Query.Date == nil {
   170  			break
   171  		}
   172  
   173  		args, err := ec.field_Query_date_args(context.TODO(), rawArgs)
   174  		if err != nil {
   175  			return 0, false
   176  		}
   177  
   178  		return e.complexity.Query.Date(childComplexity, args["filter"].(models.DateFilter)), true
   179  
   180  	case "Query.error":
   181  		if e.complexity.Query.Error == nil {
   182  			break
   183  		}
   184  
   185  		args, err := ec.field_Query_error_args(context.TODO(), rawArgs)
   186  		if err != nil {
   187  			return 0, false
   188  		}
   189  
   190  		return e.complexity.Query.Error(childComplexity, args["type"].(*models.ErrorType)), true
   191  
   192  	case "Query.jsonEncoding":
   193  		if e.complexity.Query.JSONEncoding == nil {
   194  			break
   195  		}
   196  
   197  		return e.complexity.Query.JSONEncoding(childComplexity), true
   198  
   199  	case "Query.path":
   200  		if e.complexity.Query.Path == nil {
   201  			break
   202  		}
   203  
   204  		return e.complexity.Query.Path(childComplexity), true
   205  
   206  	case "Query.viewer":
   207  		if e.complexity.Query.Viewer == nil {
   208  			break
   209  		}
   210  
   211  		return e.complexity.Query.Viewer(childComplexity), true
   212  
   213  	case "RemoteModelWithOmitempty.newDesc":
   214  		if e.complexity.RemoteModelWithOmitempty.Description == nil {
   215  			break
   216  		}
   217  
   218  		return e.complexity.RemoteModelWithOmitempty.Description(childComplexity), true
   219  
   220  	case "User.likes":
   221  		if e.complexity.User.Likes == nil {
   222  			break
   223  		}
   224  
   225  		return e.complexity.User.Likes(childComplexity), true
   226  
   227  	case "User.name":
   228  		if e.complexity.User.Name == nil {
   229  			break
   230  		}
   231  
   232  		return e.complexity.User.Name(childComplexity), true
   233  
   234  	case "User.phoneNumber":
   235  		if e.complexity.User.PhoneNumber == nil {
   236  			break
   237  		}
   238  
   239  		return e.complexity.User.PhoneNumber(childComplexity), true
   240  
   241  	case "User.query":
   242  		if e.complexity.User.Query == nil {
   243  			break
   244  		}
   245  
   246  		return e.complexity.User.Query(childComplexity), true
   247  
   248  	case "Viewer.user":
   249  		if e.complexity.Viewer.User == nil {
   250  			break
   251  		}
   252  
   253  		return e.complexity.Viewer.User(childComplexity), true
   254  
   255  	}
   256  	return 0, false
   257  }
   258  
   259  func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
   260  	rc := graphql.GetOperationContext(ctx)
   261  	ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
   262  	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
   263  		ec.unmarshalInputDateFilter,
   264  		ec.unmarshalInputListCoercion,
   265  	)
   266  	first := true
   267  
   268  	switch rc.Operation.Operation {
   269  	case ast.Query:
   270  		return func(ctx context.Context) *graphql.Response {
   271  			var response graphql.Response
   272  			var data graphql.Marshaler
   273  			if first {
   274  				first = false
   275  				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
   276  				data = ec._Query(ctx, rc.Operation.SelectionSet)
   277  			} else {
   278  				if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
   279  					result := <-ec.deferredResults
   280  					atomic.AddInt32(&ec.pendingDeferred, -1)
   281  					data = result.Result
   282  					response.Path = result.Path
   283  					response.Label = result.Label
   284  					response.Errors = result.Errors
   285  				} else {
   286  					return nil
   287  				}
   288  			}
   289  			var buf bytes.Buffer
   290  			data.MarshalGQL(&buf)
   291  			response.Data = buf.Bytes()
   292  			if atomic.LoadInt32(&ec.deferred) > 0 {
   293  				hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
   294  				response.HasNext = &hasNext
   295  			}
   296  
   297  			return &response
   298  		}
   299  
   300  	default:
   301  		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
   302  	}
   303  }
   304  
   305  type executionContext struct {
   306  	*graphql.OperationContext
   307  	*executableSchema
   308  	deferred        int32
   309  	pendingDeferred int32
   310  	deferredResults chan graphql.DeferredResult
   311  }
   312  
   313  func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
   314  	atomic.AddInt32(&ec.pendingDeferred, 1)
   315  	go func() {
   316  		ctx := graphql.WithFreshResponseContext(dg.Context)
   317  		dg.FieldSet.Dispatch(ctx)
   318  		ds := graphql.DeferredResult{
   319  			Path:   dg.Path,
   320  			Label:  dg.Label,
   321  			Result: dg.FieldSet,
   322  			Errors: graphql.GetErrors(ctx),
   323  		}
   324  		// null fields should bubble up
   325  		if dg.FieldSet.Invalids > 0 {
   326  			ds.Result = graphql.Null
   327  		}
   328  		ec.deferredResults <- ds
   329  	}()
   330  }
   331  
   332  func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
   333  	if ec.DisableIntrospection {
   334  		return nil, errors.New("introspection disabled")
   335  	}
   336  	return introspection.WrapSchema(ec.Schema()), nil
   337  }
   338  
   339  func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
   340  	if ec.DisableIntrospection {
   341  		return nil, errors.New("introspection disabled")
   342  	}
   343  	return introspection.WrapTypeFromDef(ec.Schema(), ec.Schema().Types[name]), nil
   344  }
   345  
   346  //go:embed "schema/schema.graphql" "schema/testomitempty.graphql" "schema/user.graphql"
   347  var sourcesFS embed.FS
   348  
   349  func sourceData(filename string) string {
   350  	data, err := sourcesFS.ReadFile(filename)
   351  	if err != nil {
   352  		panic(fmt.Sprintf("codegen problem: %s not available", filename))
   353  	}
   354  	return string(data)
   355  }
   356  
   357  var sources = []*ast.Source{
   358  	{Name: "schema/schema.graphql", Input: sourceData("schema/schema.graphql"), BuiltIn: false},
   359  	{Name: "schema/testomitempty.graphql", Input: sourceData("schema/testomitempty.graphql"), BuiltIn: false},
   360  	{Name: "schema/user.graphql", Input: sourceData("schema/user.graphql"), BuiltIn: false},
   361  }
   362  var parsedSchema = gqlparser.MustLoadSchema(sources...)
   363  
   364  // endregion ************************** generated!.gotpl **************************
   365  
   366  // region    ***************************** args.gotpl *****************************
   367  
   368  func (ec *executionContext) dir_magic_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   369  	var err error
   370  	args := map[string]interface{}{}
   371  	var arg0 *int
   372  	if tmp, ok := rawArgs["kind"]; ok {
   373  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kind"))
   374  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   375  		if err != nil {
   376  			return nil, err
   377  		}
   378  	}
   379  	args["kind"] = arg0
   380  	return args, nil
   381  }
   382  
   383  func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   384  	var err error
   385  	args := map[string]interface{}{}
   386  	var arg0 string
   387  	if tmp, ok := rawArgs["name"]; ok {
   388  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
   389  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   390  		if err != nil {
   391  			return nil, err
   392  		}
   393  	}
   394  	args["name"] = arg0
   395  	return args, nil
   396  }
   397  
   398  func (ec *executionContext) field_Query_coercion_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   399  	var err error
   400  	args := map[string]interface{}{}
   401  	var arg0 []*models.ListCoercion
   402  	if tmp, ok := rawArgs["value"]; ok {
   403  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
   404  		arg0, err = ec.unmarshalOListCoercion2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐListCoercionᚄ(ctx, tmp)
   405  		if err != nil {
   406  			return nil, err
   407  		}
   408  	}
   409  	args["value"] = arg0
   410  	return args, nil
   411  }
   412  
   413  func (ec *executionContext) field_Query_complexity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   414  	var err error
   415  	args := map[string]interface{}{}
   416  	var arg0 int
   417  	if tmp, ok := rawArgs["value"]; ok {
   418  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
   419  		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
   420  		if err != nil {
   421  			return nil, err
   422  		}
   423  	}
   424  	args["value"] = arg0
   425  	return args, nil
   426  }
   427  
   428  func (ec *executionContext) field_Query_date_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   429  	var err error
   430  	args := map[string]interface{}{}
   431  	var arg0 models.DateFilter
   432  	if tmp, ok := rawArgs["filter"]; ok {
   433  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
   434  		arg0, err = ec.unmarshalNDateFilter2githubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐDateFilter(ctx, tmp)
   435  		if err != nil {
   436  			return nil, err
   437  		}
   438  	}
   439  	args["filter"] = arg0
   440  	return args, nil
   441  }
   442  
   443  func (ec *executionContext) field_Query_error_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   444  	var err error
   445  	args := map[string]interface{}{}
   446  	var arg0 *models.ErrorType
   447  	if tmp, ok := rawArgs["type"]; ok {
   448  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
   449  		arg0, err = ec.unmarshalOErrorType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx, tmp)
   450  		if err != nil {
   451  			return nil, err
   452  		}
   453  	}
   454  	args["type"] = arg0
   455  	return args, nil
   456  }
   457  
   458  func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   459  	var err error
   460  	args := map[string]interface{}{}
   461  	var arg0 bool
   462  	if tmp, ok := rawArgs["includeDeprecated"]; ok {
   463  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
   464  		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
   465  		if err != nil {
   466  			return nil, err
   467  		}
   468  	}
   469  	args["includeDeprecated"] = arg0
   470  	return args, nil
   471  }
   472  
   473  func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   474  	var err error
   475  	args := map[string]interface{}{}
   476  	var arg0 bool
   477  	if tmp, ok := rawArgs["includeDeprecated"]; ok {
   478  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
   479  		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
   480  		if err != nil {
   481  			return nil, err
   482  		}
   483  	}
   484  	args["includeDeprecated"] = arg0
   485  	return args, nil
   486  }
   487  
   488  // endregion ***************************** args.gotpl *****************************
   489  
   490  // region    ************************** directives.gotpl **************************
   491  
   492  // endregion ************************** directives.gotpl **************************
   493  
   494  // region    **************************** field.gotpl *****************************
   495  
   496  func (ec *executionContext) _Element_child(ctx context.Context, field graphql.CollectedField, obj *models.Element) (ret graphql.Marshaler) {
   497  	fc, err := ec.fieldContext_Element_child(ctx, field)
   498  	if err != nil {
   499  		return graphql.Null
   500  	}
   501  	ctx = graphql.WithFieldContext(ctx, fc)
   502  	defer func() {
   503  		if r := recover(); r != nil {
   504  			ec.Error(ctx, ec.Recover(ctx, r))
   505  			ret = graphql.Null
   506  		}
   507  	}()
   508  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   509  		ctx = rctx // use context from middleware stack in children
   510  		return ec.resolvers.Element().Child(rctx, obj)
   511  	})
   512  	if err != nil {
   513  		ec.Error(ctx, err)
   514  		return graphql.Null
   515  	}
   516  	if resTmp == nil {
   517  		if !graphql.HasFieldError(ctx, fc) {
   518  			ec.Errorf(ctx, "must not be null")
   519  		}
   520  		return graphql.Null
   521  	}
   522  	res := resTmp.(*models.Element)
   523  	fc.Result = res
   524  	return ec.marshalNElement2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx, field.Selections, res)
   525  }
   526  
   527  func (ec *executionContext) fieldContext_Element_child(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   528  	fc = &graphql.FieldContext{
   529  		Object:     "Element",
   530  		Field:      field,
   531  		IsMethod:   true,
   532  		IsResolver: true,
   533  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   534  			switch field.Name {
   535  			case "child":
   536  				return ec.fieldContext_Element_child(ctx, field)
   537  			case "error":
   538  				return ec.fieldContext_Element_error(ctx, field)
   539  			case "mismatched":
   540  				return ec.fieldContext_Element_mismatched(ctx, field)
   541  			}
   542  			return nil, fmt.Errorf("no field named %q was found under type Element", field.Name)
   543  		},
   544  	}
   545  	return fc, nil
   546  }
   547  
   548  func (ec *executionContext) _Element_error(ctx context.Context, field graphql.CollectedField, obj *models.Element) (ret graphql.Marshaler) {
   549  	fc, err := ec.fieldContext_Element_error(ctx, field)
   550  	if err != nil {
   551  		return graphql.Null
   552  	}
   553  	ctx = graphql.WithFieldContext(ctx, fc)
   554  	defer func() {
   555  		if r := recover(); r != nil {
   556  			ec.Error(ctx, ec.Recover(ctx, r))
   557  			ret = graphql.Null
   558  		}
   559  	}()
   560  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   561  		ctx = rctx // use context from middleware stack in children
   562  		return ec.resolvers.Element().Error(rctx, obj)
   563  	})
   564  	if err != nil {
   565  		ec.Error(ctx, err)
   566  		return graphql.Null
   567  	}
   568  	if resTmp == nil {
   569  		if !graphql.HasFieldError(ctx, fc) {
   570  			ec.Errorf(ctx, "must not be null")
   571  		}
   572  		return graphql.Null
   573  	}
   574  	res := resTmp.(bool)
   575  	fc.Result = res
   576  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   577  }
   578  
   579  func (ec *executionContext) fieldContext_Element_error(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   580  	fc = &graphql.FieldContext{
   581  		Object:     "Element",
   582  		Field:      field,
   583  		IsMethod:   true,
   584  		IsResolver: true,
   585  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   586  			return nil, errors.New("field of type Boolean does not have child fields")
   587  		},
   588  	}
   589  	return fc, nil
   590  }
   591  
   592  func (ec *executionContext) _Element_mismatched(ctx context.Context, field graphql.CollectedField, obj *models.Element) (ret graphql.Marshaler) {
   593  	fc, err := ec.fieldContext_Element_mismatched(ctx, field)
   594  	if err != nil {
   595  		return graphql.Null
   596  	}
   597  	ctx = graphql.WithFieldContext(ctx, fc)
   598  	defer func() {
   599  		if r := recover(); r != nil {
   600  			ec.Error(ctx, ec.Recover(ctx, r))
   601  			ret = graphql.Null
   602  		}
   603  	}()
   604  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   605  		ctx = rctx // use context from middleware stack in children
   606  		return ec.resolvers.Element().Mismatched(rctx, obj)
   607  	})
   608  	if err != nil {
   609  		ec.Error(ctx, err)
   610  		return graphql.Null
   611  	}
   612  	if resTmp == nil {
   613  		return graphql.Null
   614  	}
   615  	res := resTmp.([]bool)
   616  	fc.Result = res
   617  	return ec.marshalOBoolean2ᚕboolᚄ(ctx, field.Selections, res)
   618  }
   619  
   620  func (ec *executionContext) fieldContext_Element_mismatched(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   621  	fc = &graphql.FieldContext{
   622  		Object:     "Element",
   623  		Field:      field,
   624  		IsMethod:   true,
   625  		IsResolver: true,
   626  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   627  			return nil, errors.New("field of type Boolean does not have child fields")
   628  		},
   629  	}
   630  	return fc, nil
   631  }
   632  
   633  func (ec *executionContext) _Query_path(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   634  	fc, err := ec.fieldContext_Query_path(ctx, field)
   635  	if err != nil {
   636  		return graphql.Null
   637  	}
   638  	ctx = graphql.WithFieldContext(ctx, fc)
   639  	defer func() {
   640  		if r := recover(); r != nil {
   641  			ec.Error(ctx, ec.Recover(ctx, r))
   642  			ret = graphql.Null
   643  		}
   644  	}()
   645  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   646  		ctx = rctx // use context from middleware stack in children
   647  		return ec.resolvers.Query().Path(rctx)
   648  	})
   649  	if err != nil {
   650  		ec.Error(ctx, err)
   651  		return graphql.Null
   652  	}
   653  	if resTmp == nil {
   654  		return graphql.Null
   655  	}
   656  	res := resTmp.([]*models.Element)
   657  	fc.Result = res
   658  	return ec.marshalOElement2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx, field.Selections, res)
   659  }
   660  
   661  func (ec *executionContext) fieldContext_Query_path(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   662  	fc = &graphql.FieldContext{
   663  		Object:     "Query",
   664  		Field:      field,
   665  		IsMethod:   true,
   666  		IsResolver: true,
   667  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   668  			switch field.Name {
   669  			case "child":
   670  				return ec.fieldContext_Element_child(ctx, field)
   671  			case "error":
   672  				return ec.fieldContext_Element_error(ctx, field)
   673  			case "mismatched":
   674  				return ec.fieldContext_Element_mismatched(ctx, field)
   675  			}
   676  			return nil, fmt.Errorf("no field named %q was found under type Element", field.Name)
   677  		},
   678  	}
   679  	return fc, nil
   680  }
   681  
   682  func (ec *executionContext) _Query_date(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   683  	fc, err := ec.fieldContext_Query_date(ctx, field)
   684  	if err != nil {
   685  		return graphql.Null
   686  	}
   687  	ctx = graphql.WithFieldContext(ctx, fc)
   688  	defer func() {
   689  		if r := recover(); r != nil {
   690  			ec.Error(ctx, ec.Recover(ctx, r))
   691  			ret = graphql.Null
   692  		}
   693  	}()
   694  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   695  		ctx = rctx // use context from middleware stack in children
   696  		return ec.resolvers.Query().Date(rctx, fc.Args["filter"].(models.DateFilter))
   697  	})
   698  	if err != nil {
   699  		ec.Error(ctx, err)
   700  		return graphql.Null
   701  	}
   702  	if resTmp == nil {
   703  		if !graphql.HasFieldError(ctx, fc) {
   704  			ec.Errorf(ctx, "must not be null")
   705  		}
   706  		return graphql.Null
   707  	}
   708  	res := resTmp.(bool)
   709  	fc.Result = res
   710  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   711  }
   712  
   713  func (ec *executionContext) fieldContext_Query_date(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   714  	fc = &graphql.FieldContext{
   715  		Object:     "Query",
   716  		Field:      field,
   717  		IsMethod:   true,
   718  		IsResolver: true,
   719  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   720  			return nil, errors.New("field of type Boolean does not have child fields")
   721  		},
   722  	}
   723  	defer func() {
   724  		if r := recover(); r != nil {
   725  			err = ec.Recover(ctx, r)
   726  			ec.Error(ctx, err)
   727  		}
   728  	}()
   729  	ctx = graphql.WithFieldContext(ctx, fc)
   730  	if fc.Args, err = ec.field_Query_date_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
   731  		ec.Error(ctx, err)
   732  		return fc, err
   733  	}
   734  	return fc, nil
   735  }
   736  
   737  func (ec *executionContext) _Query_viewer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   738  	fc, err := ec.fieldContext_Query_viewer(ctx, field)
   739  	if err != nil {
   740  		return graphql.Null
   741  	}
   742  	ctx = graphql.WithFieldContext(ctx, fc)
   743  	defer func() {
   744  		if r := recover(); r != nil {
   745  			ec.Error(ctx, ec.Recover(ctx, r))
   746  			ret = graphql.Null
   747  		}
   748  	}()
   749  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   750  		ctx = rctx // use context from middleware stack in children
   751  		return ec.resolvers.Query().Viewer(rctx)
   752  	})
   753  	if err != nil {
   754  		ec.Error(ctx, err)
   755  		return graphql.Null
   756  	}
   757  	if resTmp == nil {
   758  		return graphql.Null
   759  	}
   760  	res := resTmp.(*models.Viewer)
   761  	fc.Result = res
   762  	return ec.marshalOViewer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐViewer(ctx, field.Selections, res)
   763  }
   764  
   765  func (ec *executionContext) fieldContext_Query_viewer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   766  	fc = &graphql.FieldContext{
   767  		Object:     "Query",
   768  		Field:      field,
   769  		IsMethod:   true,
   770  		IsResolver: true,
   771  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   772  			switch field.Name {
   773  			case "user":
   774  				return ec.fieldContext_Viewer_user(ctx, field)
   775  			}
   776  			return nil, fmt.Errorf("no field named %q was found under type Viewer", field.Name)
   777  		},
   778  	}
   779  	return fc, nil
   780  }
   781  
   782  func (ec *executionContext) _Query_jsonEncoding(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   783  	fc, err := ec.fieldContext_Query_jsonEncoding(ctx, field)
   784  	if err != nil {
   785  		return graphql.Null
   786  	}
   787  	ctx = graphql.WithFieldContext(ctx, fc)
   788  	defer func() {
   789  		if r := recover(); r != nil {
   790  			ec.Error(ctx, ec.Recover(ctx, r))
   791  			ret = graphql.Null
   792  		}
   793  	}()
   794  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   795  		ctx = rctx // use context from middleware stack in children
   796  		return ec.resolvers.Query().JSONEncoding(rctx)
   797  	})
   798  	if err != nil {
   799  		ec.Error(ctx, err)
   800  		return graphql.Null
   801  	}
   802  	if resTmp == nil {
   803  		if !graphql.HasFieldError(ctx, fc) {
   804  			ec.Errorf(ctx, "must not be null")
   805  		}
   806  		return graphql.Null
   807  	}
   808  	res := resTmp.(string)
   809  	fc.Result = res
   810  	return ec.marshalNString2string(ctx, field.Selections, res)
   811  }
   812  
   813  func (ec *executionContext) fieldContext_Query_jsonEncoding(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   814  	fc = &graphql.FieldContext{
   815  		Object:     "Query",
   816  		Field:      field,
   817  		IsMethod:   true,
   818  		IsResolver: true,
   819  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   820  			return nil, errors.New("field of type String does not have child fields")
   821  		},
   822  	}
   823  	return fc, nil
   824  }
   825  
   826  func (ec *executionContext) _Query_error(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   827  	fc, err := ec.fieldContext_Query_error(ctx, field)
   828  	if err != nil {
   829  		return graphql.Null
   830  	}
   831  	ctx = graphql.WithFieldContext(ctx, fc)
   832  	defer func() {
   833  		if r := recover(); r != nil {
   834  			ec.Error(ctx, ec.Recover(ctx, r))
   835  			ret = graphql.Null
   836  		}
   837  	}()
   838  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   839  		ctx = rctx // use context from middleware stack in children
   840  		return ec.resolvers.Query().Error(rctx, fc.Args["type"].(*models.ErrorType))
   841  	})
   842  	if err != nil {
   843  		ec.Error(ctx, err)
   844  		return graphql.Null
   845  	}
   846  	if resTmp == nil {
   847  		if !graphql.HasFieldError(ctx, fc) {
   848  			ec.Errorf(ctx, "must not be null")
   849  		}
   850  		return graphql.Null
   851  	}
   852  	res := resTmp.(bool)
   853  	fc.Result = res
   854  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   855  }
   856  
   857  func (ec *executionContext) fieldContext_Query_error(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   858  	fc = &graphql.FieldContext{
   859  		Object:     "Query",
   860  		Field:      field,
   861  		IsMethod:   true,
   862  		IsResolver: true,
   863  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   864  			return nil, errors.New("field of type Boolean does not have child fields")
   865  		},
   866  	}
   867  	defer func() {
   868  		if r := recover(); r != nil {
   869  			err = ec.Recover(ctx, r)
   870  			ec.Error(ctx, err)
   871  		}
   872  	}()
   873  	ctx = graphql.WithFieldContext(ctx, fc)
   874  	if fc.Args, err = ec.field_Query_error_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
   875  		ec.Error(ctx, err)
   876  		return fc, err
   877  	}
   878  	return fc, nil
   879  }
   880  
   881  func (ec *executionContext) _Query_complexity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   882  	fc, err := ec.fieldContext_Query_complexity(ctx, field)
   883  	if err != nil {
   884  		return graphql.Null
   885  	}
   886  	ctx = graphql.WithFieldContext(ctx, fc)
   887  	defer func() {
   888  		if r := recover(); r != nil {
   889  			ec.Error(ctx, ec.Recover(ctx, r))
   890  			ret = graphql.Null
   891  		}
   892  	}()
   893  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   894  		ctx = rctx // use context from middleware stack in children
   895  		return ec.resolvers.Query().Complexity(rctx, fc.Args["value"].(int))
   896  	})
   897  	if err != nil {
   898  		ec.Error(ctx, err)
   899  		return graphql.Null
   900  	}
   901  	if resTmp == nil {
   902  		if !graphql.HasFieldError(ctx, fc) {
   903  			ec.Errorf(ctx, "must not be null")
   904  		}
   905  		return graphql.Null
   906  	}
   907  	res := resTmp.(bool)
   908  	fc.Result = res
   909  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   910  }
   911  
   912  func (ec *executionContext) fieldContext_Query_complexity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   913  	fc = &graphql.FieldContext{
   914  		Object:     "Query",
   915  		Field:      field,
   916  		IsMethod:   true,
   917  		IsResolver: true,
   918  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   919  			return nil, errors.New("field of type Boolean does not have child fields")
   920  		},
   921  	}
   922  	defer func() {
   923  		if r := recover(); r != nil {
   924  			err = ec.Recover(ctx, r)
   925  			ec.Error(ctx, err)
   926  		}
   927  	}()
   928  	ctx = graphql.WithFieldContext(ctx, fc)
   929  	if fc.Args, err = ec.field_Query_complexity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
   930  		ec.Error(ctx, err)
   931  		return fc, err
   932  	}
   933  	return fc, nil
   934  }
   935  
   936  func (ec *executionContext) _Query_coercion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   937  	fc, err := ec.fieldContext_Query_coercion(ctx, field)
   938  	if err != nil {
   939  		return graphql.Null
   940  	}
   941  	ctx = graphql.WithFieldContext(ctx, fc)
   942  	defer func() {
   943  		if r := recover(); r != nil {
   944  			ec.Error(ctx, ec.Recover(ctx, r))
   945  			ret = graphql.Null
   946  		}
   947  	}()
   948  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   949  		ctx = rctx // use context from middleware stack in children
   950  		return ec.resolvers.Query().Coercion(rctx, fc.Args["value"].([]*models.ListCoercion))
   951  	})
   952  	if err != nil {
   953  		ec.Error(ctx, err)
   954  		return graphql.Null
   955  	}
   956  	if resTmp == nil {
   957  		if !graphql.HasFieldError(ctx, fc) {
   958  			ec.Errorf(ctx, "must not be null")
   959  		}
   960  		return graphql.Null
   961  	}
   962  	res := resTmp.(bool)
   963  	fc.Result = res
   964  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   965  }
   966  
   967  func (ec *executionContext) fieldContext_Query_coercion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   968  	fc = &graphql.FieldContext{
   969  		Object:     "Query",
   970  		Field:      field,
   971  		IsMethod:   true,
   972  		IsResolver: true,
   973  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   974  			return nil, errors.New("field of type Boolean does not have child fields")
   975  		},
   976  	}
   977  	defer func() {
   978  		if r := recover(); r != nil {
   979  			err = ec.Recover(ctx, r)
   980  			ec.Error(ctx, err)
   981  		}
   982  	}()
   983  	ctx = graphql.WithFieldContext(ctx, fc)
   984  	if fc.Args, err = ec.field_Query_coercion_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
   985  		ec.Error(ctx, err)
   986  		return fc, err
   987  	}
   988  	return fc, nil
   989  }
   990  
   991  func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   992  	fc, err := ec.fieldContext_Query___type(ctx, field)
   993  	if err != nil {
   994  		return graphql.Null
   995  	}
   996  	ctx = graphql.WithFieldContext(ctx, fc)
   997  	defer func() {
   998  		if r := recover(); r != nil {
   999  			ec.Error(ctx, ec.Recover(ctx, r))
  1000  			ret = graphql.Null
  1001  		}
  1002  	}()
  1003  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1004  		ctx = rctx // use context from middleware stack in children
  1005  		return ec.introspectType(fc.Args["name"].(string))
  1006  	})
  1007  	if err != nil {
  1008  		ec.Error(ctx, err)
  1009  		return graphql.Null
  1010  	}
  1011  	if resTmp == nil {
  1012  		return graphql.Null
  1013  	}
  1014  	res := resTmp.(*introspection.Type)
  1015  	fc.Result = res
  1016  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1017  }
  1018  
  1019  func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1020  	fc = &graphql.FieldContext{
  1021  		Object:     "Query",
  1022  		Field:      field,
  1023  		IsMethod:   true,
  1024  		IsResolver: false,
  1025  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1026  			switch field.Name {
  1027  			case "kind":
  1028  				return ec.fieldContext___Type_kind(ctx, field)
  1029  			case "name":
  1030  				return ec.fieldContext___Type_name(ctx, field)
  1031  			case "description":
  1032  				return ec.fieldContext___Type_description(ctx, field)
  1033  			case "fields":
  1034  				return ec.fieldContext___Type_fields(ctx, field)
  1035  			case "interfaces":
  1036  				return ec.fieldContext___Type_interfaces(ctx, field)
  1037  			case "possibleTypes":
  1038  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  1039  			case "enumValues":
  1040  				return ec.fieldContext___Type_enumValues(ctx, field)
  1041  			case "inputFields":
  1042  				return ec.fieldContext___Type_inputFields(ctx, field)
  1043  			case "ofType":
  1044  				return ec.fieldContext___Type_ofType(ctx, field)
  1045  			case "specifiedByURL":
  1046  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  1047  			}
  1048  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  1049  		},
  1050  	}
  1051  	defer func() {
  1052  		if r := recover(); r != nil {
  1053  			err = ec.Recover(ctx, r)
  1054  			ec.Error(ctx, err)
  1055  		}
  1056  	}()
  1057  	ctx = graphql.WithFieldContext(ctx, fc)
  1058  	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1059  		ec.Error(ctx, err)
  1060  		return fc, err
  1061  	}
  1062  	return fc, nil
  1063  }
  1064  
  1065  func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1066  	fc, err := ec.fieldContext_Query___schema(ctx, field)
  1067  	if err != nil {
  1068  		return graphql.Null
  1069  	}
  1070  	ctx = graphql.WithFieldContext(ctx, fc)
  1071  	defer func() {
  1072  		if r := recover(); r != nil {
  1073  			ec.Error(ctx, ec.Recover(ctx, r))
  1074  			ret = graphql.Null
  1075  		}
  1076  	}()
  1077  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1078  		ctx = rctx // use context from middleware stack in children
  1079  		return ec.introspectSchema()
  1080  	})
  1081  	if err != nil {
  1082  		ec.Error(ctx, err)
  1083  		return graphql.Null
  1084  	}
  1085  	if resTmp == nil {
  1086  		return graphql.Null
  1087  	}
  1088  	res := resTmp.(*introspection.Schema)
  1089  	fc.Result = res
  1090  	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
  1091  }
  1092  
  1093  func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1094  	fc = &graphql.FieldContext{
  1095  		Object:     "Query",
  1096  		Field:      field,
  1097  		IsMethod:   true,
  1098  		IsResolver: false,
  1099  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1100  			switch field.Name {
  1101  			case "description":
  1102  				return ec.fieldContext___Schema_description(ctx, field)
  1103  			case "types":
  1104  				return ec.fieldContext___Schema_types(ctx, field)
  1105  			case "queryType":
  1106  				return ec.fieldContext___Schema_queryType(ctx, field)
  1107  			case "mutationType":
  1108  				return ec.fieldContext___Schema_mutationType(ctx, field)
  1109  			case "subscriptionType":
  1110  				return ec.fieldContext___Schema_subscriptionType(ctx, field)
  1111  			case "directives":
  1112  				return ec.fieldContext___Schema_directives(ctx, field)
  1113  			}
  1114  			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
  1115  		},
  1116  	}
  1117  	return fc, nil
  1118  }
  1119  
  1120  func (ec *executionContext) _RemoteModelWithOmitempty_newDesc(ctx context.Context, field graphql.CollectedField, obj *testomitempty.RemoteModelWithOmitempty) (ret graphql.Marshaler) {
  1121  	fc, err := ec.fieldContext_RemoteModelWithOmitempty_newDesc(ctx, field)
  1122  	if err != nil {
  1123  		return graphql.Null
  1124  	}
  1125  	ctx = graphql.WithFieldContext(ctx, fc)
  1126  	defer func() {
  1127  		if r := recover(); r != nil {
  1128  			ec.Error(ctx, ec.Recover(ctx, r))
  1129  			ret = graphql.Null
  1130  		}
  1131  	}()
  1132  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1133  		ctx = rctx // use context from middleware stack in children
  1134  		return obj.Description, nil
  1135  	})
  1136  	if err != nil {
  1137  		ec.Error(ctx, err)
  1138  		return graphql.Null
  1139  	}
  1140  	if resTmp == nil {
  1141  		return graphql.Null
  1142  	}
  1143  	res := resTmp.(string)
  1144  	fc.Result = res
  1145  	return ec.marshalOString2string(ctx, field.Selections, res)
  1146  }
  1147  
  1148  func (ec *executionContext) fieldContext_RemoteModelWithOmitempty_newDesc(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1149  	fc = &graphql.FieldContext{
  1150  		Object:     "RemoteModelWithOmitempty",
  1151  		Field:      field,
  1152  		IsMethod:   false,
  1153  		IsResolver: false,
  1154  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1155  			return nil, errors.New("field of type String does not have child fields")
  1156  		},
  1157  	}
  1158  	return fc, nil
  1159  }
  1160  
  1161  func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *remote_api.User) (ret graphql.Marshaler) {
  1162  	fc, err := ec.fieldContext_User_name(ctx, field)
  1163  	if err != nil {
  1164  		return graphql.Null
  1165  	}
  1166  	ctx = graphql.WithFieldContext(ctx, fc)
  1167  	defer func() {
  1168  		if r := recover(); r != nil {
  1169  			ec.Error(ctx, ec.Recover(ctx, r))
  1170  			ret = graphql.Null
  1171  		}
  1172  	}()
  1173  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1174  		ctx = rctx // use context from middleware stack in children
  1175  		return obj.Name, nil
  1176  	})
  1177  	if err != nil {
  1178  		ec.Error(ctx, err)
  1179  		return graphql.Null
  1180  	}
  1181  	if resTmp == nil {
  1182  		if !graphql.HasFieldError(ctx, fc) {
  1183  			ec.Errorf(ctx, "must not be null")
  1184  		}
  1185  		return graphql.Null
  1186  	}
  1187  	res := resTmp.(string)
  1188  	fc.Result = res
  1189  	return ec.marshalNString2string(ctx, field.Selections, res)
  1190  }
  1191  
  1192  func (ec *executionContext) fieldContext_User_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1193  	fc = &graphql.FieldContext{
  1194  		Object:     "User",
  1195  		Field:      field,
  1196  		IsMethod:   false,
  1197  		IsResolver: false,
  1198  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1199  			return nil, errors.New("field of type String does not have child fields")
  1200  		},
  1201  	}
  1202  	return fc, nil
  1203  }
  1204  
  1205  func (ec *executionContext) _User_likes(ctx context.Context, field graphql.CollectedField, obj *remote_api.User) (ret graphql.Marshaler) {
  1206  	fc, err := ec.fieldContext_User_likes(ctx, field)
  1207  	if err != nil {
  1208  		return graphql.Null
  1209  	}
  1210  	ctx = graphql.WithFieldContext(ctx, fc)
  1211  	defer func() {
  1212  		if r := recover(); r != nil {
  1213  			ec.Error(ctx, ec.Recover(ctx, r))
  1214  			ret = graphql.Null
  1215  		}
  1216  	}()
  1217  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1218  		ctx = rctx // use context from middleware stack in children
  1219  		return ec.resolvers.User().Likes(rctx, obj)
  1220  	})
  1221  	if err != nil {
  1222  		ec.Error(ctx, err)
  1223  		return graphql.Null
  1224  	}
  1225  	if resTmp == nil {
  1226  		if !graphql.HasFieldError(ctx, fc) {
  1227  			ec.Errorf(ctx, "must not be null")
  1228  		}
  1229  		return graphql.Null
  1230  	}
  1231  	res := resTmp.([]string)
  1232  	fc.Result = res
  1233  	return ec.marshalNString2ᚕstringᚄ(ctx, field.Selections, res)
  1234  }
  1235  
  1236  func (ec *executionContext) fieldContext_User_likes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1237  	fc = &graphql.FieldContext{
  1238  		Object:     "User",
  1239  		Field:      field,
  1240  		IsMethod:   true,
  1241  		IsResolver: true,
  1242  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1243  			return nil, errors.New("field of type String does not have child fields")
  1244  		},
  1245  	}
  1246  	return fc, nil
  1247  }
  1248  
  1249  func (ec *executionContext) _User_phoneNumber(ctx context.Context, field graphql.CollectedField, obj *remote_api.User) (ret graphql.Marshaler) {
  1250  	fc, err := ec.fieldContext_User_phoneNumber(ctx, field)
  1251  	if err != nil {
  1252  		return graphql.Null
  1253  	}
  1254  	ctx = graphql.WithFieldContext(ctx, fc)
  1255  	defer func() {
  1256  		if r := recover(); r != nil {
  1257  			ec.Error(ctx, ec.Recover(ctx, r))
  1258  			ret = graphql.Null
  1259  		}
  1260  	}()
  1261  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1262  		ctx = rctx // use context from middleware stack in children
  1263  		return obj.PhoneNumber, nil
  1264  	})
  1265  	if err != nil {
  1266  		ec.Error(ctx, err)
  1267  		return graphql.Null
  1268  	}
  1269  	if resTmp == nil {
  1270  		return graphql.Null
  1271  	}
  1272  	res := resTmp.(string)
  1273  	fc.Result = res
  1274  	return ec.marshalOString2string(ctx, field.Selections, res)
  1275  }
  1276  
  1277  func (ec *executionContext) fieldContext_User_phoneNumber(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1278  	fc = &graphql.FieldContext{
  1279  		Object:     "User",
  1280  		Field:      field,
  1281  		IsMethod:   false,
  1282  		IsResolver: false,
  1283  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1284  			return nil, errors.New("field of type String does not have child fields")
  1285  		},
  1286  	}
  1287  	return fc, nil
  1288  }
  1289  
  1290  func (ec *executionContext) _User_query(ctx context.Context, field graphql.CollectedField, obj *remote_api.User) (ret graphql.Marshaler) {
  1291  	fc, err := ec.fieldContext_User_query(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  	res := models.Query{}
  1303  	fc.Result = res
  1304  	return ec.marshalNQuery2githubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐQuery(ctx, field.Selections, res)
  1305  }
  1306  
  1307  func (ec *executionContext) fieldContext_User_query(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1308  	fc = &graphql.FieldContext{
  1309  		Object:     "User",
  1310  		Field:      field,
  1311  		IsMethod:   false,
  1312  		IsResolver: false,
  1313  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1314  			switch field.Name {
  1315  			case "path":
  1316  				return ec.fieldContext_Query_path(ctx, field)
  1317  			case "date":
  1318  				return ec.fieldContext_Query_date(ctx, field)
  1319  			case "viewer":
  1320  				return ec.fieldContext_Query_viewer(ctx, field)
  1321  			case "jsonEncoding":
  1322  				return ec.fieldContext_Query_jsonEncoding(ctx, field)
  1323  			case "error":
  1324  				return ec.fieldContext_Query_error(ctx, field)
  1325  			case "complexity":
  1326  				return ec.fieldContext_Query_complexity(ctx, field)
  1327  			case "coercion":
  1328  				return ec.fieldContext_Query_coercion(ctx, field)
  1329  			case "__schema":
  1330  				return ec.fieldContext_Query___schema(ctx, field)
  1331  			case "__type":
  1332  				return ec.fieldContext_Query___type(ctx, field)
  1333  			}
  1334  			return nil, fmt.Errorf("no field named %q was found under type Query", field.Name)
  1335  		},
  1336  	}
  1337  	return fc, nil
  1338  }
  1339  
  1340  func (ec *executionContext) _Viewer_user(ctx context.Context, field graphql.CollectedField, obj *models.Viewer) (ret graphql.Marshaler) {
  1341  	fc, err := ec.fieldContext_Viewer_user(ctx, field)
  1342  	if err != nil {
  1343  		return graphql.Null
  1344  	}
  1345  	ctx = graphql.WithFieldContext(ctx, fc)
  1346  	defer func() {
  1347  		if r := recover(); r != nil {
  1348  			ec.Error(ctx, ec.Recover(ctx, r))
  1349  			ret = graphql.Null
  1350  		}
  1351  	}()
  1352  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1353  		ctx = rctx // use context from middleware stack in children
  1354  		return obj.User, nil
  1355  	})
  1356  	if err != nil {
  1357  		ec.Error(ctx, err)
  1358  		return graphql.Null
  1359  	}
  1360  	if resTmp == nil {
  1361  		return graphql.Null
  1362  	}
  1363  	res := resTmp.(*remote_api.User)
  1364  	fc.Result = res
  1365  	return ec.marshalOUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋremote_apiᚐUser(ctx, field.Selections, res)
  1366  }
  1367  
  1368  func (ec *executionContext) fieldContext_Viewer_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1369  	fc = &graphql.FieldContext{
  1370  		Object:     "Viewer",
  1371  		Field:      field,
  1372  		IsMethod:   false,
  1373  		IsResolver: false,
  1374  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1375  			switch field.Name {
  1376  			case "name":
  1377  				return ec.fieldContext_User_name(ctx, field)
  1378  			case "likes":
  1379  				return ec.fieldContext_User_likes(ctx, field)
  1380  			case "phoneNumber":
  1381  				return ec.fieldContext_User_phoneNumber(ctx, field)
  1382  			case "query":
  1383  				return ec.fieldContext_User_query(ctx, field)
  1384  			}
  1385  			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
  1386  		},
  1387  	}
  1388  	return fc, nil
  1389  }
  1390  
  1391  func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  1392  	fc, err := ec.fieldContext___Directive_name(ctx, field)
  1393  	if err != nil {
  1394  		return graphql.Null
  1395  	}
  1396  	ctx = graphql.WithFieldContext(ctx, fc)
  1397  	defer func() {
  1398  		if r := recover(); r != nil {
  1399  			ec.Error(ctx, ec.Recover(ctx, r))
  1400  			ret = graphql.Null
  1401  		}
  1402  	}()
  1403  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1404  		ctx = rctx // use context from middleware stack in children
  1405  		return obj.Name, nil
  1406  	})
  1407  	if err != nil {
  1408  		ec.Error(ctx, err)
  1409  		return graphql.Null
  1410  	}
  1411  	if resTmp == nil {
  1412  		if !graphql.HasFieldError(ctx, fc) {
  1413  			ec.Errorf(ctx, "must not be null")
  1414  		}
  1415  		return graphql.Null
  1416  	}
  1417  	res := resTmp.(string)
  1418  	fc.Result = res
  1419  	return ec.marshalNString2string(ctx, field.Selections, res)
  1420  }
  1421  
  1422  func (ec *executionContext) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1423  	fc = &graphql.FieldContext{
  1424  		Object:     "__Directive",
  1425  		Field:      field,
  1426  		IsMethod:   false,
  1427  		IsResolver: false,
  1428  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1429  			return nil, errors.New("field of type String does not have child fields")
  1430  		},
  1431  	}
  1432  	return fc, nil
  1433  }
  1434  
  1435  func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  1436  	fc, err := ec.fieldContext___Directive_description(ctx, field)
  1437  	if err != nil {
  1438  		return graphql.Null
  1439  	}
  1440  	ctx = graphql.WithFieldContext(ctx, fc)
  1441  	defer func() {
  1442  		if r := recover(); r != nil {
  1443  			ec.Error(ctx, ec.Recover(ctx, r))
  1444  			ret = graphql.Null
  1445  		}
  1446  	}()
  1447  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1448  		ctx = rctx // use context from middleware stack in children
  1449  		return obj.Description(), nil
  1450  	})
  1451  	if err != nil {
  1452  		ec.Error(ctx, err)
  1453  		return graphql.Null
  1454  	}
  1455  	if resTmp == nil {
  1456  		return graphql.Null
  1457  	}
  1458  	res := resTmp.(*string)
  1459  	fc.Result = res
  1460  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1461  }
  1462  
  1463  func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1464  	fc = &graphql.FieldContext{
  1465  		Object:     "__Directive",
  1466  		Field:      field,
  1467  		IsMethod:   true,
  1468  		IsResolver: false,
  1469  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1470  			return nil, errors.New("field of type String does not have child fields")
  1471  		},
  1472  	}
  1473  	return fc, nil
  1474  }
  1475  
  1476  func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  1477  	fc, err := ec.fieldContext___Directive_locations(ctx, field)
  1478  	if err != nil {
  1479  		return graphql.Null
  1480  	}
  1481  	ctx = graphql.WithFieldContext(ctx, fc)
  1482  	defer func() {
  1483  		if r := recover(); r != nil {
  1484  			ec.Error(ctx, ec.Recover(ctx, r))
  1485  			ret = graphql.Null
  1486  		}
  1487  	}()
  1488  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1489  		ctx = rctx // use context from middleware stack in children
  1490  		return obj.Locations, nil
  1491  	})
  1492  	if err != nil {
  1493  		ec.Error(ctx, err)
  1494  		return graphql.Null
  1495  	}
  1496  	if resTmp == nil {
  1497  		if !graphql.HasFieldError(ctx, fc) {
  1498  			ec.Errorf(ctx, "must not be null")
  1499  		}
  1500  		return graphql.Null
  1501  	}
  1502  	res := resTmp.([]string)
  1503  	fc.Result = res
  1504  	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
  1505  }
  1506  
  1507  func (ec *executionContext) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1508  	fc = &graphql.FieldContext{
  1509  		Object:     "__Directive",
  1510  		Field:      field,
  1511  		IsMethod:   false,
  1512  		IsResolver: false,
  1513  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1514  			return nil, errors.New("field of type __DirectiveLocation does not have child fields")
  1515  		},
  1516  	}
  1517  	return fc, nil
  1518  }
  1519  
  1520  func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  1521  	fc, err := ec.fieldContext___Directive_args(ctx, field)
  1522  	if err != nil {
  1523  		return graphql.Null
  1524  	}
  1525  	ctx = graphql.WithFieldContext(ctx, fc)
  1526  	defer func() {
  1527  		if r := recover(); r != nil {
  1528  			ec.Error(ctx, ec.Recover(ctx, r))
  1529  			ret = graphql.Null
  1530  		}
  1531  	}()
  1532  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1533  		ctx = rctx // use context from middleware stack in children
  1534  		return obj.Args, nil
  1535  	})
  1536  	if err != nil {
  1537  		ec.Error(ctx, err)
  1538  		return graphql.Null
  1539  	}
  1540  	if resTmp == nil {
  1541  		if !graphql.HasFieldError(ctx, fc) {
  1542  			ec.Errorf(ctx, "must not be null")
  1543  		}
  1544  		return graphql.Null
  1545  	}
  1546  	res := resTmp.([]introspection.InputValue)
  1547  	fc.Result = res
  1548  	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  1549  }
  1550  
  1551  func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1552  	fc = &graphql.FieldContext{
  1553  		Object:     "__Directive",
  1554  		Field:      field,
  1555  		IsMethod:   false,
  1556  		IsResolver: false,
  1557  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1558  			switch field.Name {
  1559  			case "name":
  1560  				return ec.fieldContext___InputValue_name(ctx, field)
  1561  			case "description":
  1562  				return ec.fieldContext___InputValue_description(ctx, field)
  1563  			case "type":
  1564  				return ec.fieldContext___InputValue_type(ctx, field)
  1565  			case "defaultValue":
  1566  				return ec.fieldContext___InputValue_defaultValue(ctx, field)
  1567  			}
  1568  			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
  1569  		},
  1570  	}
  1571  	return fc, nil
  1572  }
  1573  
  1574  func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  1575  	fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
  1576  	if err != nil {
  1577  		return graphql.Null
  1578  	}
  1579  	ctx = graphql.WithFieldContext(ctx, fc)
  1580  	defer func() {
  1581  		if r := recover(); r != nil {
  1582  			ec.Error(ctx, ec.Recover(ctx, r))
  1583  			ret = graphql.Null
  1584  		}
  1585  	}()
  1586  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1587  		ctx = rctx // use context from middleware stack in children
  1588  		return obj.IsRepeatable, nil
  1589  	})
  1590  	if err != nil {
  1591  		ec.Error(ctx, err)
  1592  		return graphql.Null
  1593  	}
  1594  	if resTmp == nil {
  1595  		if !graphql.HasFieldError(ctx, fc) {
  1596  			ec.Errorf(ctx, "must not be null")
  1597  		}
  1598  		return graphql.Null
  1599  	}
  1600  	res := resTmp.(bool)
  1601  	fc.Result = res
  1602  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1603  }
  1604  
  1605  func (ec *executionContext) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1606  	fc = &graphql.FieldContext{
  1607  		Object:     "__Directive",
  1608  		Field:      field,
  1609  		IsMethod:   false,
  1610  		IsResolver: false,
  1611  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1612  			return nil, errors.New("field of type Boolean does not have child fields")
  1613  		},
  1614  	}
  1615  	return fc, nil
  1616  }
  1617  
  1618  func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  1619  	fc, err := ec.fieldContext___EnumValue_name(ctx, field)
  1620  	if err != nil {
  1621  		return graphql.Null
  1622  	}
  1623  	ctx = graphql.WithFieldContext(ctx, fc)
  1624  	defer func() {
  1625  		if r := recover(); r != nil {
  1626  			ec.Error(ctx, ec.Recover(ctx, r))
  1627  			ret = graphql.Null
  1628  		}
  1629  	}()
  1630  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1631  		ctx = rctx // use context from middleware stack in children
  1632  		return obj.Name, nil
  1633  	})
  1634  	if err != nil {
  1635  		ec.Error(ctx, err)
  1636  		return graphql.Null
  1637  	}
  1638  	if resTmp == nil {
  1639  		if !graphql.HasFieldError(ctx, fc) {
  1640  			ec.Errorf(ctx, "must not be null")
  1641  		}
  1642  		return graphql.Null
  1643  	}
  1644  	res := resTmp.(string)
  1645  	fc.Result = res
  1646  	return ec.marshalNString2string(ctx, field.Selections, res)
  1647  }
  1648  
  1649  func (ec *executionContext) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1650  	fc = &graphql.FieldContext{
  1651  		Object:     "__EnumValue",
  1652  		Field:      field,
  1653  		IsMethod:   false,
  1654  		IsResolver: false,
  1655  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1656  			return nil, errors.New("field of type String does not have child fields")
  1657  		},
  1658  	}
  1659  	return fc, nil
  1660  }
  1661  
  1662  func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  1663  	fc, err := ec.fieldContext___EnumValue_description(ctx, field)
  1664  	if err != nil {
  1665  		return graphql.Null
  1666  	}
  1667  	ctx = graphql.WithFieldContext(ctx, fc)
  1668  	defer func() {
  1669  		if r := recover(); r != nil {
  1670  			ec.Error(ctx, ec.Recover(ctx, r))
  1671  			ret = graphql.Null
  1672  		}
  1673  	}()
  1674  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1675  		ctx = rctx // use context from middleware stack in children
  1676  		return obj.Description(), nil
  1677  	})
  1678  	if err != nil {
  1679  		ec.Error(ctx, err)
  1680  		return graphql.Null
  1681  	}
  1682  	if resTmp == nil {
  1683  		return graphql.Null
  1684  	}
  1685  	res := resTmp.(*string)
  1686  	fc.Result = res
  1687  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1688  }
  1689  
  1690  func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1691  	fc = &graphql.FieldContext{
  1692  		Object:     "__EnumValue",
  1693  		Field:      field,
  1694  		IsMethod:   true,
  1695  		IsResolver: false,
  1696  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1697  			return nil, errors.New("field of type String does not have child fields")
  1698  		},
  1699  	}
  1700  	return fc, nil
  1701  }
  1702  
  1703  func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  1704  	fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
  1705  	if err != nil {
  1706  		return graphql.Null
  1707  	}
  1708  	ctx = graphql.WithFieldContext(ctx, fc)
  1709  	defer func() {
  1710  		if r := recover(); r != nil {
  1711  			ec.Error(ctx, ec.Recover(ctx, r))
  1712  			ret = graphql.Null
  1713  		}
  1714  	}()
  1715  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1716  		ctx = rctx // use context from middleware stack in children
  1717  		return obj.IsDeprecated(), nil
  1718  	})
  1719  	if err != nil {
  1720  		ec.Error(ctx, err)
  1721  		return graphql.Null
  1722  	}
  1723  	if resTmp == nil {
  1724  		if !graphql.HasFieldError(ctx, fc) {
  1725  			ec.Errorf(ctx, "must not be null")
  1726  		}
  1727  		return graphql.Null
  1728  	}
  1729  	res := resTmp.(bool)
  1730  	fc.Result = res
  1731  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1732  }
  1733  
  1734  func (ec *executionContext) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1735  	fc = &graphql.FieldContext{
  1736  		Object:     "__EnumValue",
  1737  		Field:      field,
  1738  		IsMethod:   true,
  1739  		IsResolver: false,
  1740  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1741  			return nil, errors.New("field of type Boolean does not have child fields")
  1742  		},
  1743  	}
  1744  	return fc, nil
  1745  }
  1746  
  1747  func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
  1748  	fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
  1749  	if err != nil {
  1750  		return graphql.Null
  1751  	}
  1752  	ctx = graphql.WithFieldContext(ctx, fc)
  1753  	defer func() {
  1754  		if r := recover(); r != nil {
  1755  			ec.Error(ctx, ec.Recover(ctx, r))
  1756  			ret = graphql.Null
  1757  		}
  1758  	}()
  1759  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1760  		ctx = rctx // use context from middleware stack in children
  1761  		return obj.DeprecationReason(), nil
  1762  	})
  1763  	if err != nil {
  1764  		ec.Error(ctx, err)
  1765  		return graphql.Null
  1766  	}
  1767  	if resTmp == nil {
  1768  		return graphql.Null
  1769  	}
  1770  	res := resTmp.(*string)
  1771  	fc.Result = res
  1772  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1773  }
  1774  
  1775  func (ec *executionContext) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1776  	fc = &graphql.FieldContext{
  1777  		Object:     "__EnumValue",
  1778  		Field:      field,
  1779  		IsMethod:   true,
  1780  		IsResolver: false,
  1781  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1782  			return nil, errors.New("field of type String does not have child fields")
  1783  		},
  1784  	}
  1785  	return fc, nil
  1786  }
  1787  
  1788  func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1789  	fc, err := ec.fieldContext___Field_name(ctx, field)
  1790  	if err != nil {
  1791  		return graphql.Null
  1792  	}
  1793  	ctx = graphql.WithFieldContext(ctx, fc)
  1794  	defer func() {
  1795  		if r := recover(); r != nil {
  1796  			ec.Error(ctx, ec.Recover(ctx, r))
  1797  			ret = graphql.Null
  1798  		}
  1799  	}()
  1800  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1801  		ctx = rctx // use context from middleware stack in children
  1802  		return obj.Name, nil
  1803  	})
  1804  	if err != nil {
  1805  		ec.Error(ctx, err)
  1806  		return graphql.Null
  1807  	}
  1808  	if resTmp == nil {
  1809  		if !graphql.HasFieldError(ctx, fc) {
  1810  			ec.Errorf(ctx, "must not be null")
  1811  		}
  1812  		return graphql.Null
  1813  	}
  1814  	res := resTmp.(string)
  1815  	fc.Result = res
  1816  	return ec.marshalNString2string(ctx, field.Selections, res)
  1817  }
  1818  
  1819  func (ec *executionContext) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1820  	fc = &graphql.FieldContext{
  1821  		Object:     "__Field",
  1822  		Field:      field,
  1823  		IsMethod:   false,
  1824  		IsResolver: false,
  1825  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1826  			return nil, errors.New("field of type String does not have child fields")
  1827  		},
  1828  	}
  1829  	return fc, nil
  1830  }
  1831  
  1832  func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1833  	fc, err := ec.fieldContext___Field_description(ctx, field)
  1834  	if err != nil {
  1835  		return graphql.Null
  1836  	}
  1837  	ctx = graphql.WithFieldContext(ctx, fc)
  1838  	defer func() {
  1839  		if r := recover(); r != nil {
  1840  			ec.Error(ctx, ec.Recover(ctx, r))
  1841  			ret = graphql.Null
  1842  		}
  1843  	}()
  1844  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1845  		ctx = rctx // use context from middleware stack in children
  1846  		return obj.Description(), nil
  1847  	})
  1848  	if err != nil {
  1849  		ec.Error(ctx, err)
  1850  		return graphql.Null
  1851  	}
  1852  	if resTmp == nil {
  1853  		return graphql.Null
  1854  	}
  1855  	res := resTmp.(*string)
  1856  	fc.Result = res
  1857  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1858  }
  1859  
  1860  func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1861  	fc = &graphql.FieldContext{
  1862  		Object:     "__Field",
  1863  		Field:      field,
  1864  		IsMethod:   true,
  1865  		IsResolver: false,
  1866  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1867  			return nil, errors.New("field of type String does not have child fields")
  1868  		},
  1869  	}
  1870  	return fc, nil
  1871  }
  1872  
  1873  func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1874  	fc, err := ec.fieldContext___Field_args(ctx, field)
  1875  	if err != nil {
  1876  		return graphql.Null
  1877  	}
  1878  	ctx = graphql.WithFieldContext(ctx, fc)
  1879  	defer func() {
  1880  		if r := recover(); r != nil {
  1881  			ec.Error(ctx, ec.Recover(ctx, r))
  1882  			ret = graphql.Null
  1883  		}
  1884  	}()
  1885  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1886  		ctx = rctx // use context from middleware stack in children
  1887  		return obj.Args, nil
  1888  	})
  1889  	if err != nil {
  1890  		ec.Error(ctx, err)
  1891  		return graphql.Null
  1892  	}
  1893  	if resTmp == nil {
  1894  		if !graphql.HasFieldError(ctx, fc) {
  1895  			ec.Errorf(ctx, "must not be null")
  1896  		}
  1897  		return graphql.Null
  1898  	}
  1899  	res := resTmp.([]introspection.InputValue)
  1900  	fc.Result = res
  1901  	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  1902  }
  1903  
  1904  func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1905  	fc = &graphql.FieldContext{
  1906  		Object:     "__Field",
  1907  		Field:      field,
  1908  		IsMethod:   false,
  1909  		IsResolver: false,
  1910  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1911  			switch field.Name {
  1912  			case "name":
  1913  				return ec.fieldContext___InputValue_name(ctx, field)
  1914  			case "description":
  1915  				return ec.fieldContext___InputValue_description(ctx, field)
  1916  			case "type":
  1917  				return ec.fieldContext___InputValue_type(ctx, field)
  1918  			case "defaultValue":
  1919  				return ec.fieldContext___InputValue_defaultValue(ctx, field)
  1920  			}
  1921  			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
  1922  		},
  1923  	}
  1924  	return fc, nil
  1925  }
  1926  
  1927  func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1928  	fc, err := ec.fieldContext___Field_type(ctx, field)
  1929  	if err != nil {
  1930  		return graphql.Null
  1931  	}
  1932  	ctx = graphql.WithFieldContext(ctx, fc)
  1933  	defer func() {
  1934  		if r := recover(); r != nil {
  1935  			ec.Error(ctx, ec.Recover(ctx, r))
  1936  			ret = graphql.Null
  1937  		}
  1938  	}()
  1939  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1940  		ctx = rctx // use context from middleware stack in children
  1941  		return obj.Type, nil
  1942  	})
  1943  	if err != nil {
  1944  		ec.Error(ctx, err)
  1945  		return graphql.Null
  1946  	}
  1947  	if resTmp == nil {
  1948  		if !graphql.HasFieldError(ctx, fc) {
  1949  			ec.Errorf(ctx, "must not be null")
  1950  		}
  1951  		return graphql.Null
  1952  	}
  1953  	res := resTmp.(*introspection.Type)
  1954  	fc.Result = res
  1955  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1956  }
  1957  
  1958  func (ec *executionContext) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1959  	fc = &graphql.FieldContext{
  1960  		Object:     "__Field",
  1961  		Field:      field,
  1962  		IsMethod:   false,
  1963  		IsResolver: false,
  1964  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1965  			switch field.Name {
  1966  			case "kind":
  1967  				return ec.fieldContext___Type_kind(ctx, field)
  1968  			case "name":
  1969  				return ec.fieldContext___Type_name(ctx, field)
  1970  			case "description":
  1971  				return ec.fieldContext___Type_description(ctx, field)
  1972  			case "fields":
  1973  				return ec.fieldContext___Type_fields(ctx, field)
  1974  			case "interfaces":
  1975  				return ec.fieldContext___Type_interfaces(ctx, field)
  1976  			case "possibleTypes":
  1977  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  1978  			case "enumValues":
  1979  				return ec.fieldContext___Type_enumValues(ctx, field)
  1980  			case "inputFields":
  1981  				return ec.fieldContext___Type_inputFields(ctx, field)
  1982  			case "ofType":
  1983  				return ec.fieldContext___Type_ofType(ctx, field)
  1984  			case "specifiedByURL":
  1985  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  1986  			}
  1987  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  1988  		},
  1989  	}
  1990  	return fc, nil
  1991  }
  1992  
  1993  func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1994  	fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
  1995  	if err != nil {
  1996  		return graphql.Null
  1997  	}
  1998  	ctx = graphql.WithFieldContext(ctx, fc)
  1999  	defer func() {
  2000  		if r := recover(); r != nil {
  2001  			ec.Error(ctx, ec.Recover(ctx, r))
  2002  			ret = graphql.Null
  2003  		}
  2004  	}()
  2005  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2006  		ctx = rctx // use context from middleware stack in children
  2007  		return obj.IsDeprecated(), nil
  2008  	})
  2009  	if err != nil {
  2010  		ec.Error(ctx, err)
  2011  		return graphql.Null
  2012  	}
  2013  	if resTmp == nil {
  2014  		if !graphql.HasFieldError(ctx, fc) {
  2015  			ec.Errorf(ctx, "must not be null")
  2016  		}
  2017  		return graphql.Null
  2018  	}
  2019  	res := resTmp.(bool)
  2020  	fc.Result = res
  2021  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  2022  }
  2023  
  2024  func (ec *executionContext) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2025  	fc = &graphql.FieldContext{
  2026  		Object:     "__Field",
  2027  		Field:      field,
  2028  		IsMethod:   true,
  2029  		IsResolver: false,
  2030  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2031  			return nil, errors.New("field of type Boolean does not have child fields")
  2032  		},
  2033  	}
  2034  	return fc, nil
  2035  }
  2036  
  2037  func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  2038  	fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
  2039  	if err != nil {
  2040  		return graphql.Null
  2041  	}
  2042  	ctx = graphql.WithFieldContext(ctx, fc)
  2043  	defer func() {
  2044  		if r := recover(); r != nil {
  2045  			ec.Error(ctx, ec.Recover(ctx, r))
  2046  			ret = graphql.Null
  2047  		}
  2048  	}()
  2049  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2050  		ctx = rctx // use context from middleware stack in children
  2051  		return obj.DeprecationReason(), nil
  2052  	})
  2053  	if err != nil {
  2054  		ec.Error(ctx, err)
  2055  		return graphql.Null
  2056  	}
  2057  	if resTmp == nil {
  2058  		return graphql.Null
  2059  	}
  2060  	res := resTmp.(*string)
  2061  	fc.Result = res
  2062  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2063  }
  2064  
  2065  func (ec *executionContext) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2066  	fc = &graphql.FieldContext{
  2067  		Object:     "__Field",
  2068  		Field:      field,
  2069  		IsMethod:   true,
  2070  		IsResolver: false,
  2071  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2072  			return nil, errors.New("field of type String does not have child fields")
  2073  		},
  2074  	}
  2075  	return fc, nil
  2076  }
  2077  
  2078  func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  2079  	fc, err := ec.fieldContext___InputValue_name(ctx, field)
  2080  	if err != nil {
  2081  		return graphql.Null
  2082  	}
  2083  	ctx = graphql.WithFieldContext(ctx, fc)
  2084  	defer func() {
  2085  		if r := recover(); r != nil {
  2086  			ec.Error(ctx, ec.Recover(ctx, r))
  2087  			ret = graphql.Null
  2088  		}
  2089  	}()
  2090  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2091  		ctx = rctx // use context from middleware stack in children
  2092  		return obj.Name, nil
  2093  	})
  2094  	if err != nil {
  2095  		ec.Error(ctx, err)
  2096  		return graphql.Null
  2097  	}
  2098  	if resTmp == nil {
  2099  		if !graphql.HasFieldError(ctx, fc) {
  2100  			ec.Errorf(ctx, "must not be null")
  2101  		}
  2102  		return graphql.Null
  2103  	}
  2104  	res := resTmp.(string)
  2105  	fc.Result = res
  2106  	return ec.marshalNString2string(ctx, field.Selections, res)
  2107  }
  2108  
  2109  func (ec *executionContext) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2110  	fc = &graphql.FieldContext{
  2111  		Object:     "__InputValue",
  2112  		Field:      field,
  2113  		IsMethod:   false,
  2114  		IsResolver: false,
  2115  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2116  			return nil, errors.New("field of type String does not have child fields")
  2117  		},
  2118  	}
  2119  	return fc, nil
  2120  }
  2121  
  2122  func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  2123  	fc, err := ec.fieldContext___InputValue_description(ctx, field)
  2124  	if err != nil {
  2125  		return graphql.Null
  2126  	}
  2127  	ctx = graphql.WithFieldContext(ctx, fc)
  2128  	defer func() {
  2129  		if r := recover(); r != nil {
  2130  			ec.Error(ctx, ec.Recover(ctx, r))
  2131  			ret = graphql.Null
  2132  		}
  2133  	}()
  2134  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2135  		ctx = rctx // use context from middleware stack in children
  2136  		return obj.Description(), nil
  2137  	})
  2138  	if err != nil {
  2139  		ec.Error(ctx, err)
  2140  		return graphql.Null
  2141  	}
  2142  	if resTmp == nil {
  2143  		return graphql.Null
  2144  	}
  2145  	res := resTmp.(*string)
  2146  	fc.Result = res
  2147  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2148  }
  2149  
  2150  func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2151  	fc = &graphql.FieldContext{
  2152  		Object:     "__InputValue",
  2153  		Field:      field,
  2154  		IsMethod:   true,
  2155  		IsResolver: false,
  2156  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2157  			return nil, errors.New("field of type String does not have child fields")
  2158  		},
  2159  	}
  2160  	return fc, nil
  2161  }
  2162  
  2163  func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  2164  	fc, err := ec.fieldContext___InputValue_type(ctx, field)
  2165  	if err != nil {
  2166  		return graphql.Null
  2167  	}
  2168  	ctx = graphql.WithFieldContext(ctx, fc)
  2169  	defer func() {
  2170  		if r := recover(); r != nil {
  2171  			ec.Error(ctx, ec.Recover(ctx, r))
  2172  			ret = graphql.Null
  2173  		}
  2174  	}()
  2175  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2176  		ctx = rctx // use context from middleware stack in children
  2177  		return obj.Type, nil
  2178  	})
  2179  	if err != nil {
  2180  		ec.Error(ctx, err)
  2181  		return graphql.Null
  2182  	}
  2183  	if resTmp == nil {
  2184  		if !graphql.HasFieldError(ctx, fc) {
  2185  			ec.Errorf(ctx, "must not be null")
  2186  		}
  2187  		return graphql.Null
  2188  	}
  2189  	res := resTmp.(*introspection.Type)
  2190  	fc.Result = res
  2191  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  2192  }
  2193  
  2194  func (ec *executionContext) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2195  	fc = &graphql.FieldContext{
  2196  		Object:     "__InputValue",
  2197  		Field:      field,
  2198  		IsMethod:   false,
  2199  		IsResolver: false,
  2200  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2201  			switch field.Name {
  2202  			case "kind":
  2203  				return ec.fieldContext___Type_kind(ctx, field)
  2204  			case "name":
  2205  				return ec.fieldContext___Type_name(ctx, field)
  2206  			case "description":
  2207  				return ec.fieldContext___Type_description(ctx, field)
  2208  			case "fields":
  2209  				return ec.fieldContext___Type_fields(ctx, field)
  2210  			case "interfaces":
  2211  				return ec.fieldContext___Type_interfaces(ctx, field)
  2212  			case "possibleTypes":
  2213  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2214  			case "enumValues":
  2215  				return ec.fieldContext___Type_enumValues(ctx, field)
  2216  			case "inputFields":
  2217  				return ec.fieldContext___Type_inputFields(ctx, field)
  2218  			case "ofType":
  2219  				return ec.fieldContext___Type_ofType(ctx, field)
  2220  			case "specifiedByURL":
  2221  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2222  			}
  2223  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2224  		},
  2225  	}
  2226  	return fc, nil
  2227  }
  2228  
  2229  func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  2230  	fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
  2231  	if err != nil {
  2232  		return graphql.Null
  2233  	}
  2234  	ctx = graphql.WithFieldContext(ctx, fc)
  2235  	defer func() {
  2236  		if r := recover(); r != nil {
  2237  			ec.Error(ctx, ec.Recover(ctx, r))
  2238  			ret = graphql.Null
  2239  		}
  2240  	}()
  2241  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2242  		ctx = rctx // use context from middleware stack in children
  2243  		return obj.DefaultValue, nil
  2244  	})
  2245  	if err != nil {
  2246  		ec.Error(ctx, err)
  2247  		return graphql.Null
  2248  	}
  2249  	if resTmp == nil {
  2250  		return graphql.Null
  2251  	}
  2252  	res := resTmp.(*string)
  2253  	fc.Result = res
  2254  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2255  }
  2256  
  2257  func (ec *executionContext) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2258  	fc = &graphql.FieldContext{
  2259  		Object:     "__InputValue",
  2260  		Field:      field,
  2261  		IsMethod:   false,
  2262  		IsResolver: false,
  2263  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2264  			return nil, errors.New("field of type String does not have child fields")
  2265  		},
  2266  	}
  2267  	return fc, nil
  2268  }
  2269  
  2270  func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  2271  	fc, err := ec.fieldContext___Schema_description(ctx, field)
  2272  	if err != nil {
  2273  		return graphql.Null
  2274  	}
  2275  	ctx = graphql.WithFieldContext(ctx, fc)
  2276  	defer func() {
  2277  		if r := recover(); r != nil {
  2278  			ec.Error(ctx, ec.Recover(ctx, r))
  2279  			ret = graphql.Null
  2280  		}
  2281  	}()
  2282  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2283  		ctx = rctx // use context from middleware stack in children
  2284  		return obj.Description(), nil
  2285  	})
  2286  	if err != nil {
  2287  		ec.Error(ctx, err)
  2288  		return graphql.Null
  2289  	}
  2290  	if resTmp == nil {
  2291  		return graphql.Null
  2292  	}
  2293  	res := resTmp.(*string)
  2294  	fc.Result = res
  2295  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2296  }
  2297  
  2298  func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2299  	fc = &graphql.FieldContext{
  2300  		Object:     "__Schema",
  2301  		Field:      field,
  2302  		IsMethod:   true,
  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) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  2312  	fc, err := ec.fieldContext___Schema_types(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.Types(), 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.([]introspection.Type)
  2338  	fc.Result = res
  2339  	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  2340  }
  2341  
  2342  func (ec *executionContext) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2343  	fc = &graphql.FieldContext{
  2344  		Object:     "__Schema",
  2345  		Field:      field,
  2346  		IsMethod:   true,
  2347  		IsResolver: false,
  2348  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2349  			switch field.Name {
  2350  			case "kind":
  2351  				return ec.fieldContext___Type_kind(ctx, field)
  2352  			case "name":
  2353  				return ec.fieldContext___Type_name(ctx, field)
  2354  			case "description":
  2355  				return ec.fieldContext___Type_description(ctx, field)
  2356  			case "fields":
  2357  				return ec.fieldContext___Type_fields(ctx, field)
  2358  			case "interfaces":
  2359  				return ec.fieldContext___Type_interfaces(ctx, field)
  2360  			case "possibleTypes":
  2361  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2362  			case "enumValues":
  2363  				return ec.fieldContext___Type_enumValues(ctx, field)
  2364  			case "inputFields":
  2365  				return ec.fieldContext___Type_inputFields(ctx, field)
  2366  			case "ofType":
  2367  				return ec.fieldContext___Type_ofType(ctx, field)
  2368  			case "specifiedByURL":
  2369  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2370  			}
  2371  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2372  		},
  2373  	}
  2374  	return fc, nil
  2375  }
  2376  
  2377  func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  2378  	fc, err := ec.fieldContext___Schema_queryType(ctx, field)
  2379  	if err != nil {
  2380  		return graphql.Null
  2381  	}
  2382  	ctx = graphql.WithFieldContext(ctx, fc)
  2383  	defer func() {
  2384  		if r := recover(); r != nil {
  2385  			ec.Error(ctx, ec.Recover(ctx, r))
  2386  			ret = graphql.Null
  2387  		}
  2388  	}()
  2389  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2390  		ctx = rctx // use context from middleware stack in children
  2391  		return obj.QueryType(), nil
  2392  	})
  2393  	if err != nil {
  2394  		ec.Error(ctx, err)
  2395  		return graphql.Null
  2396  	}
  2397  	if resTmp == nil {
  2398  		if !graphql.HasFieldError(ctx, fc) {
  2399  			ec.Errorf(ctx, "must not be null")
  2400  		}
  2401  		return graphql.Null
  2402  	}
  2403  	res := resTmp.(*introspection.Type)
  2404  	fc.Result = res
  2405  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  2406  }
  2407  
  2408  func (ec *executionContext) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2409  	fc = &graphql.FieldContext{
  2410  		Object:     "__Schema",
  2411  		Field:      field,
  2412  		IsMethod:   true,
  2413  		IsResolver: false,
  2414  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2415  			switch field.Name {
  2416  			case "kind":
  2417  				return ec.fieldContext___Type_kind(ctx, field)
  2418  			case "name":
  2419  				return ec.fieldContext___Type_name(ctx, field)
  2420  			case "description":
  2421  				return ec.fieldContext___Type_description(ctx, field)
  2422  			case "fields":
  2423  				return ec.fieldContext___Type_fields(ctx, field)
  2424  			case "interfaces":
  2425  				return ec.fieldContext___Type_interfaces(ctx, field)
  2426  			case "possibleTypes":
  2427  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2428  			case "enumValues":
  2429  				return ec.fieldContext___Type_enumValues(ctx, field)
  2430  			case "inputFields":
  2431  				return ec.fieldContext___Type_inputFields(ctx, field)
  2432  			case "ofType":
  2433  				return ec.fieldContext___Type_ofType(ctx, field)
  2434  			case "specifiedByURL":
  2435  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2436  			}
  2437  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2438  		},
  2439  	}
  2440  	return fc, nil
  2441  }
  2442  
  2443  func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  2444  	fc, err := ec.fieldContext___Schema_mutationType(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.MutationType(), nil
  2458  	})
  2459  	if err != nil {
  2460  		ec.Error(ctx, err)
  2461  		return graphql.Null
  2462  	}
  2463  	if resTmp == nil {
  2464  		return graphql.Null
  2465  	}
  2466  	res := resTmp.(*introspection.Type)
  2467  	fc.Result = res
  2468  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  2469  }
  2470  
  2471  func (ec *executionContext) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2472  	fc = &graphql.FieldContext{
  2473  		Object:     "__Schema",
  2474  		Field:      field,
  2475  		IsMethod:   true,
  2476  		IsResolver: false,
  2477  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2478  			switch field.Name {
  2479  			case "kind":
  2480  				return ec.fieldContext___Type_kind(ctx, field)
  2481  			case "name":
  2482  				return ec.fieldContext___Type_name(ctx, field)
  2483  			case "description":
  2484  				return ec.fieldContext___Type_description(ctx, field)
  2485  			case "fields":
  2486  				return ec.fieldContext___Type_fields(ctx, field)
  2487  			case "interfaces":
  2488  				return ec.fieldContext___Type_interfaces(ctx, field)
  2489  			case "possibleTypes":
  2490  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2491  			case "enumValues":
  2492  				return ec.fieldContext___Type_enumValues(ctx, field)
  2493  			case "inputFields":
  2494  				return ec.fieldContext___Type_inputFields(ctx, field)
  2495  			case "ofType":
  2496  				return ec.fieldContext___Type_ofType(ctx, field)
  2497  			case "specifiedByURL":
  2498  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2499  			}
  2500  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2501  		},
  2502  	}
  2503  	return fc, nil
  2504  }
  2505  
  2506  func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  2507  	fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
  2508  	if err != nil {
  2509  		return graphql.Null
  2510  	}
  2511  	ctx = graphql.WithFieldContext(ctx, fc)
  2512  	defer func() {
  2513  		if r := recover(); r != nil {
  2514  			ec.Error(ctx, ec.Recover(ctx, r))
  2515  			ret = graphql.Null
  2516  		}
  2517  	}()
  2518  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2519  		ctx = rctx // use context from middleware stack in children
  2520  		return obj.SubscriptionType(), nil
  2521  	})
  2522  	if err != nil {
  2523  		ec.Error(ctx, err)
  2524  		return graphql.Null
  2525  	}
  2526  	if resTmp == nil {
  2527  		return graphql.Null
  2528  	}
  2529  	res := resTmp.(*introspection.Type)
  2530  	fc.Result = res
  2531  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  2532  }
  2533  
  2534  func (ec *executionContext) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2535  	fc = &graphql.FieldContext{
  2536  		Object:     "__Schema",
  2537  		Field:      field,
  2538  		IsMethod:   true,
  2539  		IsResolver: false,
  2540  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2541  			switch field.Name {
  2542  			case "kind":
  2543  				return ec.fieldContext___Type_kind(ctx, field)
  2544  			case "name":
  2545  				return ec.fieldContext___Type_name(ctx, field)
  2546  			case "description":
  2547  				return ec.fieldContext___Type_description(ctx, field)
  2548  			case "fields":
  2549  				return ec.fieldContext___Type_fields(ctx, field)
  2550  			case "interfaces":
  2551  				return ec.fieldContext___Type_interfaces(ctx, field)
  2552  			case "possibleTypes":
  2553  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2554  			case "enumValues":
  2555  				return ec.fieldContext___Type_enumValues(ctx, field)
  2556  			case "inputFields":
  2557  				return ec.fieldContext___Type_inputFields(ctx, field)
  2558  			case "ofType":
  2559  				return ec.fieldContext___Type_ofType(ctx, field)
  2560  			case "specifiedByURL":
  2561  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2562  			}
  2563  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2564  		},
  2565  	}
  2566  	return fc, nil
  2567  }
  2568  
  2569  func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  2570  	fc, err := ec.fieldContext___Schema_directives(ctx, field)
  2571  	if err != nil {
  2572  		return graphql.Null
  2573  	}
  2574  	ctx = graphql.WithFieldContext(ctx, fc)
  2575  	defer func() {
  2576  		if r := recover(); r != nil {
  2577  			ec.Error(ctx, ec.Recover(ctx, r))
  2578  			ret = graphql.Null
  2579  		}
  2580  	}()
  2581  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2582  		ctx = rctx // use context from middleware stack in children
  2583  		return obj.Directives(), nil
  2584  	})
  2585  	if err != nil {
  2586  		ec.Error(ctx, err)
  2587  		return graphql.Null
  2588  	}
  2589  	if resTmp == nil {
  2590  		if !graphql.HasFieldError(ctx, fc) {
  2591  			ec.Errorf(ctx, "must not be null")
  2592  		}
  2593  		return graphql.Null
  2594  	}
  2595  	res := resTmp.([]introspection.Directive)
  2596  	fc.Result = res
  2597  	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
  2598  }
  2599  
  2600  func (ec *executionContext) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2601  	fc = &graphql.FieldContext{
  2602  		Object:     "__Schema",
  2603  		Field:      field,
  2604  		IsMethod:   true,
  2605  		IsResolver: false,
  2606  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2607  			switch field.Name {
  2608  			case "name":
  2609  				return ec.fieldContext___Directive_name(ctx, field)
  2610  			case "description":
  2611  				return ec.fieldContext___Directive_description(ctx, field)
  2612  			case "locations":
  2613  				return ec.fieldContext___Directive_locations(ctx, field)
  2614  			case "args":
  2615  				return ec.fieldContext___Directive_args(ctx, field)
  2616  			case "isRepeatable":
  2617  				return ec.fieldContext___Directive_isRepeatable(ctx, field)
  2618  			}
  2619  			return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
  2620  		},
  2621  	}
  2622  	return fc, nil
  2623  }
  2624  
  2625  func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2626  	fc, err := ec.fieldContext___Type_kind(ctx, field)
  2627  	if err != nil {
  2628  		return graphql.Null
  2629  	}
  2630  	ctx = graphql.WithFieldContext(ctx, fc)
  2631  	defer func() {
  2632  		if r := recover(); r != nil {
  2633  			ec.Error(ctx, ec.Recover(ctx, r))
  2634  			ret = graphql.Null
  2635  		}
  2636  	}()
  2637  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2638  		ctx = rctx // use context from middleware stack in children
  2639  		return obj.Kind(), nil
  2640  	})
  2641  	if err != nil {
  2642  		ec.Error(ctx, err)
  2643  		return graphql.Null
  2644  	}
  2645  	if resTmp == nil {
  2646  		if !graphql.HasFieldError(ctx, fc) {
  2647  			ec.Errorf(ctx, "must not be null")
  2648  		}
  2649  		return graphql.Null
  2650  	}
  2651  	res := resTmp.(string)
  2652  	fc.Result = res
  2653  	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
  2654  }
  2655  
  2656  func (ec *executionContext) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2657  	fc = &graphql.FieldContext{
  2658  		Object:     "__Type",
  2659  		Field:      field,
  2660  		IsMethod:   true,
  2661  		IsResolver: false,
  2662  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2663  			return nil, errors.New("field of type __TypeKind does not have child fields")
  2664  		},
  2665  	}
  2666  	return fc, nil
  2667  }
  2668  
  2669  func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2670  	fc, err := ec.fieldContext___Type_name(ctx, field)
  2671  	if err != nil {
  2672  		return graphql.Null
  2673  	}
  2674  	ctx = graphql.WithFieldContext(ctx, fc)
  2675  	defer func() {
  2676  		if r := recover(); r != nil {
  2677  			ec.Error(ctx, ec.Recover(ctx, r))
  2678  			ret = graphql.Null
  2679  		}
  2680  	}()
  2681  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2682  		ctx = rctx // use context from middleware stack in children
  2683  		return obj.Name(), nil
  2684  	})
  2685  	if err != nil {
  2686  		ec.Error(ctx, err)
  2687  		return graphql.Null
  2688  	}
  2689  	if resTmp == nil {
  2690  		return graphql.Null
  2691  	}
  2692  	res := resTmp.(*string)
  2693  	fc.Result = res
  2694  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2695  }
  2696  
  2697  func (ec *executionContext) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2698  	fc = &graphql.FieldContext{
  2699  		Object:     "__Type",
  2700  		Field:      field,
  2701  		IsMethod:   true,
  2702  		IsResolver: false,
  2703  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2704  			return nil, errors.New("field of type String does not have child fields")
  2705  		},
  2706  	}
  2707  	return fc, nil
  2708  }
  2709  
  2710  func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2711  	fc, err := ec.fieldContext___Type_description(ctx, field)
  2712  	if err != nil {
  2713  		return graphql.Null
  2714  	}
  2715  	ctx = graphql.WithFieldContext(ctx, fc)
  2716  	defer func() {
  2717  		if r := recover(); r != nil {
  2718  			ec.Error(ctx, ec.Recover(ctx, r))
  2719  			ret = graphql.Null
  2720  		}
  2721  	}()
  2722  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2723  		ctx = rctx // use context from middleware stack in children
  2724  		return obj.Description(), nil
  2725  	})
  2726  	if err != nil {
  2727  		ec.Error(ctx, err)
  2728  		return graphql.Null
  2729  	}
  2730  	if resTmp == nil {
  2731  		return graphql.Null
  2732  	}
  2733  	res := resTmp.(*string)
  2734  	fc.Result = res
  2735  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2736  }
  2737  
  2738  func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2739  	fc = &graphql.FieldContext{
  2740  		Object:     "__Type",
  2741  		Field:      field,
  2742  		IsMethod:   true,
  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) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2752  	fc, err := ec.fieldContext___Type_fields(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.Fields(fc.Args["includeDeprecated"].(bool)), nil
  2766  	})
  2767  	if err != nil {
  2768  		ec.Error(ctx, err)
  2769  		return graphql.Null
  2770  	}
  2771  	if resTmp == nil {
  2772  		return graphql.Null
  2773  	}
  2774  	res := resTmp.([]introspection.Field)
  2775  	fc.Result = res
  2776  	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
  2777  }
  2778  
  2779  func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2780  	fc = &graphql.FieldContext{
  2781  		Object:     "__Type",
  2782  		Field:      field,
  2783  		IsMethod:   true,
  2784  		IsResolver: false,
  2785  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2786  			switch field.Name {
  2787  			case "name":
  2788  				return ec.fieldContext___Field_name(ctx, field)
  2789  			case "description":
  2790  				return ec.fieldContext___Field_description(ctx, field)
  2791  			case "args":
  2792  				return ec.fieldContext___Field_args(ctx, field)
  2793  			case "type":
  2794  				return ec.fieldContext___Field_type(ctx, field)
  2795  			case "isDeprecated":
  2796  				return ec.fieldContext___Field_isDeprecated(ctx, field)
  2797  			case "deprecationReason":
  2798  				return ec.fieldContext___Field_deprecationReason(ctx, field)
  2799  			}
  2800  			return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
  2801  		},
  2802  	}
  2803  	defer func() {
  2804  		if r := recover(); r != nil {
  2805  			err = ec.Recover(ctx, r)
  2806  			ec.Error(ctx, err)
  2807  		}
  2808  	}()
  2809  	ctx = graphql.WithFieldContext(ctx, fc)
  2810  	if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2811  		ec.Error(ctx, err)
  2812  		return fc, err
  2813  	}
  2814  	return fc, nil
  2815  }
  2816  
  2817  func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2818  	fc, err := ec.fieldContext___Type_interfaces(ctx, field)
  2819  	if err != nil {
  2820  		return graphql.Null
  2821  	}
  2822  	ctx = graphql.WithFieldContext(ctx, fc)
  2823  	defer func() {
  2824  		if r := recover(); r != nil {
  2825  			ec.Error(ctx, ec.Recover(ctx, r))
  2826  			ret = graphql.Null
  2827  		}
  2828  	}()
  2829  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2830  		ctx = rctx // use context from middleware stack in children
  2831  		return obj.Interfaces(), nil
  2832  	})
  2833  	if err != nil {
  2834  		ec.Error(ctx, err)
  2835  		return graphql.Null
  2836  	}
  2837  	if resTmp == nil {
  2838  		return graphql.Null
  2839  	}
  2840  	res := resTmp.([]introspection.Type)
  2841  	fc.Result = res
  2842  	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  2843  }
  2844  
  2845  func (ec *executionContext) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2846  	fc = &graphql.FieldContext{
  2847  		Object:     "__Type",
  2848  		Field:      field,
  2849  		IsMethod:   true,
  2850  		IsResolver: false,
  2851  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2852  			switch field.Name {
  2853  			case "kind":
  2854  				return ec.fieldContext___Type_kind(ctx, field)
  2855  			case "name":
  2856  				return ec.fieldContext___Type_name(ctx, field)
  2857  			case "description":
  2858  				return ec.fieldContext___Type_description(ctx, field)
  2859  			case "fields":
  2860  				return ec.fieldContext___Type_fields(ctx, field)
  2861  			case "interfaces":
  2862  				return ec.fieldContext___Type_interfaces(ctx, field)
  2863  			case "possibleTypes":
  2864  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2865  			case "enumValues":
  2866  				return ec.fieldContext___Type_enumValues(ctx, field)
  2867  			case "inputFields":
  2868  				return ec.fieldContext___Type_inputFields(ctx, field)
  2869  			case "ofType":
  2870  				return ec.fieldContext___Type_ofType(ctx, field)
  2871  			case "specifiedByURL":
  2872  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2873  			}
  2874  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2875  		},
  2876  	}
  2877  	return fc, nil
  2878  }
  2879  
  2880  func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2881  	fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
  2882  	if err != nil {
  2883  		return graphql.Null
  2884  	}
  2885  	ctx = graphql.WithFieldContext(ctx, fc)
  2886  	defer func() {
  2887  		if r := recover(); r != nil {
  2888  			ec.Error(ctx, ec.Recover(ctx, r))
  2889  			ret = graphql.Null
  2890  		}
  2891  	}()
  2892  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2893  		ctx = rctx // use context from middleware stack in children
  2894  		return obj.PossibleTypes(), nil
  2895  	})
  2896  	if err != nil {
  2897  		ec.Error(ctx, err)
  2898  		return graphql.Null
  2899  	}
  2900  	if resTmp == nil {
  2901  		return graphql.Null
  2902  	}
  2903  	res := resTmp.([]introspection.Type)
  2904  	fc.Result = res
  2905  	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  2906  }
  2907  
  2908  func (ec *executionContext) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2909  	fc = &graphql.FieldContext{
  2910  		Object:     "__Type",
  2911  		Field:      field,
  2912  		IsMethod:   true,
  2913  		IsResolver: false,
  2914  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2915  			switch field.Name {
  2916  			case "kind":
  2917  				return ec.fieldContext___Type_kind(ctx, field)
  2918  			case "name":
  2919  				return ec.fieldContext___Type_name(ctx, field)
  2920  			case "description":
  2921  				return ec.fieldContext___Type_description(ctx, field)
  2922  			case "fields":
  2923  				return ec.fieldContext___Type_fields(ctx, field)
  2924  			case "interfaces":
  2925  				return ec.fieldContext___Type_interfaces(ctx, field)
  2926  			case "possibleTypes":
  2927  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  2928  			case "enumValues":
  2929  				return ec.fieldContext___Type_enumValues(ctx, field)
  2930  			case "inputFields":
  2931  				return ec.fieldContext___Type_inputFields(ctx, field)
  2932  			case "ofType":
  2933  				return ec.fieldContext___Type_ofType(ctx, field)
  2934  			case "specifiedByURL":
  2935  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  2936  			}
  2937  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  2938  		},
  2939  	}
  2940  	return fc, nil
  2941  }
  2942  
  2943  func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  2944  	fc, err := ec.fieldContext___Type_enumValues(ctx, field)
  2945  	if err != nil {
  2946  		return graphql.Null
  2947  	}
  2948  	ctx = graphql.WithFieldContext(ctx, fc)
  2949  	defer func() {
  2950  		if r := recover(); r != nil {
  2951  			ec.Error(ctx, ec.Recover(ctx, r))
  2952  			ret = graphql.Null
  2953  		}
  2954  	}()
  2955  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  2956  		ctx = rctx // use context from middleware stack in children
  2957  		return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
  2958  	})
  2959  	if err != nil {
  2960  		ec.Error(ctx, err)
  2961  		return graphql.Null
  2962  	}
  2963  	if resTmp == nil {
  2964  		return graphql.Null
  2965  	}
  2966  	res := resTmp.([]introspection.EnumValue)
  2967  	fc.Result = res
  2968  	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
  2969  }
  2970  
  2971  func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2972  	fc = &graphql.FieldContext{
  2973  		Object:     "__Type",
  2974  		Field:      field,
  2975  		IsMethod:   true,
  2976  		IsResolver: false,
  2977  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2978  			switch field.Name {
  2979  			case "name":
  2980  				return ec.fieldContext___EnumValue_name(ctx, field)
  2981  			case "description":
  2982  				return ec.fieldContext___EnumValue_description(ctx, field)
  2983  			case "isDeprecated":
  2984  				return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
  2985  			case "deprecationReason":
  2986  				return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
  2987  			}
  2988  			return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
  2989  		},
  2990  	}
  2991  	defer func() {
  2992  		if r := recover(); r != nil {
  2993  			err = ec.Recover(ctx, r)
  2994  			ec.Error(ctx, err)
  2995  		}
  2996  	}()
  2997  	ctx = graphql.WithFieldContext(ctx, fc)
  2998  	if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2999  		ec.Error(ctx, err)
  3000  		return fc, err
  3001  	}
  3002  	return fc, nil
  3003  }
  3004  
  3005  func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  3006  	fc, err := ec.fieldContext___Type_inputFields(ctx, field)
  3007  	if err != nil {
  3008  		return graphql.Null
  3009  	}
  3010  	ctx = graphql.WithFieldContext(ctx, fc)
  3011  	defer func() {
  3012  		if r := recover(); r != nil {
  3013  			ec.Error(ctx, ec.Recover(ctx, r))
  3014  			ret = graphql.Null
  3015  		}
  3016  	}()
  3017  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3018  		ctx = rctx // use context from middleware stack in children
  3019  		return obj.InputFields(), nil
  3020  	})
  3021  	if err != nil {
  3022  		ec.Error(ctx, err)
  3023  		return graphql.Null
  3024  	}
  3025  	if resTmp == nil {
  3026  		return graphql.Null
  3027  	}
  3028  	res := resTmp.([]introspection.InputValue)
  3029  	fc.Result = res
  3030  	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  3031  }
  3032  
  3033  func (ec *executionContext) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3034  	fc = &graphql.FieldContext{
  3035  		Object:     "__Type",
  3036  		Field:      field,
  3037  		IsMethod:   true,
  3038  		IsResolver: false,
  3039  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3040  			switch field.Name {
  3041  			case "name":
  3042  				return ec.fieldContext___InputValue_name(ctx, field)
  3043  			case "description":
  3044  				return ec.fieldContext___InputValue_description(ctx, field)
  3045  			case "type":
  3046  				return ec.fieldContext___InputValue_type(ctx, field)
  3047  			case "defaultValue":
  3048  				return ec.fieldContext___InputValue_defaultValue(ctx, field)
  3049  			}
  3050  			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
  3051  		},
  3052  	}
  3053  	return fc, nil
  3054  }
  3055  
  3056  func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  3057  	fc, err := ec.fieldContext___Type_ofType(ctx, field)
  3058  	if err != nil {
  3059  		return graphql.Null
  3060  	}
  3061  	ctx = graphql.WithFieldContext(ctx, fc)
  3062  	defer func() {
  3063  		if r := recover(); r != nil {
  3064  			ec.Error(ctx, ec.Recover(ctx, r))
  3065  			ret = graphql.Null
  3066  		}
  3067  	}()
  3068  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3069  		ctx = rctx // use context from middleware stack in children
  3070  		return obj.OfType(), nil
  3071  	})
  3072  	if err != nil {
  3073  		ec.Error(ctx, err)
  3074  		return graphql.Null
  3075  	}
  3076  	if resTmp == nil {
  3077  		return graphql.Null
  3078  	}
  3079  	res := resTmp.(*introspection.Type)
  3080  	fc.Result = res
  3081  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  3082  }
  3083  
  3084  func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3085  	fc = &graphql.FieldContext{
  3086  		Object:     "__Type",
  3087  		Field:      field,
  3088  		IsMethod:   true,
  3089  		IsResolver: false,
  3090  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3091  			switch field.Name {
  3092  			case "kind":
  3093  				return ec.fieldContext___Type_kind(ctx, field)
  3094  			case "name":
  3095  				return ec.fieldContext___Type_name(ctx, field)
  3096  			case "description":
  3097  				return ec.fieldContext___Type_description(ctx, field)
  3098  			case "fields":
  3099  				return ec.fieldContext___Type_fields(ctx, field)
  3100  			case "interfaces":
  3101  				return ec.fieldContext___Type_interfaces(ctx, field)
  3102  			case "possibleTypes":
  3103  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  3104  			case "enumValues":
  3105  				return ec.fieldContext___Type_enumValues(ctx, field)
  3106  			case "inputFields":
  3107  				return ec.fieldContext___Type_inputFields(ctx, field)
  3108  			case "ofType":
  3109  				return ec.fieldContext___Type_ofType(ctx, field)
  3110  			case "specifiedByURL":
  3111  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  3112  			}
  3113  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  3114  		},
  3115  	}
  3116  	return fc, nil
  3117  }
  3118  
  3119  func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  3120  	fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
  3121  	if err != nil {
  3122  		return graphql.Null
  3123  	}
  3124  	ctx = graphql.WithFieldContext(ctx, fc)
  3125  	defer func() {
  3126  		if r := recover(); r != nil {
  3127  			ec.Error(ctx, ec.Recover(ctx, r))
  3128  			ret = graphql.Null
  3129  		}
  3130  	}()
  3131  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  3132  		ctx = rctx // use context from middleware stack in children
  3133  		return obj.SpecifiedByURL(), nil
  3134  	})
  3135  	if err != nil {
  3136  		ec.Error(ctx, err)
  3137  		return graphql.Null
  3138  	}
  3139  	if resTmp == nil {
  3140  		return graphql.Null
  3141  	}
  3142  	res := resTmp.(*string)
  3143  	fc.Result = res
  3144  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  3145  }
  3146  
  3147  func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3148  	fc = &graphql.FieldContext{
  3149  		Object:     "__Type",
  3150  		Field:      field,
  3151  		IsMethod:   true,
  3152  		IsResolver: false,
  3153  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3154  			return nil, errors.New("field of type String does not have child fields")
  3155  		},
  3156  	}
  3157  	return fc, nil
  3158  }
  3159  
  3160  // endregion **************************** field.gotpl *****************************
  3161  
  3162  // region    **************************** input.gotpl *****************************
  3163  
  3164  func (ec *executionContext) unmarshalInputDateFilter(ctx context.Context, obj interface{}) (models.DateFilter, error) {
  3165  	var it models.DateFilter
  3166  	asMap := map[string]interface{}{}
  3167  	for k, v := range obj.(map[string]interface{}) {
  3168  		asMap[k] = v
  3169  	}
  3170  
  3171  	if _, present := asMap["timezone"]; !present {
  3172  		asMap["timezone"] = "UTC"
  3173  	}
  3174  	if _, present := asMap["op"]; !present {
  3175  		asMap["op"] = "EQ"
  3176  	}
  3177  
  3178  	fieldsInOrder := [...]string{"value", "timezone", "op"}
  3179  	for _, k := range fieldsInOrder {
  3180  		v, ok := asMap[k]
  3181  		if !ok {
  3182  			continue
  3183  		}
  3184  		switch k {
  3185  		case "value":
  3186  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
  3187  			data, err := ec.unmarshalNString2string(ctx, v)
  3188  			if err != nil {
  3189  				return it, err
  3190  			}
  3191  			it.Value = data
  3192  		case "timezone":
  3193  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("timezone"))
  3194  			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
  3195  			if err != nil {
  3196  				return it, err
  3197  			}
  3198  			it.Timezone = data
  3199  		case "op":
  3200  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("op"))
  3201  			data, err := ec.unmarshalODATE_FILTER_OP2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐDateFilterOp(ctx, v)
  3202  			if err != nil {
  3203  				return it, err
  3204  			}
  3205  			it.Op = data
  3206  		}
  3207  	}
  3208  
  3209  	return it, nil
  3210  }
  3211  
  3212  func (ec *executionContext) unmarshalInputListCoercion(ctx context.Context, obj interface{}) (models.ListCoercion, error) {
  3213  	var it models.ListCoercion
  3214  	asMap := map[string]interface{}{}
  3215  	for k, v := range obj.(map[string]interface{}) {
  3216  		asMap[k] = v
  3217  	}
  3218  
  3219  	fieldsInOrder := [...]string{"enumVal", "strVal", "intVal", "scalarVal"}
  3220  	for _, k := range fieldsInOrder {
  3221  		v, ok := asMap[k]
  3222  		if !ok {
  3223  			continue
  3224  		}
  3225  		switch k {
  3226  		case "enumVal":
  3227  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enumVal"))
  3228  			data, err := ec.unmarshalOErrorType2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx, v)
  3229  			if err != nil {
  3230  				return it, err
  3231  			}
  3232  			it.EnumVal = data
  3233  		case "strVal":
  3234  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("strVal"))
  3235  			data, err := ec.unmarshalOString2ᚕᚖstring(ctx, v)
  3236  			if err != nil {
  3237  				return it, err
  3238  			}
  3239  			it.StrVal = data
  3240  		case "intVal":
  3241  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("intVal"))
  3242  			data, err := ec.unmarshalOInt2ᚕᚖint(ctx, v)
  3243  			if err != nil {
  3244  				return it, err
  3245  			}
  3246  			it.IntVal = data
  3247  		case "scalarVal":
  3248  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scalarVal"))
  3249  			data, err := ec.unmarshalOMap2ᚕmap(ctx, v)
  3250  			if err != nil {
  3251  				return it, err
  3252  			}
  3253  			it.ScalarVal = data
  3254  		}
  3255  	}
  3256  
  3257  	return it, nil
  3258  }
  3259  
  3260  // endregion **************************** input.gotpl *****************************
  3261  
  3262  // region    ************************** interface.gotpl ***************************
  3263  
  3264  // endregion ************************** interface.gotpl ***************************
  3265  
  3266  // region    **************************** object.gotpl ****************************
  3267  
  3268  var elementImplementors = []string{"Element"}
  3269  
  3270  func (ec *executionContext) _Element(ctx context.Context, sel ast.SelectionSet, obj *models.Element) graphql.Marshaler {
  3271  	fields := graphql.CollectFields(ec.OperationContext, sel, elementImplementors)
  3272  
  3273  	out := graphql.NewFieldSet(fields)
  3274  	deferred := make(map[string]*graphql.FieldSet)
  3275  	for i, field := range fields {
  3276  		switch field.Name {
  3277  		case "__typename":
  3278  			out.Values[i] = graphql.MarshalString("Element")
  3279  		case "child":
  3280  			field := field
  3281  
  3282  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3283  				defer func() {
  3284  					if r := recover(); r != nil {
  3285  						ec.Error(ctx, ec.Recover(ctx, r))
  3286  					}
  3287  				}()
  3288  				res = ec._Element_child(ctx, field, obj)
  3289  				if res == graphql.Null {
  3290  					atomic.AddUint32(&fs.Invalids, 1)
  3291  				}
  3292  				return res
  3293  			}
  3294  
  3295  			if field.Deferrable != nil {
  3296  				dfs, ok := deferred[field.Deferrable.Label]
  3297  				di := 0
  3298  				if ok {
  3299  					dfs.AddField(field)
  3300  					di = len(dfs.Values) - 1
  3301  				} else {
  3302  					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
  3303  					deferred[field.Deferrable.Label] = dfs
  3304  				}
  3305  				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
  3306  					return innerFunc(ctx, dfs)
  3307  				})
  3308  
  3309  				// don't run the out.Concurrently() call below
  3310  				out.Values[i] = graphql.Null
  3311  				continue
  3312  			}
  3313  
  3314  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3315  		case "error":
  3316  			field := field
  3317  
  3318  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3319  				defer func() {
  3320  					if r := recover(); r != nil {
  3321  						ec.Error(ctx, ec.Recover(ctx, r))
  3322  					}
  3323  				}()
  3324  				res = ec._Element_error(ctx, field, obj)
  3325  				if res == graphql.Null {
  3326  					atomic.AddUint32(&fs.Invalids, 1)
  3327  				}
  3328  				return res
  3329  			}
  3330  
  3331  			if field.Deferrable != nil {
  3332  				dfs, ok := deferred[field.Deferrable.Label]
  3333  				di := 0
  3334  				if ok {
  3335  					dfs.AddField(field)
  3336  					di = len(dfs.Values) - 1
  3337  				} else {
  3338  					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
  3339  					deferred[field.Deferrable.Label] = dfs
  3340  				}
  3341  				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
  3342  					return innerFunc(ctx, dfs)
  3343  				})
  3344  
  3345  				// don't run the out.Concurrently() call below
  3346  				out.Values[i] = graphql.Null
  3347  				continue
  3348  			}
  3349  
  3350  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3351  		case "mismatched":
  3352  			field := field
  3353  
  3354  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3355  				defer func() {
  3356  					if r := recover(); r != nil {
  3357  						ec.Error(ctx, ec.Recover(ctx, r))
  3358  					}
  3359  				}()
  3360  				res = ec._Element_mismatched(ctx, field, obj)
  3361  				return res
  3362  			}
  3363  
  3364  			if field.Deferrable != nil {
  3365  				dfs, ok := deferred[field.Deferrable.Label]
  3366  				di := 0
  3367  				if ok {
  3368  					dfs.AddField(field)
  3369  					di = len(dfs.Values) - 1
  3370  				} else {
  3371  					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
  3372  					deferred[field.Deferrable.Label] = dfs
  3373  				}
  3374  				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
  3375  					return innerFunc(ctx, dfs)
  3376  				})
  3377  
  3378  				// don't run the out.Concurrently() call below
  3379  				out.Values[i] = graphql.Null
  3380  				continue
  3381  			}
  3382  
  3383  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3384  		default:
  3385  			panic("unknown field " + strconv.Quote(field.Name))
  3386  		}
  3387  	}
  3388  	out.Dispatch(ctx)
  3389  	if out.Invalids > 0 {
  3390  		return graphql.Null
  3391  	}
  3392  
  3393  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3394  
  3395  	for label, dfs := range deferred {
  3396  		ec.processDeferredGroup(graphql.DeferredGroup{
  3397  			Label:    label,
  3398  			Path:     graphql.GetPath(ctx),
  3399  			FieldSet: dfs,
  3400  			Context:  ctx,
  3401  		})
  3402  	}
  3403  
  3404  	return out
  3405  }
  3406  
  3407  var queryImplementors = []string{"Query"}
  3408  
  3409  func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  3410  	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
  3411  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  3412  		Object: "Query",
  3413  	})
  3414  
  3415  	out := graphql.NewFieldSet(fields)
  3416  	deferred := make(map[string]*graphql.FieldSet)
  3417  	for i, field := range fields {
  3418  		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
  3419  			Object: field.Name,
  3420  			Field:  field,
  3421  		})
  3422  
  3423  		switch field.Name {
  3424  		case "__typename":
  3425  			out.Values[i] = graphql.MarshalString("Query")
  3426  		case "path":
  3427  			field := field
  3428  
  3429  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3430  				defer func() {
  3431  					if r := recover(); r != nil {
  3432  						ec.Error(ctx, ec.Recover(ctx, r))
  3433  					}
  3434  				}()
  3435  				res = ec._Query_path(ctx, field)
  3436  				return res
  3437  			}
  3438  
  3439  			rrm := func(ctx context.Context) graphql.Marshaler {
  3440  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3441  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3442  			}
  3443  
  3444  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3445  		case "date":
  3446  			field := field
  3447  
  3448  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3449  				defer func() {
  3450  					if r := recover(); r != nil {
  3451  						ec.Error(ctx, ec.Recover(ctx, r))
  3452  					}
  3453  				}()
  3454  				res = ec._Query_date(ctx, field)
  3455  				if res == graphql.Null {
  3456  					atomic.AddUint32(&fs.Invalids, 1)
  3457  				}
  3458  				return res
  3459  			}
  3460  
  3461  			rrm := func(ctx context.Context) graphql.Marshaler {
  3462  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3463  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3464  			}
  3465  
  3466  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3467  		case "viewer":
  3468  			field := field
  3469  
  3470  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3471  				defer func() {
  3472  					if r := recover(); r != nil {
  3473  						ec.Error(ctx, ec.Recover(ctx, r))
  3474  					}
  3475  				}()
  3476  				res = ec._Query_viewer(ctx, field)
  3477  				return res
  3478  			}
  3479  
  3480  			rrm := func(ctx context.Context) graphql.Marshaler {
  3481  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3482  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3483  			}
  3484  
  3485  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3486  		case "jsonEncoding":
  3487  			field := field
  3488  
  3489  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3490  				defer func() {
  3491  					if r := recover(); r != nil {
  3492  						ec.Error(ctx, ec.Recover(ctx, r))
  3493  					}
  3494  				}()
  3495  				res = ec._Query_jsonEncoding(ctx, field)
  3496  				if res == graphql.Null {
  3497  					atomic.AddUint32(&fs.Invalids, 1)
  3498  				}
  3499  				return res
  3500  			}
  3501  
  3502  			rrm := func(ctx context.Context) graphql.Marshaler {
  3503  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3504  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3505  			}
  3506  
  3507  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3508  		case "error":
  3509  			field := field
  3510  
  3511  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3512  				defer func() {
  3513  					if r := recover(); r != nil {
  3514  						ec.Error(ctx, ec.Recover(ctx, r))
  3515  					}
  3516  				}()
  3517  				res = ec._Query_error(ctx, field)
  3518  				if res == graphql.Null {
  3519  					atomic.AddUint32(&fs.Invalids, 1)
  3520  				}
  3521  				return res
  3522  			}
  3523  
  3524  			rrm := func(ctx context.Context) graphql.Marshaler {
  3525  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3526  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3527  			}
  3528  
  3529  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3530  		case "complexity":
  3531  			field := field
  3532  
  3533  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3534  				defer func() {
  3535  					if r := recover(); r != nil {
  3536  						ec.Error(ctx, ec.Recover(ctx, r))
  3537  					}
  3538  				}()
  3539  				res = ec._Query_complexity(ctx, field)
  3540  				if res == graphql.Null {
  3541  					atomic.AddUint32(&fs.Invalids, 1)
  3542  				}
  3543  				return res
  3544  			}
  3545  
  3546  			rrm := func(ctx context.Context) graphql.Marshaler {
  3547  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3548  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3549  			}
  3550  
  3551  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3552  		case "coercion":
  3553  			field := field
  3554  
  3555  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3556  				defer func() {
  3557  					if r := recover(); r != nil {
  3558  						ec.Error(ctx, ec.Recover(ctx, r))
  3559  					}
  3560  				}()
  3561  				res = ec._Query_coercion(ctx, field)
  3562  				if res == graphql.Null {
  3563  					atomic.AddUint32(&fs.Invalids, 1)
  3564  				}
  3565  				return res
  3566  			}
  3567  
  3568  			rrm := func(ctx context.Context) graphql.Marshaler {
  3569  				return ec.OperationContext.RootResolverMiddleware(ctx,
  3570  					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3571  			}
  3572  
  3573  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
  3574  		case "__type":
  3575  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  3576  				return ec._Query___type(ctx, field)
  3577  			})
  3578  		case "__schema":
  3579  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  3580  				return ec._Query___schema(ctx, field)
  3581  			})
  3582  		default:
  3583  			panic("unknown field " + strconv.Quote(field.Name))
  3584  		}
  3585  	}
  3586  	out.Dispatch(ctx)
  3587  	if out.Invalids > 0 {
  3588  		return graphql.Null
  3589  	}
  3590  
  3591  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3592  
  3593  	for label, dfs := range deferred {
  3594  		ec.processDeferredGroup(graphql.DeferredGroup{
  3595  			Label:    label,
  3596  			Path:     graphql.GetPath(ctx),
  3597  			FieldSet: dfs,
  3598  			Context:  ctx,
  3599  		})
  3600  	}
  3601  
  3602  	return out
  3603  }
  3604  
  3605  var remoteModelWithOmitemptyImplementors = []string{"RemoteModelWithOmitempty"}
  3606  
  3607  func (ec *executionContext) _RemoteModelWithOmitempty(ctx context.Context, sel ast.SelectionSet, obj *testomitempty.RemoteModelWithOmitempty) graphql.Marshaler {
  3608  	fields := graphql.CollectFields(ec.OperationContext, sel, remoteModelWithOmitemptyImplementors)
  3609  
  3610  	out := graphql.NewFieldSet(fields)
  3611  	deferred := make(map[string]*graphql.FieldSet)
  3612  	for i, field := range fields {
  3613  		switch field.Name {
  3614  		case "__typename":
  3615  			out.Values[i] = graphql.MarshalString("RemoteModelWithOmitempty")
  3616  		case "newDesc":
  3617  			out.Values[i] = ec._RemoteModelWithOmitempty_newDesc(ctx, field, obj)
  3618  		default:
  3619  			panic("unknown field " + strconv.Quote(field.Name))
  3620  		}
  3621  	}
  3622  	out.Dispatch(ctx)
  3623  	if out.Invalids > 0 {
  3624  		return graphql.Null
  3625  	}
  3626  
  3627  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3628  
  3629  	for label, dfs := range deferred {
  3630  		ec.processDeferredGroup(graphql.DeferredGroup{
  3631  			Label:    label,
  3632  			Path:     graphql.GetPath(ctx),
  3633  			FieldSet: dfs,
  3634  			Context:  ctx,
  3635  		})
  3636  	}
  3637  
  3638  	return out
  3639  }
  3640  
  3641  var userImplementors = []string{"User"}
  3642  
  3643  func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *remote_api.User) graphql.Marshaler {
  3644  	fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)
  3645  
  3646  	out := graphql.NewFieldSet(fields)
  3647  	deferred := make(map[string]*graphql.FieldSet)
  3648  	for i, field := range fields {
  3649  		switch field.Name {
  3650  		case "__typename":
  3651  			out.Values[i] = graphql.MarshalString("User")
  3652  		case "name":
  3653  			out.Values[i] = ec._User_name(ctx, field, obj)
  3654  			if out.Values[i] == graphql.Null {
  3655  				atomic.AddUint32(&out.Invalids, 1)
  3656  			}
  3657  		case "likes":
  3658  			field := field
  3659  
  3660  			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
  3661  				defer func() {
  3662  					if r := recover(); r != nil {
  3663  						ec.Error(ctx, ec.Recover(ctx, r))
  3664  					}
  3665  				}()
  3666  				res = ec._User_likes(ctx, field, obj)
  3667  				if res == graphql.Null {
  3668  					atomic.AddUint32(&fs.Invalids, 1)
  3669  				}
  3670  				return res
  3671  			}
  3672  
  3673  			if field.Deferrable != nil {
  3674  				dfs, ok := deferred[field.Deferrable.Label]
  3675  				di := 0
  3676  				if ok {
  3677  					dfs.AddField(field)
  3678  					di = len(dfs.Values) - 1
  3679  				} else {
  3680  					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
  3681  					deferred[field.Deferrable.Label] = dfs
  3682  				}
  3683  				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
  3684  					return innerFunc(ctx, dfs)
  3685  				})
  3686  
  3687  				// don't run the out.Concurrently() call below
  3688  				out.Values[i] = graphql.Null
  3689  				continue
  3690  			}
  3691  
  3692  			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
  3693  		case "phoneNumber":
  3694  			out.Values[i] = ec._User_phoneNumber(ctx, field, obj)
  3695  		case "query":
  3696  			out.Values[i] = ec._User_query(ctx, field, obj)
  3697  			if out.Values[i] == graphql.Null {
  3698  				atomic.AddUint32(&out.Invalids, 1)
  3699  			}
  3700  		default:
  3701  			panic("unknown field " + strconv.Quote(field.Name))
  3702  		}
  3703  	}
  3704  	out.Dispatch(ctx)
  3705  	if out.Invalids > 0 {
  3706  		return graphql.Null
  3707  	}
  3708  
  3709  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3710  
  3711  	for label, dfs := range deferred {
  3712  		ec.processDeferredGroup(graphql.DeferredGroup{
  3713  			Label:    label,
  3714  			Path:     graphql.GetPath(ctx),
  3715  			FieldSet: dfs,
  3716  			Context:  ctx,
  3717  		})
  3718  	}
  3719  
  3720  	return out
  3721  }
  3722  
  3723  var viewerImplementors = []string{"Viewer"}
  3724  
  3725  func (ec *executionContext) _Viewer(ctx context.Context, sel ast.SelectionSet, obj *models.Viewer) graphql.Marshaler {
  3726  	fields := graphql.CollectFields(ec.OperationContext, sel, viewerImplementors)
  3727  
  3728  	out := graphql.NewFieldSet(fields)
  3729  	deferred := make(map[string]*graphql.FieldSet)
  3730  	for i, field := range fields {
  3731  		switch field.Name {
  3732  		case "__typename":
  3733  			out.Values[i] = graphql.MarshalString("Viewer")
  3734  		case "user":
  3735  			out.Values[i] = ec._Viewer_user(ctx, field, obj)
  3736  		default:
  3737  			panic("unknown field " + strconv.Quote(field.Name))
  3738  		}
  3739  	}
  3740  	out.Dispatch(ctx)
  3741  	if out.Invalids > 0 {
  3742  		return graphql.Null
  3743  	}
  3744  
  3745  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3746  
  3747  	for label, dfs := range deferred {
  3748  		ec.processDeferredGroup(graphql.DeferredGroup{
  3749  			Label:    label,
  3750  			Path:     graphql.GetPath(ctx),
  3751  			FieldSet: dfs,
  3752  			Context:  ctx,
  3753  		})
  3754  	}
  3755  
  3756  	return out
  3757  }
  3758  
  3759  var __DirectiveImplementors = []string{"__Directive"}
  3760  
  3761  func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
  3762  	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
  3763  
  3764  	out := graphql.NewFieldSet(fields)
  3765  	deferred := make(map[string]*graphql.FieldSet)
  3766  	for i, field := range fields {
  3767  		switch field.Name {
  3768  		case "__typename":
  3769  			out.Values[i] = graphql.MarshalString("__Directive")
  3770  		case "name":
  3771  			out.Values[i] = ec.___Directive_name(ctx, field, obj)
  3772  			if out.Values[i] == graphql.Null {
  3773  				out.Invalids++
  3774  			}
  3775  		case "description":
  3776  			out.Values[i] = ec.___Directive_description(ctx, field, obj)
  3777  		case "locations":
  3778  			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
  3779  			if out.Values[i] == graphql.Null {
  3780  				out.Invalids++
  3781  			}
  3782  		case "args":
  3783  			out.Values[i] = ec.___Directive_args(ctx, field, obj)
  3784  			if out.Values[i] == graphql.Null {
  3785  				out.Invalids++
  3786  			}
  3787  		case "isRepeatable":
  3788  			out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
  3789  			if out.Values[i] == graphql.Null {
  3790  				out.Invalids++
  3791  			}
  3792  		default:
  3793  			panic("unknown field " + strconv.Quote(field.Name))
  3794  		}
  3795  	}
  3796  	out.Dispatch(ctx)
  3797  	if out.Invalids > 0 {
  3798  		return graphql.Null
  3799  	}
  3800  
  3801  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3802  
  3803  	for label, dfs := range deferred {
  3804  		ec.processDeferredGroup(graphql.DeferredGroup{
  3805  			Label:    label,
  3806  			Path:     graphql.GetPath(ctx),
  3807  			FieldSet: dfs,
  3808  			Context:  ctx,
  3809  		})
  3810  	}
  3811  
  3812  	return out
  3813  }
  3814  
  3815  var __EnumValueImplementors = []string{"__EnumValue"}
  3816  
  3817  func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
  3818  	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
  3819  
  3820  	out := graphql.NewFieldSet(fields)
  3821  	deferred := make(map[string]*graphql.FieldSet)
  3822  	for i, field := range fields {
  3823  		switch field.Name {
  3824  		case "__typename":
  3825  			out.Values[i] = graphql.MarshalString("__EnumValue")
  3826  		case "name":
  3827  			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
  3828  			if out.Values[i] == graphql.Null {
  3829  				out.Invalids++
  3830  			}
  3831  		case "description":
  3832  			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
  3833  		case "isDeprecated":
  3834  			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
  3835  			if out.Values[i] == graphql.Null {
  3836  				out.Invalids++
  3837  			}
  3838  		case "deprecationReason":
  3839  			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
  3840  		default:
  3841  			panic("unknown field " + strconv.Quote(field.Name))
  3842  		}
  3843  	}
  3844  	out.Dispatch(ctx)
  3845  	if out.Invalids > 0 {
  3846  		return graphql.Null
  3847  	}
  3848  
  3849  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3850  
  3851  	for label, dfs := range deferred {
  3852  		ec.processDeferredGroup(graphql.DeferredGroup{
  3853  			Label:    label,
  3854  			Path:     graphql.GetPath(ctx),
  3855  			FieldSet: dfs,
  3856  			Context:  ctx,
  3857  		})
  3858  	}
  3859  
  3860  	return out
  3861  }
  3862  
  3863  var __FieldImplementors = []string{"__Field"}
  3864  
  3865  func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
  3866  	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
  3867  
  3868  	out := graphql.NewFieldSet(fields)
  3869  	deferred := make(map[string]*graphql.FieldSet)
  3870  	for i, field := range fields {
  3871  		switch field.Name {
  3872  		case "__typename":
  3873  			out.Values[i] = graphql.MarshalString("__Field")
  3874  		case "name":
  3875  			out.Values[i] = ec.___Field_name(ctx, field, obj)
  3876  			if out.Values[i] == graphql.Null {
  3877  				out.Invalids++
  3878  			}
  3879  		case "description":
  3880  			out.Values[i] = ec.___Field_description(ctx, field, obj)
  3881  		case "args":
  3882  			out.Values[i] = ec.___Field_args(ctx, field, obj)
  3883  			if out.Values[i] == graphql.Null {
  3884  				out.Invalids++
  3885  			}
  3886  		case "type":
  3887  			out.Values[i] = ec.___Field_type(ctx, field, obj)
  3888  			if out.Values[i] == graphql.Null {
  3889  				out.Invalids++
  3890  			}
  3891  		case "isDeprecated":
  3892  			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
  3893  			if out.Values[i] == graphql.Null {
  3894  				out.Invalids++
  3895  			}
  3896  		case "deprecationReason":
  3897  			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
  3898  		default:
  3899  			panic("unknown field " + strconv.Quote(field.Name))
  3900  		}
  3901  	}
  3902  	out.Dispatch(ctx)
  3903  	if out.Invalids > 0 {
  3904  		return graphql.Null
  3905  	}
  3906  
  3907  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3908  
  3909  	for label, dfs := range deferred {
  3910  		ec.processDeferredGroup(graphql.DeferredGroup{
  3911  			Label:    label,
  3912  			Path:     graphql.GetPath(ctx),
  3913  			FieldSet: dfs,
  3914  			Context:  ctx,
  3915  		})
  3916  	}
  3917  
  3918  	return out
  3919  }
  3920  
  3921  var __InputValueImplementors = []string{"__InputValue"}
  3922  
  3923  func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
  3924  	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
  3925  
  3926  	out := graphql.NewFieldSet(fields)
  3927  	deferred := make(map[string]*graphql.FieldSet)
  3928  	for i, field := range fields {
  3929  		switch field.Name {
  3930  		case "__typename":
  3931  			out.Values[i] = graphql.MarshalString("__InputValue")
  3932  		case "name":
  3933  			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
  3934  			if out.Values[i] == graphql.Null {
  3935  				out.Invalids++
  3936  			}
  3937  		case "description":
  3938  			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
  3939  		case "type":
  3940  			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
  3941  			if out.Values[i] == graphql.Null {
  3942  				out.Invalids++
  3943  			}
  3944  		case "defaultValue":
  3945  			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
  3946  		default:
  3947  			panic("unknown field " + strconv.Quote(field.Name))
  3948  		}
  3949  	}
  3950  	out.Dispatch(ctx)
  3951  	if out.Invalids > 0 {
  3952  		return graphql.Null
  3953  	}
  3954  
  3955  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  3956  
  3957  	for label, dfs := range deferred {
  3958  		ec.processDeferredGroup(graphql.DeferredGroup{
  3959  			Label:    label,
  3960  			Path:     graphql.GetPath(ctx),
  3961  			FieldSet: dfs,
  3962  			Context:  ctx,
  3963  		})
  3964  	}
  3965  
  3966  	return out
  3967  }
  3968  
  3969  var __SchemaImplementors = []string{"__Schema"}
  3970  
  3971  func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
  3972  	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
  3973  
  3974  	out := graphql.NewFieldSet(fields)
  3975  	deferred := make(map[string]*graphql.FieldSet)
  3976  	for i, field := range fields {
  3977  		switch field.Name {
  3978  		case "__typename":
  3979  			out.Values[i] = graphql.MarshalString("__Schema")
  3980  		case "description":
  3981  			out.Values[i] = ec.___Schema_description(ctx, field, obj)
  3982  		case "types":
  3983  			out.Values[i] = ec.___Schema_types(ctx, field, obj)
  3984  			if out.Values[i] == graphql.Null {
  3985  				out.Invalids++
  3986  			}
  3987  		case "queryType":
  3988  			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
  3989  			if out.Values[i] == graphql.Null {
  3990  				out.Invalids++
  3991  			}
  3992  		case "mutationType":
  3993  			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
  3994  		case "subscriptionType":
  3995  			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
  3996  		case "directives":
  3997  			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
  3998  			if out.Values[i] == graphql.Null {
  3999  				out.Invalids++
  4000  			}
  4001  		default:
  4002  			panic("unknown field " + strconv.Quote(field.Name))
  4003  		}
  4004  	}
  4005  	out.Dispatch(ctx)
  4006  	if out.Invalids > 0 {
  4007  		return graphql.Null
  4008  	}
  4009  
  4010  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  4011  
  4012  	for label, dfs := range deferred {
  4013  		ec.processDeferredGroup(graphql.DeferredGroup{
  4014  			Label:    label,
  4015  			Path:     graphql.GetPath(ctx),
  4016  			FieldSet: dfs,
  4017  			Context:  ctx,
  4018  		})
  4019  	}
  4020  
  4021  	return out
  4022  }
  4023  
  4024  var __TypeImplementors = []string{"__Type"}
  4025  
  4026  func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
  4027  	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
  4028  
  4029  	out := graphql.NewFieldSet(fields)
  4030  	deferred := make(map[string]*graphql.FieldSet)
  4031  	for i, field := range fields {
  4032  		switch field.Name {
  4033  		case "__typename":
  4034  			out.Values[i] = graphql.MarshalString("__Type")
  4035  		case "kind":
  4036  			out.Values[i] = ec.___Type_kind(ctx, field, obj)
  4037  			if out.Values[i] == graphql.Null {
  4038  				out.Invalids++
  4039  			}
  4040  		case "name":
  4041  			out.Values[i] = ec.___Type_name(ctx, field, obj)
  4042  		case "description":
  4043  			out.Values[i] = ec.___Type_description(ctx, field, obj)
  4044  		case "fields":
  4045  			out.Values[i] = ec.___Type_fields(ctx, field, obj)
  4046  		case "interfaces":
  4047  			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
  4048  		case "possibleTypes":
  4049  			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
  4050  		case "enumValues":
  4051  			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
  4052  		case "inputFields":
  4053  			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
  4054  		case "ofType":
  4055  			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
  4056  		case "specifiedByURL":
  4057  			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
  4058  		default:
  4059  			panic("unknown field " + strconv.Quote(field.Name))
  4060  		}
  4061  	}
  4062  	out.Dispatch(ctx)
  4063  	if out.Invalids > 0 {
  4064  		return graphql.Null
  4065  	}
  4066  
  4067  	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
  4068  
  4069  	for label, dfs := range deferred {
  4070  		ec.processDeferredGroup(graphql.DeferredGroup{
  4071  			Label:    label,
  4072  			Path:     graphql.GetPath(ctx),
  4073  			FieldSet: dfs,
  4074  			Context:  ctx,
  4075  		})
  4076  	}
  4077  
  4078  	return out
  4079  }
  4080  
  4081  // endregion **************************** object.gotpl ****************************
  4082  
  4083  // region    ***************************** type.gotpl *****************************
  4084  
  4085  func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
  4086  	res, err := graphql.UnmarshalBoolean(v)
  4087  	return res, graphql.ErrorOnPath(ctx, err)
  4088  }
  4089  
  4090  func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
  4091  	res := graphql.MarshalBoolean(v)
  4092  	if res == graphql.Null {
  4093  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4094  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4095  		}
  4096  	}
  4097  	return res
  4098  }
  4099  
  4100  func (ec *executionContext) unmarshalNDateFilter2githubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐDateFilter(ctx context.Context, v interface{}) (models.DateFilter, error) {
  4101  	res, err := ec.unmarshalInputDateFilter(ctx, v)
  4102  	return res, graphql.ErrorOnPath(ctx, err)
  4103  }
  4104  
  4105  func (ec *executionContext) marshalNElement2githubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx context.Context, sel ast.SelectionSet, v models.Element) graphql.Marshaler {
  4106  	return ec._Element(ctx, sel, &v)
  4107  }
  4108  
  4109  func (ec *executionContext) marshalNElement2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx context.Context, sel ast.SelectionSet, v *models.Element) graphql.Marshaler {
  4110  	if v == nil {
  4111  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4112  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4113  		}
  4114  		return graphql.Null
  4115  	}
  4116  	return ec._Element(ctx, sel, v)
  4117  }
  4118  
  4119  func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
  4120  	res, err := graphql.UnmarshalInt(v)
  4121  	return res, graphql.ErrorOnPath(ctx, err)
  4122  }
  4123  
  4124  func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
  4125  	res := graphql.MarshalInt(v)
  4126  	if res == graphql.Null {
  4127  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4128  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4129  		}
  4130  	}
  4131  	return res
  4132  }
  4133  
  4134  func (ec *executionContext) unmarshalNListCoercion2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐListCoercion(ctx context.Context, v interface{}) (*models.ListCoercion, error) {
  4135  	res, err := ec.unmarshalInputListCoercion(ctx, v)
  4136  	return &res, graphql.ErrorOnPath(ctx, err)
  4137  }
  4138  
  4139  func (ec *executionContext) marshalNQuery2githubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐQuery(ctx context.Context, sel ast.SelectionSet, v models.Query) graphql.Marshaler {
  4140  	return ec._Query(ctx, sel)
  4141  }
  4142  
  4143  func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
  4144  	res, err := graphql.UnmarshalString(v)
  4145  	return res, graphql.ErrorOnPath(ctx, err)
  4146  }
  4147  
  4148  func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  4149  	res := graphql.MarshalString(v)
  4150  	if res == graphql.Null {
  4151  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4152  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4153  		}
  4154  	}
  4155  	return res
  4156  }
  4157  
  4158  func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
  4159  	var vSlice []interface{}
  4160  	if v != nil {
  4161  		vSlice = graphql.CoerceList(v)
  4162  	}
  4163  	var err error
  4164  	res := make([]string, len(vSlice))
  4165  	for i := range vSlice {
  4166  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4167  		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
  4168  		if err != nil {
  4169  			return nil, err
  4170  		}
  4171  	}
  4172  	return res, nil
  4173  }
  4174  
  4175  func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
  4176  	ret := make(graphql.Array, len(v))
  4177  	for i := range v {
  4178  		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
  4179  	}
  4180  
  4181  	for _, e := range ret {
  4182  		if e == graphql.Null {
  4183  			return graphql.Null
  4184  		}
  4185  	}
  4186  
  4187  	return ret
  4188  }
  4189  
  4190  func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
  4191  	return ec.___Directive(ctx, sel, &v)
  4192  }
  4193  
  4194  func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
  4195  	ret := make(graphql.Array, len(v))
  4196  	var wg sync.WaitGroup
  4197  	isLen1 := len(v) == 1
  4198  	if !isLen1 {
  4199  		wg.Add(len(v))
  4200  	}
  4201  	for i := range v {
  4202  		i := i
  4203  		fc := &graphql.FieldContext{
  4204  			Index:  &i,
  4205  			Result: &v[i],
  4206  		}
  4207  		ctx := graphql.WithFieldContext(ctx, fc)
  4208  		f := func(i int) {
  4209  			defer func() {
  4210  				if r := recover(); r != nil {
  4211  					ec.Error(ctx, ec.Recover(ctx, r))
  4212  					ret = nil
  4213  				}
  4214  			}()
  4215  			if !isLen1 {
  4216  				defer wg.Done()
  4217  			}
  4218  			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
  4219  		}
  4220  		if isLen1 {
  4221  			f(i)
  4222  		} else {
  4223  			go f(i)
  4224  		}
  4225  
  4226  	}
  4227  	wg.Wait()
  4228  
  4229  	for _, e := range ret {
  4230  		if e == graphql.Null {
  4231  			return graphql.Null
  4232  		}
  4233  	}
  4234  
  4235  	return ret
  4236  }
  4237  
  4238  func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
  4239  	res, err := graphql.UnmarshalString(v)
  4240  	return res, graphql.ErrorOnPath(ctx, err)
  4241  }
  4242  
  4243  func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  4244  	res := graphql.MarshalString(v)
  4245  	if res == graphql.Null {
  4246  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4247  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4248  		}
  4249  	}
  4250  	return res
  4251  }
  4252  
  4253  func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
  4254  	var vSlice []interface{}
  4255  	if v != nil {
  4256  		vSlice = graphql.CoerceList(v)
  4257  	}
  4258  	var err error
  4259  	res := make([]string, len(vSlice))
  4260  	for i := range vSlice {
  4261  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4262  		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
  4263  		if err != nil {
  4264  			return nil, err
  4265  		}
  4266  	}
  4267  	return res, nil
  4268  }
  4269  
  4270  func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
  4271  	ret := make(graphql.Array, len(v))
  4272  	var wg sync.WaitGroup
  4273  	isLen1 := len(v) == 1
  4274  	if !isLen1 {
  4275  		wg.Add(len(v))
  4276  	}
  4277  	for i := range v {
  4278  		i := i
  4279  		fc := &graphql.FieldContext{
  4280  			Index:  &i,
  4281  			Result: &v[i],
  4282  		}
  4283  		ctx := graphql.WithFieldContext(ctx, fc)
  4284  		f := func(i int) {
  4285  			defer func() {
  4286  				if r := recover(); r != nil {
  4287  					ec.Error(ctx, ec.Recover(ctx, r))
  4288  					ret = nil
  4289  				}
  4290  			}()
  4291  			if !isLen1 {
  4292  				defer wg.Done()
  4293  			}
  4294  			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
  4295  		}
  4296  		if isLen1 {
  4297  			f(i)
  4298  		} else {
  4299  			go f(i)
  4300  		}
  4301  
  4302  	}
  4303  	wg.Wait()
  4304  
  4305  	for _, e := range ret {
  4306  		if e == graphql.Null {
  4307  			return graphql.Null
  4308  		}
  4309  	}
  4310  
  4311  	return ret
  4312  }
  4313  
  4314  func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
  4315  	return ec.___EnumValue(ctx, sel, &v)
  4316  }
  4317  
  4318  func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
  4319  	return ec.___Field(ctx, sel, &v)
  4320  }
  4321  
  4322  func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
  4323  	return ec.___InputValue(ctx, sel, &v)
  4324  }
  4325  
  4326  func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
  4327  	ret := make(graphql.Array, len(v))
  4328  	var wg sync.WaitGroup
  4329  	isLen1 := len(v) == 1
  4330  	if !isLen1 {
  4331  		wg.Add(len(v))
  4332  	}
  4333  	for i := range v {
  4334  		i := i
  4335  		fc := &graphql.FieldContext{
  4336  			Index:  &i,
  4337  			Result: &v[i],
  4338  		}
  4339  		ctx := graphql.WithFieldContext(ctx, fc)
  4340  		f := func(i int) {
  4341  			defer func() {
  4342  				if r := recover(); r != nil {
  4343  					ec.Error(ctx, ec.Recover(ctx, r))
  4344  					ret = nil
  4345  				}
  4346  			}()
  4347  			if !isLen1 {
  4348  				defer wg.Done()
  4349  			}
  4350  			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
  4351  		}
  4352  		if isLen1 {
  4353  			f(i)
  4354  		} else {
  4355  			go f(i)
  4356  		}
  4357  
  4358  	}
  4359  	wg.Wait()
  4360  
  4361  	for _, e := range ret {
  4362  		if e == graphql.Null {
  4363  			return graphql.Null
  4364  		}
  4365  	}
  4366  
  4367  	return ret
  4368  }
  4369  
  4370  func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
  4371  	return ec.___Type(ctx, sel, &v)
  4372  }
  4373  
  4374  func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
  4375  	ret := make(graphql.Array, len(v))
  4376  	var wg sync.WaitGroup
  4377  	isLen1 := len(v) == 1
  4378  	if !isLen1 {
  4379  		wg.Add(len(v))
  4380  	}
  4381  	for i := range v {
  4382  		i := i
  4383  		fc := &graphql.FieldContext{
  4384  			Index:  &i,
  4385  			Result: &v[i],
  4386  		}
  4387  		ctx := graphql.WithFieldContext(ctx, fc)
  4388  		f := func(i int) {
  4389  			defer func() {
  4390  				if r := recover(); r != nil {
  4391  					ec.Error(ctx, ec.Recover(ctx, r))
  4392  					ret = nil
  4393  				}
  4394  			}()
  4395  			if !isLen1 {
  4396  				defer wg.Done()
  4397  			}
  4398  			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
  4399  		}
  4400  		if isLen1 {
  4401  			f(i)
  4402  		} else {
  4403  			go f(i)
  4404  		}
  4405  
  4406  	}
  4407  	wg.Wait()
  4408  
  4409  	for _, e := range ret {
  4410  		if e == graphql.Null {
  4411  			return graphql.Null
  4412  		}
  4413  	}
  4414  
  4415  	return ret
  4416  }
  4417  
  4418  func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
  4419  	if v == nil {
  4420  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4421  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4422  		}
  4423  		return graphql.Null
  4424  	}
  4425  	return ec.___Type(ctx, sel, v)
  4426  }
  4427  
  4428  func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
  4429  	res, err := graphql.UnmarshalString(v)
  4430  	return res, graphql.ErrorOnPath(ctx, err)
  4431  }
  4432  
  4433  func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  4434  	res := graphql.MarshalString(v)
  4435  	if res == graphql.Null {
  4436  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  4437  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  4438  		}
  4439  	}
  4440  	return res
  4441  }
  4442  
  4443  func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
  4444  	res, err := graphql.UnmarshalBoolean(v)
  4445  	return res, graphql.ErrorOnPath(ctx, err)
  4446  }
  4447  
  4448  func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
  4449  	res := graphql.MarshalBoolean(v)
  4450  	return res
  4451  }
  4452  
  4453  func (ec *executionContext) unmarshalOBoolean2ᚕboolᚄ(ctx context.Context, v interface{}) ([]bool, error) {
  4454  	if v == nil {
  4455  		return nil, nil
  4456  	}
  4457  	var vSlice []interface{}
  4458  	if v != nil {
  4459  		vSlice = graphql.CoerceList(v)
  4460  	}
  4461  	var err error
  4462  	res := make([]bool, len(vSlice))
  4463  	for i := range vSlice {
  4464  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4465  		res[i], err = ec.unmarshalNBoolean2bool(ctx, vSlice[i])
  4466  		if err != nil {
  4467  			return nil, err
  4468  		}
  4469  	}
  4470  	return res, nil
  4471  }
  4472  
  4473  func (ec *executionContext) marshalOBoolean2ᚕboolᚄ(ctx context.Context, sel ast.SelectionSet, v []bool) graphql.Marshaler {
  4474  	if v == nil {
  4475  		return graphql.Null
  4476  	}
  4477  	ret := make(graphql.Array, len(v))
  4478  	for i := range v {
  4479  		ret[i] = ec.marshalNBoolean2bool(ctx, sel, v[i])
  4480  	}
  4481  
  4482  	for _, e := range ret {
  4483  		if e == graphql.Null {
  4484  			return graphql.Null
  4485  		}
  4486  	}
  4487  
  4488  	return ret
  4489  }
  4490  
  4491  func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
  4492  	if v == nil {
  4493  		return nil, nil
  4494  	}
  4495  	res, err := graphql.UnmarshalBoolean(v)
  4496  	return &res, graphql.ErrorOnPath(ctx, err)
  4497  }
  4498  
  4499  func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
  4500  	if v == nil {
  4501  		return graphql.Null
  4502  	}
  4503  	res := graphql.MarshalBoolean(*v)
  4504  	return res
  4505  }
  4506  
  4507  func (ec *executionContext) unmarshalODATE_FILTER_OP2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐDateFilterOp(ctx context.Context, v interface{}) (*models.DateFilterOp, error) {
  4508  	if v == nil {
  4509  		return nil, nil
  4510  	}
  4511  	var res = new(models.DateFilterOp)
  4512  	err := res.UnmarshalGQL(v)
  4513  	return res, graphql.ErrorOnPath(ctx, err)
  4514  }
  4515  
  4516  func (ec *executionContext) marshalODATE_FILTER_OP2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐDateFilterOp(ctx context.Context, sel ast.SelectionSet, v *models.DateFilterOp) graphql.Marshaler {
  4517  	if v == nil {
  4518  		return graphql.Null
  4519  	}
  4520  	return v
  4521  }
  4522  
  4523  func (ec *executionContext) marshalOElement2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx context.Context, sel ast.SelectionSet, v []*models.Element) graphql.Marshaler {
  4524  	if v == nil {
  4525  		return graphql.Null
  4526  	}
  4527  	ret := make(graphql.Array, len(v))
  4528  	var wg sync.WaitGroup
  4529  	isLen1 := len(v) == 1
  4530  	if !isLen1 {
  4531  		wg.Add(len(v))
  4532  	}
  4533  	for i := range v {
  4534  		i := i
  4535  		fc := &graphql.FieldContext{
  4536  			Index:  &i,
  4537  			Result: &v[i],
  4538  		}
  4539  		ctx := graphql.WithFieldContext(ctx, fc)
  4540  		f := func(i int) {
  4541  			defer func() {
  4542  				if r := recover(); r != nil {
  4543  					ec.Error(ctx, ec.Recover(ctx, r))
  4544  					ret = nil
  4545  				}
  4546  			}()
  4547  			if !isLen1 {
  4548  				defer wg.Done()
  4549  			}
  4550  			ret[i] = ec.marshalOElement2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx, sel, v[i])
  4551  		}
  4552  		if isLen1 {
  4553  			f(i)
  4554  		} else {
  4555  			go f(i)
  4556  		}
  4557  
  4558  	}
  4559  	wg.Wait()
  4560  
  4561  	return ret
  4562  }
  4563  
  4564  func (ec *executionContext) marshalOElement2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐElement(ctx context.Context, sel ast.SelectionSet, v *models.Element) graphql.Marshaler {
  4565  	if v == nil {
  4566  		return graphql.Null
  4567  	}
  4568  	return ec._Element(ctx, sel, v)
  4569  }
  4570  
  4571  func (ec *executionContext) unmarshalOErrorType2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx context.Context, v interface{}) ([]*models.ErrorType, error) {
  4572  	if v == nil {
  4573  		return nil, nil
  4574  	}
  4575  	var vSlice []interface{}
  4576  	if v != nil {
  4577  		vSlice = graphql.CoerceList(v)
  4578  	}
  4579  	var err error
  4580  	res := make([]*models.ErrorType, len(vSlice))
  4581  	for i := range vSlice {
  4582  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4583  		res[i], err = ec.unmarshalOErrorType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx, vSlice[i])
  4584  		if err != nil {
  4585  			return nil, err
  4586  		}
  4587  	}
  4588  	return res, nil
  4589  }
  4590  
  4591  func (ec *executionContext) marshalOErrorType2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx context.Context, sel ast.SelectionSet, v []*models.ErrorType) graphql.Marshaler {
  4592  	if v == nil {
  4593  		return graphql.Null
  4594  	}
  4595  	ret := make(graphql.Array, len(v))
  4596  	var wg sync.WaitGroup
  4597  	isLen1 := len(v) == 1
  4598  	if !isLen1 {
  4599  		wg.Add(len(v))
  4600  	}
  4601  	for i := range v {
  4602  		i := i
  4603  		fc := &graphql.FieldContext{
  4604  			Index:  &i,
  4605  			Result: &v[i],
  4606  		}
  4607  		ctx := graphql.WithFieldContext(ctx, fc)
  4608  		f := func(i int) {
  4609  			defer func() {
  4610  				if r := recover(); r != nil {
  4611  					ec.Error(ctx, ec.Recover(ctx, r))
  4612  					ret = nil
  4613  				}
  4614  			}()
  4615  			if !isLen1 {
  4616  				defer wg.Done()
  4617  			}
  4618  			ret[i] = ec.marshalOErrorType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx, sel, v[i])
  4619  		}
  4620  		if isLen1 {
  4621  			f(i)
  4622  		} else {
  4623  			go f(i)
  4624  		}
  4625  
  4626  	}
  4627  	wg.Wait()
  4628  
  4629  	return ret
  4630  }
  4631  
  4632  func (ec *executionContext) unmarshalOErrorType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx context.Context, v interface{}) (*models.ErrorType, error) {
  4633  	if v == nil {
  4634  		return nil, nil
  4635  	}
  4636  	var res = new(models.ErrorType)
  4637  	err := res.UnmarshalGQL(v)
  4638  	return res, graphql.ErrorOnPath(ctx, err)
  4639  }
  4640  
  4641  func (ec *executionContext) marshalOErrorType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐErrorType(ctx context.Context, sel ast.SelectionSet, v *models.ErrorType) graphql.Marshaler {
  4642  	if v == nil {
  4643  		return graphql.Null
  4644  	}
  4645  	return v
  4646  }
  4647  
  4648  func (ec *executionContext) unmarshalOInt2ᚕᚖint(ctx context.Context, v interface{}) ([]*int, error) {
  4649  	if v == nil {
  4650  		return nil, nil
  4651  	}
  4652  	var vSlice []interface{}
  4653  	if v != nil {
  4654  		vSlice = graphql.CoerceList(v)
  4655  	}
  4656  	var err error
  4657  	res := make([]*int, len(vSlice))
  4658  	for i := range vSlice {
  4659  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4660  		res[i], err = ec.unmarshalOInt2ᚖint(ctx, vSlice[i])
  4661  		if err != nil {
  4662  			return nil, err
  4663  		}
  4664  	}
  4665  	return res, nil
  4666  }
  4667  
  4668  func (ec *executionContext) marshalOInt2ᚕᚖint(ctx context.Context, sel ast.SelectionSet, v []*int) graphql.Marshaler {
  4669  	if v == nil {
  4670  		return graphql.Null
  4671  	}
  4672  	ret := make(graphql.Array, len(v))
  4673  	for i := range v {
  4674  		ret[i] = ec.marshalOInt2ᚖint(ctx, sel, v[i])
  4675  	}
  4676  
  4677  	return ret
  4678  }
  4679  
  4680  func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
  4681  	if v == nil {
  4682  		return nil, nil
  4683  	}
  4684  	res, err := graphql.UnmarshalInt(v)
  4685  	return &res, graphql.ErrorOnPath(ctx, err)
  4686  }
  4687  
  4688  func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
  4689  	if v == nil {
  4690  		return graphql.Null
  4691  	}
  4692  	res := graphql.MarshalInt(*v)
  4693  	return res
  4694  }
  4695  
  4696  func (ec *executionContext) unmarshalOListCoercion2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐListCoercionᚄ(ctx context.Context, v interface{}) ([]*models.ListCoercion, error) {
  4697  	if v == nil {
  4698  		return nil, nil
  4699  	}
  4700  	var vSlice []interface{}
  4701  	if v != nil {
  4702  		vSlice = graphql.CoerceList(v)
  4703  	}
  4704  	var err error
  4705  	res := make([]*models.ListCoercion, len(vSlice))
  4706  	for i := range vSlice {
  4707  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4708  		res[i], err = ec.unmarshalNListCoercion2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐListCoercion(ctx, vSlice[i])
  4709  		if err != nil {
  4710  			return nil, err
  4711  		}
  4712  	}
  4713  	return res, nil
  4714  }
  4715  
  4716  func (ec *executionContext) unmarshalOMap2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
  4717  	if v == nil {
  4718  		return nil, nil
  4719  	}
  4720  	res, err := graphql.UnmarshalMap(v)
  4721  	return res, graphql.ErrorOnPath(ctx, err)
  4722  }
  4723  
  4724  func (ec *executionContext) marshalOMap2map(ctx context.Context, sel ast.SelectionSet, v map[string]interface{}) graphql.Marshaler {
  4725  	if v == nil {
  4726  		return graphql.Null
  4727  	}
  4728  	res := graphql.MarshalMap(v)
  4729  	return res
  4730  }
  4731  
  4732  func (ec *executionContext) unmarshalOMap2ᚕmap(ctx context.Context, v interface{}) ([]map[string]interface{}, error) {
  4733  	if v == nil {
  4734  		return nil, nil
  4735  	}
  4736  	var vSlice []interface{}
  4737  	if v != nil {
  4738  		vSlice = graphql.CoerceList(v)
  4739  	}
  4740  	var err error
  4741  	res := make([]map[string]interface{}, len(vSlice))
  4742  	for i := range vSlice {
  4743  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4744  		res[i], err = ec.unmarshalOMap2map(ctx, vSlice[i])
  4745  		if err != nil {
  4746  			return nil, err
  4747  		}
  4748  	}
  4749  	return res, nil
  4750  }
  4751  
  4752  func (ec *executionContext) marshalOMap2ᚕmap(ctx context.Context, sel ast.SelectionSet, v []map[string]interface{}) graphql.Marshaler {
  4753  	if v == nil {
  4754  		return graphql.Null
  4755  	}
  4756  	ret := make(graphql.Array, len(v))
  4757  	for i := range v {
  4758  		ret[i] = ec.marshalOMap2map(ctx, sel, v[i])
  4759  	}
  4760  
  4761  	return ret
  4762  }
  4763  
  4764  func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
  4765  	res, err := graphql.UnmarshalString(v)
  4766  	return res, graphql.ErrorOnPath(ctx, err)
  4767  }
  4768  
  4769  func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  4770  	res := graphql.MarshalString(v)
  4771  	return res
  4772  }
  4773  
  4774  func (ec *executionContext) unmarshalOString2ᚕᚖstring(ctx context.Context, v interface{}) ([]*string, error) {
  4775  	if v == nil {
  4776  		return nil, nil
  4777  	}
  4778  	var vSlice []interface{}
  4779  	if v != nil {
  4780  		vSlice = graphql.CoerceList(v)
  4781  	}
  4782  	var err error
  4783  	res := make([]*string, len(vSlice))
  4784  	for i := range vSlice {
  4785  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  4786  		res[i], err = ec.unmarshalOString2ᚖstring(ctx, vSlice[i])
  4787  		if err != nil {
  4788  			return nil, err
  4789  		}
  4790  	}
  4791  	return res, nil
  4792  }
  4793  
  4794  func (ec *executionContext) marshalOString2ᚕᚖstring(ctx context.Context, sel ast.SelectionSet, v []*string) graphql.Marshaler {
  4795  	if v == nil {
  4796  		return graphql.Null
  4797  	}
  4798  	ret := make(graphql.Array, len(v))
  4799  	for i := range v {
  4800  		ret[i] = ec.marshalOString2ᚖstring(ctx, sel, v[i])
  4801  	}
  4802  
  4803  	return ret
  4804  }
  4805  
  4806  func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
  4807  	if v == nil {
  4808  		return nil, nil
  4809  	}
  4810  	res, err := graphql.UnmarshalString(v)
  4811  	return &res, graphql.ErrorOnPath(ctx, err)
  4812  }
  4813  
  4814  func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
  4815  	if v == nil {
  4816  		return graphql.Null
  4817  	}
  4818  	res := graphql.MarshalString(*v)
  4819  	return res
  4820  }
  4821  
  4822  func (ec *executionContext) marshalOUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋremote_apiᚐUser(ctx context.Context, sel ast.SelectionSet, v *remote_api.User) graphql.Marshaler {
  4823  	if v == nil {
  4824  		return graphql.Null
  4825  	}
  4826  	return ec._User(ctx, sel, v)
  4827  }
  4828  
  4829  func (ec *executionContext) marshalOViewer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋintegrationᚋserverᚋmodelsᚑgoᚐViewer(ctx context.Context, sel ast.SelectionSet, v *models.Viewer) graphql.Marshaler {
  4830  	if v == nil {
  4831  		return graphql.Null
  4832  	}
  4833  	return ec._Viewer(ctx, sel, v)
  4834  }
  4835  
  4836  func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
  4837  	if v == nil {
  4838  		return graphql.Null
  4839  	}
  4840  	ret := make(graphql.Array, len(v))
  4841  	var wg sync.WaitGroup
  4842  	isLen1 := len(v) == 1
  4843  	if !isLen1 {
  4844  		wg.Add(len(v))
  4845  	}
  4846  	for i := range v {
  4847  		i := i
  4848  		fc := &graphql.FieldContext{
  4849  			Index:  &i,
  4850  			Result: &v[i],
  4851  		}
  4852  		ctx := graphql.WithFieldContext(ctx, fc)
  4853  		f := func(i int) {
  4854  			defer func() {
  4855  				if r := recover(); r != nil {
  4856  					ec.Error(ctx, ec.Recover(ctx, r))
  4857  					ret = nil
  4858  				}
  4859  			}()
  4860  			if !isLen1 {
  4861  				defer wg.Done()
  4862  			}
  4863  			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
  4864  		}
  4865  		if isLen1 {
  4866  			f(i)
  4867  		} else {
  4868  			go f(i)
  4869  		}
  4870  
  4871  	}
  4872  	wg.Wait()
  4873  
  4874  	for _, e := range ret {
  4875  		if e == graphql.Null {
  4876  			return graphql.Null
  4877  		}
  4878  	}
  4879  
  4880  	return ret
  4881  }
  4882  
  4883  func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
  4884  	if v == nil {
  4885  		return graphql.Null
  4886  	}
  4887  	ret := make(graphql.Array, len(v))
  4888  	var wg sync.WaitGroup
  4889  	isLen1 := len(v) == 1
  4890  	if !isLen1 {
  4891  		wg.Add(len(v))
  4892  	}
  4893  	for i := range v {
  4894  		i := i
  4895  		fc := &graphql.FieldContext{
  4896  			Index:  &i,
  4897  			Result: &v[i],
  4898  		}
  4899  		ctx := graphql.WithFieldContext(ctx, fc)
  4900  		f := func(i int) {
  4901  			defer func() {
  4902  				if r := recover(); r != nil {
  4903  					ec.Error(ctx, ec.Recover(ctx, r))
  4904  					ret = nil
  4905  				}
  4906  			}()
  4907  			if !isLen1 {
  4908  				defer wg.Done()
  4909  			}
  4910  			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
  4911  		}
  4912  		if isLen1 {
  4913  			f(i)
  4914  		} else {
  4915  			go f(i)
  4916  		}
  4917  
  4918  	}
  4919  	wg.Wait()
  4920  
  4921  	for _, e := range ret {
  4922  		if e == graphql.Null {
  4923  			return graphql.Null
  4924  		}
  4925  	}
  4926  
  4927  	return ret
  4928  }
  4929  
  4930  func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
  4931  	if v == nil {
  4932  		return graphql.Null
  4933  	}
  4934  	ret := make(graphql.Array, len(v))
  4935  	var wg sync.WaitGroup
  4936  	isLen1 := len(v) == 1
  4937  	if !isLen1 {
  4938  		wg.Add(len(v))
  4939  	}
  4940  	for i := range v {
  4941  		i := i
  4942  		fc := &graphql.FieldContext{
  4943  			Index:  &i,
  4944  			Result: &v[i],
  4945  		}
  4946  		ctx := graphql.WithFieldContext(ctx, fc)
  4947  		f := func(i int) {
  4948  			defer func() {
  4949  				if r := recover(); r != nil {
  4950  					ec.Error(ctx, ec.Recover(ctx, r))
  4951  					ret = nil
  4952  				}
  4953  			}()
  4954  			if !isLen1 {
  4955  				defer wg.Done()
  4956  			}
  4957  			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
  4958  		}
  4959  		if isLen1 {
  4960  			f(i)
  4961  		} else {
  4962  			go f(i)
  4963  		}
  4964  
  4965  	}
  4966  	wg.Wait()
  4967  
  4968  	for _, e := range ret {
  4969  		if e == graphql.Null {
  4970  			return graphql.Null
  4971  		}
  4972  	}
  4973  
  4974  	return ret
  4975  }
  4976  
  4977  func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
  4978  	if v == nil {
  4979  		return graphql.Null
  4980  	}
  4981  	return ec.___Schema(ctx, sel, v)
  4982  }
  4983  
  4984  func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
  4985  	if v == nil {
  4986  		return graphql.Null
  4987  	}
  4988  	ret := make(graphql.Array, len(v))
  4989  	var wg sync.WaitGroup
  4990  	isLen1 := len(v) == 1
  4991  	if !isLen1 {
  4992  		wg.Add(len(v))
  4993  	}
  4994  	for i := range v {
  4995  		i := i
  4996  		fc := &graphql.FieldContext{
  4997  			Index:  &i,
  4998  			Result: &v[i],
  4999  		}
  5000  		ctx := graphql.WithFieldContext(ctx, fc)
  5001  		f := func(i int) {
  5002  			defer func() {
  5003  				if r := recover(); r != nil {
  5004  					ec.Error(ctx, ec.Recover(ctx, r))
  5005  					ret = nil
  5006  				}
  5007  			}()
  5008  			if !isLen1 {
  5009  				defer wg.Done()
  5010  			}
  5011  			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
  5012  		}
  5013  		if isLen1 {
  5014  			f(i)
  5015  		} else {
  5016  			go f(i)
  5017  		}
  5018  
  5019  	}
  5020  	wg.Wait()
  5021  
  5022  	for _, e := range ret {
  5023  		if e == graphql.Null {
  5024  			return graphql.Null
  5025  		}
  5026  	}
  5027  
  5028  	return ret
  5029  }
  5030  
  5031  func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
  5032  	if v == nil {
  5033  		return graphql.Null
  5034  	}
  5035  	return ec.___Type(ctx, sel, v)
  5036  }
  5037  
  5038  // endregion ***************************** type.gotpl *****************************
  5039  

View as plain text