github.com/fortexxx/gqlgen@v0.10.3-0.20191216030626-ca5ea8b21ead/example/config/generated.go (about)

     1  // Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
     2  
     3  package config
     4  
     5  import (
     6  	"bytes"
     7  	"context"
     8  	"errors"
     9  	"strconv"
    10  	"sync"
    11  	"sync/atomic"
    12  
    13  	"github.com/99designs/gqlgen/graphql"
    14  	"github.com/99designs/gqlgen/graphql/introspection"
    15  	"github.com/vektah/gqlparser"
    16  	"github.com/vektah/gqlparser/ast"
    17  )
    18  
    19  // region    ************************** generated!.gotpl **************************
    20  
    21  // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
    22  func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
    23  	return &executableSchema{
    24  		resolvers:  cfg.Resolvers,
    25  		directives: cfg.Directives,
    26  		complexity: cfg.Complexity,
    27  	}
    28  }
    29  
    30  type Config struct {
    31  	Resolvers  ResolverRoot
    32  	Directives DirectiveRoot
    33  	Complexity ComplexityRoot
    34  }
    35  
    36  type ResolverRoot interface {
    37  	Mutation() MutationResolver
    38  	Query() QueryResolver
    39  	Todo() TodoResolver
    40  }
    41  
    42  type DirectiveRoot struct {
    43  }
    44  
    45  type ComplexityRoot struct {
    46  	Mutation struct {
    47  		CreateTodo func(childComplexity int, input NewTodo) int
    48  	}
    49  
    50  	Query struct {
    51  		Todos func(childComplexity int) int
    52  	}
    53  
    54  	Todo struct {
    55  		DatabaseID  func(childComplexity int) int
    56  		Description func(childComplexity int) int
    57  		Done        func(childComplexity int) int
    58  		ID          func(childComplexity int) int
    59  		User        func(childComplexity int) int
    60  	}
    61  
    62  	User struct {
    63  		FullName func(childComplexity int) int
    64  		ID       func(childComplexity int) int
    65  	}
    66  }
    67  
    68  type MutationResolver interface {
    69  	CreateTodo(ctx context.Context, input NewTodo) (*Todo, error)
    70  }
    71  type QueryResolver interface {
    72  	Todos(ctx context.Context) ([]*Todo, error)
    73  }
    74  type TodoResolver interface {
    75  	ID(ctx context.Context, obj *Todo) (string, error)
    76  }
    77  
    78  type executableSchema struct {
    79  	resolvers  ResolverRoot
    80  	directives DirectiveRoot
    81  	complexity ComplexityRoot
    82  }
    83  
    84  func (e *executableSchema) Schema() *ast.Schema {
    85  	return parsedSchema
    86  }
    87  
    88  func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
    89  	ec := executionContext{nil, e}
    90  	_ = ec
    91  	switch typeName + "." + field {
    92  
    93  	case "Mutation.createTodo":
    94  		if e.complexity.Mutation.CreateTodo == nil {
    95  			break
    96  		}
    97  
    98  		args, err := ec.field_Mutation_createTodo_args(context.TODO(), rawArgs)
    99  		if err != nil {
   100  			return 0, false
   101  		}
   102  
   103  		return e.complexity.Mutation.CreateTodo(childComplexity, args["input"].(NewTodo)), true
   104  
   105  	case "Query.todos":
   106  		if e.complexity.Query.Todos == nil {
   107  			break
   108  		}
   109  
   110  		return e.complexity.Query.Todos(childComplexity), true
   111  
   112  	case "Todo.databaseId":
   113  		if e.complexity.Todo.DatabaseID == nil {
   114  			break
   115  		}
   116  
   117  		return e.complexity.Todo.DatabaseID(childComplexity), true
   118  
   119  	case "Todo.text":
   120  		if e.complexity.Todo.Description == nil {
   121  			break
   122  		}
   123  
   124  		return e.complexity.Todo.Description(childComplexity), true
   125  
   126  	case "Todo.done":
   127  		if e.complexity.Todo.Done == nil {
   128  			break
   129  		}
   130  
   131  		return e.complexity.Todo.Done(childComplexity), true
   132  
   133  	case "Todo.id":
   134  		if e.complexity.Todo.ID == nil {
   135  			break
   136  		}
   137  
   138  		return e.complexity.Todo.ID(childComplexity), true
   139  
   140  	case "Todo.user":
   141  		if e.complexity.Todo.User == nil {
   142  			break
   143  		}
   144  
   145  		return e.complexity.Todo.User(childComplexity), true
   146  
   147  	case "User.name":
   148  		if e.complexity.User.FullName == nil {
   149  			break
   150  		}
   151  
   152  		return e.complexity.User.FullName(childComplexity), true
   153  
   154  	case "User.id":
   155  		if e.complexity.User.ID == nil {
   156  			break
   157  		}
   158  
   159  		return e.complexity.User.ID(childComplexity), true
   160  
   161  	}
   162  	return 0, false
   163  }
   164  
   165  func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
   166  	rc := graphql.GetOperationContext(ctx)
   167  	ec := executionContext{rc, e}
   168  	first := true
   169  
   170  	switch rc.Operation.Operation {
   171  	case ast.Query:
   172  		return func(ctx context.Context) *graphql.Response {
   173  			if !first {
   174  				return nil
   175  			}
   176  			first = false
   177  			data := ec._Query(ctx, rc.Operation.SelectionSet)
   178  			var buf bytes.Buffer
   179  			data.MarshalGQL(&buf)
   180  
   181  			return &graphql.Response{
   182  				Data: buf.Bytes(),
   183  			}
   184  		}
   185  	case ast.Mutation:
   186  		return func(ctx context.Context) *graphql.Response {
   187  			if !first {
   188  				return nil
   189  			}
   190  			first = false
   191  			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
   192  			var buf bytes.Buffer
   193  			data.MarshalGQL(&buf)
   194  
   195  			return &graphql.Response{
   196  				Data: buf.Bytes(),
   197  			}
   198  		}
   199  
   200  	default:
   201  		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
   202  	}
   203  }
   204  
   205  type executionContext struct {
   206  	*graphql.OperationContext
   207  	*executableSchema
   208  }
   209  
   210  func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
   211  	if ec.DisableIntrospection {
   212  		return nil, errors.New("introspection disabled")
   213  	}
   214  	return introspection.WrapSchema(parsedSchema), nil
   215  }
   216  
   217  func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
   218  	if ec.DisableIntrospection {
   219  		return nil, errors.New("introspection disabled")
   220  	}
   221  	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
   222  }
   223  
   224  var parsedSchema = gqlparser.MustLoadSchema(
   225  	&ast.Source{Name: "schema.graphql", Input: `directive @goModel(model: String, models: [String!]) on OBJECT | INPUT_OBJECT | SCALAR | ENUM | INTERFACE | UNION
   226  directive @goField(forceResolver: Boolean, name: String) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION
   227  
   228  type Query {
   229    todos: [Todo!]!
   230  }
   231  
   232  type Mutation {
   233    createTodo(input: NewTodo!): Todo!
   234  }
   235  `},
   236  	&ast.Source{Name: "todo.graphql", Input: `type Todo {
   237    id: ID! @goField(forceResolver: true)
   238    databaseId: Int!
   239    text: String!
   240    done: Boolean!
   241    user: User!
   242  }
   243  
   244  input NewTodo {
   245    text: String!
   246    userId: String!
   247  }
   248  
   249  `},
   250  	&ast.Source{Name: "user.graphql", Input: `type User
   251  @goModel(model:"github.com/99designs/gqlgen/example/config.User") {
   252    id: ID!
   253    name: String! @goField(name:"FullName")
   254  }
   255  `},
   256  )
   257  
   258  // endregion ************************** generated!.gotpl **************************
   259  
   260  // region    ***************************** args.gotpl *****************************
   261  
   262  func (ec *executionContext) field_Mutation_createTodo_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   263  	var err error
   264  	args := map[string]interface{}{}
   265  	var arg0 NewTodo
   266  	if tmp, ok := rawArgs["input"]; ok {
   267  		arg0, err = ec.unmarshalNNewTodo2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐNewTodo(ctx, tmp)
   268  		if err != nil {
   269  			return nil, err
   270  		}
   271  	}
   272  	args["input"] = arg0
   273  	return args, nil
   274  }
   275  
   276  func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   277  	var err error
   278  	args := map[string]interface{}{}
   279  	var arg0 string
   280  	if tmp, ok := rawArgs["name"]; ok {
   281  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   282  		if err != nil {
   283  			return nil, err
   284  		}
   285  	}
   286  	args["name"] = arg0
   287  	return args, nil
   288  }
   289  
   290  func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   291  	var err error
   292  	args := map[string]interface{}{}
   293  	var arg0 bool
   294  	if tmp, ok := rawArgs["includeDeprecated"]; ok {
   295  		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
   296  		if err != nil {
   297  			return nil, err
   298  		}
   299  	}
   300  	args["includeDeprecated"] = arg0
   301  	return args, nil
   302  }
   303  
   304  func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   305  	var err error
   306  	args := map[string]interface{}{}
   307  	var arg0 bool
   308  	if tmp, ok := rawArgs["includeDeprecated"]; ok {
   309  		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
   310  		if err != nil {
   311  			return nil, err
   312  		}
   313  	}
   314  	args["includeDeprecated"] = arg0
   315  	return args, nil
   316  }
   317  
   318  // endregion ***************************** args.gotpl *****************************
   319  
   320  // region    ************************** directives.gotpl **************************
   321  
   322  // endregion ************************** directives.gotpl **************************
   323  
   324  // region    **************************** field.gotpl *****************************
   325  
   326  func (ec *executionContext) _Mutation_createTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   327  	defer func() {
   328  		if r := recover(); r != nil {
   329  			ec.Error(ctx, ec.Recover(ctx, r))
   330  			ret = graphql.Null
   331  		}
   332  	}()
   333  	fc := &graphql.FieldContext{
   334  		Object:   "Mutation",
   335  		Field:    field,
   336  		Args:     nil,
   337  		IsMethod: true,
   338  	}
   339  
   340  	ctx = graphql.WithFieldContext(ctx, fc)
   341  	rawArgs := field.ArgumentMap(ec.Variables)
   342  	args, err := ec.field_Mutation_createTodo_args(ctx, rawArgs)
   343  	if err != nil {
   344  		ec.Error(ctx, err)
   345  		return graphql.Null
   346  	}
   347  	fc.Args = args
   348  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   349  		ctx = rctx // use context from middleware stack in children
   350  		return ec.resolvers.Mutation().CreateTodo(rctx, args["input"].(NewTodo))
   351  	})
   352  	if err != nil {
   353  		ec.Error(ctx, err)
   354  		return graphql.Null
   355  	}
   356  	if resTmp == nil {
   357  		if !graphql.HasFieldError(ctx, fc) {
   358  			ec.Errorf(ctx, "must not be null")
   359  		}
   360  		return graphql.Null
   361  	}
   362  	res := resTmp.(*Todo)
   363  	fc.Result = res
   364  	return ec.marshalNTodo2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx, field.Selections, res)
   365  }
   366  
   367  func (ec *executionContext) _Query_todos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   368  	defer func() {
   369  		if r := recover(); r != nil {
   370  			ec.Error(ctx, ec.Recover(ctx, r))
   371  			ret = graphql.Null
   372  		}
   373  	}()
   374  	fc := &graphql.FieldContext{
   375  		Object:   "Query",
   376  		Field:    field,
   377  		Args:     nil,
   378  		IsMethod: true,
   379  	}
   380  
   381  	ctx = graphql.WithFieldContext(ctx, fc)
   382  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   383  		ctx = rctx // use context from middleware stack in children
   384  		return ec.resolvers.Query().Todos(rctx)
   385  	})
   386  	if err != nil {
   387  		ec.Error(ctx, err)
   388  		return graphql.Null
   389  	}
   390  	if resTmp == nil {
   391  		if !graphql.HasFieldError(ctx, fc) {
   392  			ec.Errorf(ctx, "must not be null")
   393  		}
   394  		return graphql.Null
   395  	}
   396  	res := resTmp.([]*Todo)
   397  	fc.Result = res
   398  	return ec.marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodoᚄ(ctx, field.Selections, res)
   399  }
   400  
   401  func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   402  	defer func() {
   403  		if r := recover(); r != nil {
   404  			ec.Error(ctx, ec.Recover(ctx, r))
   405  			ret = graphql.Null
   406  		}
   407  	}()
   408  	fc := &graphql.FieldContext{
   409  		Object:   "Query",
   410  		Field:    field,
   411  		Args:     nil,
   412  		IsMethod: true,
   413  	}
   414  
   415  	ctx = graphql.WithFieldContext(ctx, fc)
   416  	rawArgs := field.ArgumentMap(ec.Variables)
   417  	args, err := ec.field_Query___type_args(ctx, rawArgs)
   418  	if err != nil {
   419  		ec.Error(ctx, err)
   420  		return graphql.Null
   421  	}
   422  	fc.Args = args
   423  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   424  		ctx = rctx // use context from middleware stack in children
   425  		return ec.introspectType(args["name"].(string))
   426  	})
   427  	if err != nil {
   428  		ec.Error(ctx, err)
   429  		return graphql.Null
   430  	}
   431  	if resTmp == nil {
   432  		return graphql.Null
   433  	}
   434  	res := resTmp.(*introspection.Type)
   435  	fc.Result = res
   436  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
   437  }
   438  
   439  func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
   440  	defer func() {
   441  		if r := recover(); r != nil {
   442  			ec.Error(ctx, ec.Recover(ctx, r))
   443  			ret = graphql.Null
   444  		}
   445  	}()
   446  	fc := &graphql.FieldContext{
   447  		Object:   "Query",
   448  		Field:    field,
   449  		Args:     nil,
   450  		IsMethod: true,
   451  	}
   452  
   453  	ctx = graphql.WithFieldContext(ctx, fc)
   454  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   455  		ctx = rctx // use context from middleware stack in children
   456  		return ec.introspectSchema()
   457  	})
   458  	if err != nil {
   459  		ec.Error(ctx, err)
   460  		return graphql.Null
   461  	}
   462  	if resTmp == nil {
   463  		return graphql.Null
   464  	}
   465  	res := resTmp.(*introspection.Schema)
   466  	fc.Result = res
   467  	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
   468  }
   469  
   470  func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) {
   471  	defer func() {
   472  		if r := recover(); r != nil {
   473  			ec.Error(ctx, ec.Recover(ctx, r))
   474  			ret = graphql.Null
   475  		}
   476  	}()
   477  	fc := &graphql.FieldContext{
   478  		Object:   "Todo",
   479  		Field:    field,
   480  		Args:     nil,
   481  		IsMethod: true,
   482  	}
   483  
   484  	ctx = graphql.WithFieldContext(ctx, fc)
   485  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   486  		ctx = rctx // use context from middleware stack in children
   487  		return ec.resolvers.Todo().ID(rctx, obj)
   488  	})
   489  	if err != nil {
   490  		ec.Error(ctx, err)
   491  		return graphql.Null
   492  	}
   493  	if resTmp == nil {
   494  		if !graphql.HasFieldError(ctx, fc) {
   495  			ec.Errorf(ctx, "must not be null")
   496  		}
   497  		return graphql.Null
   498  	}
   499  	res := resTmp.(string)
   500  	fc.Result = res
   501  	return ec.marshalNID2string(ctx, field.Selections, res)
   502  }
   503  
   504  func (ec *executionContext) _Todo_databaseId(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) {
   505  	defer func() {
   506  		if r := recover(); r != nil {
   507  			ec.Error(ctx, ec.Recover(ctx, r))
   508  			ret = graphql.Null
   509  		}
   510  	}()
   511  	fc := &graphql.FieldContext{
   512  		Object:   "Todo",
   513  		Field:    field,
   514  		Args:     nil,
   515  		IsMethod: false,
   516  	}
   517  
   518  	ctx = graphql.WithFieldContext(ctx, fc)
   519  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   520  		ctx = rctx // use context from middleware stack in children
   521  		return obj.DatabaseID, nil
   522  	})
   523  	if err != nil {
   524  		ec.Error(ctx, err)
   525  		return graphql.Null
   526  	}
   527  	if resTmp == nil {
   528  		if !graphql.HasFieldError(ctx, fc) {
   529  			ec.Errorf(ctx, "must not be null")
   530  		}
   531  		return graphql.Null
   532  	}
   533  	res := resTmp.(int)
   534  	fc.Result = res
   535  	return ec.marshalNInt2int(ctx, field.Selections, res)
   536  }
   537  
   538  func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) {
   539  	defer func() {
   540  		if r := recover(); r != nil {
   541  			ec.Error(ctx, ec.Recover(ctx, r))
   542  			ret = graphql.Null
   543  		}
   544  	}()
   545  	fc := &graphql.FieldContext{
   546  		Object:   "Todo",
   547  		Field:    field,
   548  		Args:     nil,
   549  		IsMethod: false,
   550  	}
   551  
   552  	ctx = graphql.WithFieldContext(ctx, fc)
   553  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   554  		ctx = rctx // use context from middleware stack in children
   555  		return obj.Description, nil
   556  	})
   557  	if err != nil {
   558  		ec.Error(ctx, err)
   559  		return graphql.Null
   560  	}
   561  	if resTmp == nil {
   562  		if !graphql.HasFieldError(ctx, fc) {
   563  			ec.Errorf(ctx, "must not be null")
   564  		}
   565  		return graphql.Null
   566  	}
   567  	res := resTmp.(string)
   568  	fc.Result = res
   569  	return ec.marshalNString2string(ctx, field.Selections, res)
   570  }
   571  
   572  func (ec *executionContext) _Todo_done(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) {
   573  	defer func() {
   574  		if r := recover(); r != nil {
   575  			ec.Error(ctx, ec.Recover(ctx, r))
   576  			ret = graphql.Null
   577  		}
   578  	}()
   579  	fc := &graphql.FieldContext{
   580  		Object:   "Todo",
   581  		Field:    field,
   582  		Args:     nil,
   583  		IsMethod: false,
   584  	}
   585  
   586  	ctx = graphql.WithFieldContext(ctx, fc)
   587  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   588  		ctx = rctx // use context from middleware stack in children
   589  		return obj.Done, nil
   590  	})
   591  	if err != nil {
   592  		ec.Error(ctx, err)
   593  		return graphql.Null
   594  	}
   595  	if resTmp == nil {
   596  		if !graphql.HasFieldError(ctx, fc) {
   597  			ec.Errorf(ctx, "must not be null")
   598  		}
   599  		return graphql.Null
   600  	}
   601  	res := resTmp.(bool)
   602  	fc.Result = res
   603  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   604  }
   605  
   606  func (ec *executionContext) _Todo_user(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) {
   607  	defer func() {
   608  		if r := recover(); r != nil {
   609  			ec.Error(ctx, ec.Recover(ctx, r))
   610  			ret = graphql.Null
   611  		}
   612  	}()
   613  	fc := &graphql.FieldContext{
   614  		Object:   "Todo",
   615  		Field:    field,
   616  		Args:     nil,
   617  		IsMethod: false,
   618  	}
   619  
   620  	ctx = graphql.WithFieldContext(ctx, fc)
   621  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   622  		ctx = rctx // use context from middleware stack in children
   623  		return obj.User, nil
   624  	})
   625  	if err != nil {
   626  		ec.Error(ctx, err)
   627  		return graphql.Null
   628  	}
   629  	if resTmp == nil {
   630  		if !graphql.HasFieldError(ctx, fc) {
   631  			ec.Errorf(ctx, "must not be null")
   632  		}
   633  		return graphql.Null
   634  	}
   635  	res := resTmp.(*User)
   636  	fc.Result = res
   637  	return ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐUser(ctx, field.Selections, res)
   638  }
   639  
   640  func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
   641  	defer func() {
   642  		if r := recover(); r != nil {
   643  			ec.Error(ctx, ec.Recover(ctx, r))
   644  			ret = graphql.Null
   645  		}
   646  	}()
   647  	fc := &graphql.FieldContext{
   648  		Object:   "User",
   649  		Field:    field,
   650  		Args:     nil,
   651  		IsMethod: false,
   652  	}
   653  
   654  	ctx = graphql.WithFieldContext(ctx, fc)
   655  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   656  		ctx = rctx // use context from middleware stack in children
   657  		return obj.ID, nil
   658  	})
   659  	if err != nil {
   660  		ec.Error(ctx, err)
   661  		return graphql.Null
   662  	}
   663  	if resTmp == nil {
   664  		if !graphql.HasFieldError(ctx, fc) {
   665  			ec.Errorf(ctx, "must not be null")
   666  		}
   667  		return graphql.Null
   668  	}
   669  	res := resTmp.(string)
   670  	fc.Result = res
   671  	return ec.marshalNID2string(ctx, field.Selections, res)
   672  }
   673  
   674  func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
   675  	defer func() {
   676  		if r := recover(); r != nil {
   677  			ec.Error(ctx, ec.Recover(ctx, r))
   678  			ret = graphql.Null
   679  		}
   680  	}()
   681  	fc := &graphql.FieldContext{
   682  		Object:   "User",
   683  		Field:    field,
   684  		Args:     nil,
   685  		IsMethod: true,
   686  	}
   687  
   688  	ctx = graphql.WithFieldContext(ctx, fc)
   689  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   690  		ctx = rctx // use context from middleware stack in children
   691  		return obj.FullName(), nil
   692  	})
   693  	if err != nil {
   694  		ec.Error(ctx, err)
   695  		return graphql.Null
   696  	}
   697  	if resTmp == nil {
   698  		if !graphql.HasFieldError(ctx, fc) {
   699  			ec.Errorf(ctx, "must not be null")
   700  		}
   701  		return graphql.Null
   702  	}
   703  	res := resTmp.(string)
   704  	fc.Result = res
   705  	return ec.marshalNString2string(ctx, field.Selections, res)
   706  }
   707  
   708  func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
   709  	defer func() {
   710  		if r := recover(); r != nil {
   711  			ec.Error(ctx, ec.Recover(ctx, r))
   712  			ret = graphql.Null
   713  		}
   714  	}()
   715  	fc := &graphql.FieldContext{
   716  		Object:   "__Directive",
   717  		Field:    field,
   718  		Args:     nil,
   719  		IsMethod: false,
   720  	}
   721  
   722  	ctx = graphql.WithFieldContext(ctx, fc)
   723  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   724  		ctx = rctx // use context from middleware stack in children
   725  		return obj.Name, nil
   726  	})
   727  	if err != nil {
   728  		ec.Error(ctx, err)
   729  		return graphql.Null
   730  	}
   731  	if resTmp == nil {
   732  		if !graphql.HasFieldError(ctx, fc) {
   733  			ec.Errorf(ctx, "must not be null")
   734  		}
   735  		return graphql.Null
   736  	}
   737  	res := resTmp.(string)
   738  	fc.Result = res
   739  	return ec.marshalNString2string(ctx, field.Selections, res)
   740  }
   741  
   742  func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
   743  	defer func() {
   744  		if r := recover(); r != nil {
   745  			ec.Error(ctx, ec.Recover(ctx, r))
   746  			ret = graphql.Null
   747  		}
   748  	}()
   749  	fc := &graphql.FieldContext{
   750  		Object:   "__Directive",
   751  		Field:    field,
   752  		Args:     nil,
   753  		IsMethod: false,
   754  	}
   755  
   756  	ctx = graphql.WithFieldContext(ctx, fc)
   757  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   758  		ctx = rctx // use context from middleware stack in children
   759  		return obj.Description, nil
   760  	})
   761  	if err != nil {
   762  		ec.Error(ctx, err)
   763  		return graphql.Null
   764  	}
   765  	if resTmp == nil {
   766  		return graphql.Null
   767  	}
   768  	res := resTmp.(string)
   769  	fc.Result = res
   770  	return ec.marshalOString2string(ctx, field.Selections, res)
   771  }
   772  
   773  func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
   774  	defer func() {
   775  		if r := recover(); r != nil {
   776  			ec.Error(ctx, ec.Recover(ctx, r))
   777  			ret = graphql.Null
   778  		}
   779  	}()
   780  	fc := &graphql.FieldContext{
   781  		Object:   "__Directive",
   782  		Field:    field,
   783  		Args:     nil,
   784  		IsMethod: false,
   785  	}
   786  
   787  	ctx = graphql.WithFieldContext(ctx, fc)
   788  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   789  		ctx = rctx // use context from middleware stack in children
   790  		return obj.Locations, nil
   791  	})
   792  	if err != nil {
   793  		ec.Error(ctx, err)
   794  		return graphql.Null
   795  	}
   796  	if resTmp == nil {
   797  		if !graphql.HasFieldError(ctx, fc) {
   798  			ec.Errorf(ctx, "must not be null")
   799  		}
   800  		return graphql.Null
   801  	}
   802  	res := resTmp.([]string)
   803  	fc.Result = res
   804  	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
   805  }
   806  
   807  func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
   808  	defer func() {
   809  		if r := recover(); r != nil {
   810  			ec.Error(ctx, ec.Recover(ctx, r))
   811  			ret = graphql.Null
   812  		}
   813  	}()
   814  	fc := &graphql.FieldContext{
   815  		Object:   "__Directive",
   816  		Field:    field,
   817  		Args:     nil,
   818  		IsMethod: false,
   819  	}
   820  
   821  	ctx = graphql.WithFieldContext(ctx, fc)
   822  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   823  		ctx = rctx // use context from middleware stack in children
   824  		return obj.Args, nil
   825  	})
   826  	if err != nil {
   827  		ec.Error(ctx, err)
   828  		return graphql.Null
   829  	}
   830  	if resTmp == nil {
   831  		if !graphql.HasFieldError(ctx, fc) {
   832  			ec.Errorf(ctx, "must not be null")
   833  		}
   834  		return graphql.Null
   835  	}
   836  	res := resTmp.([]introspection.InputValue)
   837  	fc.Result = res
   838  	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
   839  }
   840  
   841  func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
   842  	defer func() {
   843  		if r := recover(); r != nil {
   844  			ec.Error(ctx, ec.Recover(ctx, r))
   845  			ret = graphql.Null
   846  		}
   847  	}()
   848  	fc := &graphql.FieldContext{
   849  		Object:   "__EnumValue",
   850  		Field:    field,
   851  		Args:     nil,
   852  		IsMethod: false,
   853  	}
   854  
   855  	ctx = graphql.WithFieldContext(ctx, fc)
   856  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   857  		ctx = rctx // use context from middleware stack in children
   858  		return obj.Name, nil
   859  	})
   860  	if err != nil {
   861  		ec.Error(ctx, err)
   862  		return graphql.Null
   863  	}
   864  	if resTmp == nil {
   865  		if !graphql.HasFieldError(ctx, fc) {
   866  			ec.Errorf(ctx, "must not be null")
   867  		}
   868  		return graphql.Null
   869  	}
   870  	res := resTmp.(string)
   871  	fc.Result = res
   872  	return ec.marshalNString2string(ctx, field.Selections, res)
   873  }
   874  
   875  func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
   876  	defer func() {
   877  		if r := recover(); r != nil {
   878  			ec.Error(ctx, ec.Recover(ctx, r))
   879  			ret = graphql.Null
   880  		}
   881  	}()
   882  	fc := &graphql.FieldContext{
   883  		Object:   "__EnumValue",
   884  		Field:    field,
   885  		Args:     nil,
   886  		IsMethod: false,
   887  	}
   888  
   889  	ctx = graphql.WithFieldContext(ctx, fc)
   890  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   891  		ctx = rctx // use context from middleware stack in children
   892  		return obj.Description, nil
   893  	})
   894  	if err != nil {
   895  		ec.Error(ctx, err)
   896  		return graphql.Null
   897  	}
   898  	if resTmp == nil {
   899  		return graphql.Null
   900  	}
   901  	res := resTmp.(string)
   902  	fc.Result = res
   903  	return ec.marshalOString2string(ctx, field.Selections, res)
   904  }
   905  
   906  func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
   907  	defer func() {
   908  		if r := recover(); r != nil {
   909  			ec.Error(ctx, ec.Recover(ctx, r))
   910  			ret = graphql.Null
   911  		}
   912  	}()
   913  	fc := &graphql.FieldContext{
   914  		Object:   "__EnumValue",
   915  		Field:    field,
   916  		Args:     nil,
   917  		IsMethod: true,
   918  	}
   919  
   920  	ctx = graphql.WithFieldContext(ctx, fc)
   921  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   922  		ctx = rctx // use context from middleware stack in children
   923  		return obj.IsDeprecated(), nil
   924  	})
   925  	if err != nil {
   926  		ec.Error(ctx, err)
   927  		return graphql.Null
   928  	}
   929  	if resTmp == nil {
   930  		if !graphql.HasFieldError(ctx, fc) {
   931  			ec.Errorf(ctx, "must not be null")
   932  		}
   933  		return graphql.Null
   934  	}
   935  	res := resTmp.(bool)
   936  	fc.Result = res
   937  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
   938  }
   939  
   940  func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
   941  	defer func() {
   942  		if r := recover(); r != nil {
   943  			ec.Error(ctx, ec.Recover(ctx, r))
   944  			ret = graphql.Null
   945  		}
   946  	}()
   947  	fc := &graphql.FieldContext{
   948  		Object:   "__EnumValue",
   949  		Field:    field,
   950  		Args:     nil,
   951  		IsMethod: true,
   952  	}
   953  
   954  	ctx = graphql.WithFieldContext(ctx, fc)
   955  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   956  		ctx = rctx // use context from middleware stack in children
   957  		return obj.DeprecationReason(), nil
   958  	})
   959  	if err != nil {
   960  		ec.Error(ctx, err)
   961  		return graphql.Null
   962  	}
   963  	if resTmp == nil {
   964  		return graphql.Null
   965  	}
   966  	res := resTmp.(*string)
   967  	fc.Result = res
   968  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
   969  }
   970  
   971  func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
   972  	defer func() {
   973  		if r := recover(); r != nil {
   974  			ec.Error(ctx, ec.Recover(ctx, r))
   975  			ret = graphql.Null
   976  		}
   977  	}()
   978  	fc := &graphql.FieldContext{
   979  		Object:   "__Field",
   980  		Field:    field,
   981  		Args:     nil,
   982  		IsMethod: false,
   983  	}
   984  
   985  	ctx = graphql.WithFieldContext(ctx, fc)
   986  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
   987  		ctx = rctx // use context from middleware stack in children
   988  		return obj.Name, nil
   989  	})
   990  	if err != nil {
   991  		ec.Error(ctx, err)
   992  		return graphql.Null
   993  	}
   994  	if resTmp == nil {
   995  		if !graphql.HasFieldError(ctx, fc) {
   996  			ec.Errorf(ctx, "must not be null")
   997  		}
   998  		return graphql.Null
   999  	}
  1000  	res := resTmp.(string)
  1001  	fc.Result = res
  1002  	return ec.marshalNString2string(ctx, field.Selections, res)
  1003  }
  1004  
  1005  func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1006  	defer func() {
  1007  		if r := recover(); r != nil {
  1008  			ec.Error(ctx, ec.Recover(ctx, r))
  1009  			ret = graphql.Null
  1010  		}
  1011  	}()
  1012  	fc := &graphql.FieldContext{
  1013  		Object:   "__Field",
  1014  		Field:    field,
  1015  		Args:     nil,
  1016  		IsMethod: false,
  1017  	}
  1018  
  1019  	ctx = graphql.WithFieldContext(ctx, fc)
  1020  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1021  		ctx = rctx // use context from middleware stack in children
  1022  		return obj.Description, nil
  1023  	})
  1024  	if err != nil {
  1025  		ec.Error(ctx, err)
  1026  		return graphql.Null
  1027  	}
  1028  	if resTmp == nil {
  1029  		return graphql.Null
  1030  	}
  1031  	res := resTmp.(string)
  1032  	fc.Result = res
  1033  	return ec.marshalOString2string(ctx, field.Selections, res)
  1034  }
  1035  
  1036  func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1037  	defer func() {
  1038  		if r := recover(); r != nil {
  1039  			ec.Error(ctx, ec.Recover(ctx, r))
  1040  			ret = graphql.Null
  1041  		}
  1042  	}()
  1043  	fc := &graphql.FieldContext{
  1044  		Object:   "__Field",
  1045  		Field:    field,
  1046  		Args:     nil,
  1047  		IsMethod: false,
  1048  	}
  1049  
  1050  	ctx = graphql.WithFieldContext(ctx, fc)
  1051  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1052  		ctx = rctx // use context from middleware stack in children
  1053  		return obj.Args, nil
  1054  	})
  1055  	if err != nil {
  1056  		ec.Error(ctx, err)
  1057  		return graphql.Null
  1058  	}
  1059  	if resTmp == nil {
  1060  		if !graphql.HasFieldError(ctx, fc) {
  1061  			ec.Errorf(ctx, "must not be null")
  1062  		}
  1063  		return graphql.Null
  1064  	}
  1065  	res := resTmp.([]introspection.InputValue)
  1066  	fc.Result = res
  1067  	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  1068  }
  1069  
  1070  func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1071  	defer func() {
  1072  		if r := recover(); r != nil {
  1073  			ec.Error(ctx, ec.Recover(ctx, r))
  1074  			ret = graphql.Null
  1075  		}
  1076  	}()
  1077  	fc := &graphql.FieldContext{
  1078  		Object:   "__Field",
  1079  		Field:    field,
  1080  		Args:     nil,
  1081  		IsMethod: false,
  1082  	}
  1083  
  1084  	ctx = graphql.WithFieldContext(ctx, fc)
  1085  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1086  		ctx = rctx // use context from middleware stack in children
  1087  		return obj.Type, nil
  1088  	})
  1089  	if err != nil {
  1090  		ec.Error(ctx, err)
  1091  		return graphql.Null
  1092  	}
  1093  	if resTmp == nil {
  1094  		if !graphql.HasFieldError(ctx, fc) {
  1095  			ec.Errorf(ctx, "must not be null")
  1096  		}
  1097  		return graphql.Null
  1098  	}
  1099  	res := resTmp.(*introspection.Type)
  1100  	fc.Result = res
  1101  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1102  }
  1103  
  1104  func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1105  	defer func() {
  1106  		if r := recover(); r != nil {
  1107  			ec.Error(ctx, ec.Recover(ctx, r))
  1108  			ret = graphql.Null
  1109  		}
  1110  	}()
  1111  	fc := &graphql.FieldContext{
  1112  		Object:   "__Field",
  1113  		Field:    field,
  1114  		Args:     nil,
  1115  		IsMethod: true,
  1116  	}
  1117  
  1118  	ctx = graphql.WithFieldContext(ctx, fc)
  1119  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1120  		ctx = rctx // use context from middleware stack in children
  1121  		return obj.IsDeprecated(), nil
  1122  	})
  1123  	if err != nil {
  1124  		ec.Error(ctx, err)
  1125  		return graphql.Null
  1126  	}
  1127  	if resTmp == nil {
  1128  		if !graphql.HasFieldError(ctx, fc) {
  1129  			ec.Errorf(ctx, "must not be null")
  1130  		}
  1131  		return graphql.Null
  1132  	}
  1133  	res := resTmp.(bool)
  1134  	fc.Result = res
  1135  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1136  }
  1137  
  1138  func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
  1139  	defer func() {
  1140  		if r := recover(); r != nil {
  1141  			ec.Error(ctx, ec.Recover(ctx, r))
  1142  			ret = graphql.Null
  1143  		}
  1144  	}()
  1145  	fc := &graphql.FieldContext{
  1146  		Object:   "__Field",
  1147  		Field:    field,
  1148  		Args:     nil,
  1149  		IsMethod: true,
  1150  	}
  1151  
  1152  	ctx = graphql.WithFieldContext(ctx, fc)
  1153  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1154  		ctx = rctx // use context from middleware stack in children
  1155  		return obj.DeprecationReason(), nil
  1156  	})
  1157  	if err != nil {
  1158  		ec.Error(ctx, err)
  1159  		return graphql.Null
  1160  	}
  1161  	if resTmp == nil {
  1162  		return graphql.Null
  1163  	}
  1164  	res := resTmp.(*string)
  1165  	fc.Result = res
  1166  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1167  }
  1168  
  1169  func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  1170  	defer func() {
  1171  		if r := recover(); r != nil {
  1172  			ec.Error(ctx, ec.Recover(ctx, r))
  1173  			ret = graphql.Null
  1174  		}
  1175  	}()
  1176  	fc := &graphql.FieldContext{
  1177  		Object:   "__InputValue",
  1178  		Field:    field,
  1179  		Args:     nil,
  1180  		IsMethod: false,
  1181  	}
  1182  
  1183  	ctx = graphql.WithFieldContext(ctx, fc)
  1184  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1185  		ctx = rctx // use context from middleware stack in children
  1186  		return obj.Name, nil
  1187  	})
  1188  	if err != nil {
  1189  		ec.Error(ctx, err)
  1190  		return graphql.Null
  1191  	}
  1192  	if resTmp == nil {
  1193  		if !graphql.HasFieldError(ctx, fc) {
  1194  			ec.Errorf(ctx, "must not be null")
  1195  		}
  1196  		return graphql.Null
  1197  	}
  1198  	res := resTmp.(string)
  1199  	fc.Result = res
  1200  	return ec.marshalNString2string(ctx, field.Selections, res)
  1201  }
  1202  
  1203  func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  1204  	defer func() {
  1205  		if r := recover(); r != nil {
  1206  			ec.Error(ctx, ec.Recover(ctx, r))
  1207  			ret = graphql.Null
  1208  		}
  1209  	}()
  1210  	fc := &graphql.FieldContext{
  1211  		Object:   "__InputValue",
  1212  		Field:    field,
  1213  		Args:     nil,
  1214  		IsMethod: false,
  1215  	}
  1216  
  1217  	ctx = graphql.WithFieldContext(ctx, fc)
  1218  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1219  		ctx = rctx // use context from middleware stack in children
  1220  		return obj.Description, nil
  1221  	})
  1222  	if err != nil {
  1223  		ec.Error(ctx, err)
  1224  		return graphql.Null
  1225  	}
  1226  	if resTmp == nil {
  1227  		return graphql.Null
  1228  	}
  1229  	res := resTmp.(string)
  1230  	fc.Result = res
  1231  	return ec.marshalOString2string(ctx, field.Selections, res)
  1232  }
  1233  
  1234  func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  1235  	defer func() {
  1236  		if r := recover(); r != nil {
  1237  			ec.Error(ctx, ec.Recover(ctx, r))
  1238  			ret = graphql.Null
  1239  		}
  1240  	}()
  1241  	fc := &graphql.FieldContext{
  1242  		Object:   "__InputValue",
  1243  		Field:    field,
  1244  		Args:     nil,
  1245  		IsMethod: false,
  1246  	}
  1247  
  1248  	ctx = graphql.WithFieldContext(ctx, fc)
  1249  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1250  		ctx = rctx // use context from middleware stack in children
  1251  		return obj.Type, nil
  1252  	})
  1253  	if err != nil {
  1254  		ec.Error(ctx, err)
  1255  		return graphql.Null
  1256  	}
  1257  	if resTmp == nil {
  1258  		if !graphql.HasFieldError(ctx, fc) {
  1259  			ec.Errorf(ctx, "must not be null")
  1260  		}
  1261  		return graphql.Null
  1262  	}
  1263  	res := resTmp.(*introspection.Type)
  1264  	fc.Result = res
  1265  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1266  }
  1267  
  1268  func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
  1269  	defer func() {
  1270  		if r := recover(); r != nil {
  1271  			ec.Error(ctx, ec.Recover(ctx, r))
  1272  			ret = graphql.Null
  1273  		}
  1274  	}()
  1275  	fc := &graphql.FieldContext{
  1276  		Object:   "__InputValue",
  1277  		Field:    field,
  1278  		Args:     nil,
  1279  		IsMethod: false,
  1280  	}
  1281  
  1282  	ctx = graphql.WithFieldContext(ctx, fc)
  1283  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1284  		ctx = rctx // use context from middleware stack in children
  1285  		return obj.DefaultValue, nil
  1286  	})
  1287  	if err != nil {
  1288  		ec.Error(ctx, err)
  1289  		return graphql.Null
  1290  	}
  1291  	if resTmp == nil {
  1292  		return graphql.Null
  1293  	}
  1294  	res := resTmp.(*string)
  1295  	fc.Result = res
  1296  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1297  }
  1298  
  1299  func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  1300  	defer func() {
  1301  		if r := recover(); r != nil {
  1302  			ec.Error(ctx, ec.Recover(ctx, r))
  1303  			ret = graphql.Null
  1304  		}
  1305  	}()
  1306  	fc := &graphql.FieldContext{
  1307  		Object:   "__Schema",
  1308  		Field:    field,
  1309  		Args:     nil,
  1310  		IsMethod: true,
  1311  	}
  1312  
  1313  	ctx = graphql.WithFieldContext(ctx, fc)
  1314  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1315  		ctx = rctx // use context from middleware stack in children
  1316  		return obj.Types(), nil
  1317  	})
  1318  	if err != nil {
  1319  		ec.Error(ctx, err)
  1320  		return graphql.Null
  1321  	}
  1322  	if resTmp == nil {
  1323  		if !graphql.HasFieldError(ctx, fc) {
  1324  			ec.Errorf(ctx, "must not be null")
  1325  		}
  1326  		return graphql.Null
  1327  	}
  1328  	res := resTmp.([]introspection.Type)
  1329  	fc.Result = res
  1330  	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  1331  }
  1332  
  1333  func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  1334  	defer func() {
  1335  		if r := recover(); r != nil {
  1336  			ec.Error(ctx, ec.Recover(ctx, r))
  1337  			ret = graphql.Null
  1338  		}
  1339  	}()
  1340  	fc := &graphql.FieldContext{
  1341  		Object:   "__Schema",
  1342  		Field:    field,
  1343  		Args:     nil,
  1344  		IsMethod: true,
  1345  	}
  1346  
  1347  	ctx = graphql.WithFieldContext(ctx, fc)
  1348  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1349  		ctx = rctx // use context from middleware stack in children
  1350  		return obj.QueryType(), nil
  1351  	})
  1352  	if err != nil {
  1353  		ec.Error(ctx, err)
  1354  		return graphql.Null
  1355  	}
  1356  	if resTmp == nil {
  1357  		if !graphql.HasFieldError(ctx, fc) {
  1358  			ec.Errorf(ctx, "must not be null")
  1359  		}
  1360  		return graphql.Null
  1361  	}
  1362  	res := resTmp.(*introspection.Type)
  1363  	fc.Result = res
  1364  	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1365  }
  1366  
  1367  func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  1368  	defer func() {
  1369  		if r := recover(); r != nil {
  1370  			ec.Error(ctx, ec.Recover(ctx, r))
  1371  			ret = graphql.Null
  1372  		}
  1373  	}()
  1374  	fc := &graphql.FieldContext{
  1375  		Object:   "__Schema",
  1376  		Field:    field,
  1377  		Args:     nil,
  1378  		IsMethod: true,
  1379  	}
  1380  
  1381  	ctx = graphql.WithFieldContext(ctx, fc)
  1382  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1383  		ctx = rctx // use context from middleware stack in children
  1384  		return obj.MutationType(), nil
  1385  	})
  1386  	if err != nil {
  1387  		ec.Error(ctx, err)
  1388  		return graphql.Null
  1389  	}
  1390  	if resTmp == nil {
  1391  		return graphql.Null
  1392  	}
  1393  	res := resTmp.(*introspection.Type)
  1394  	fc.Result = res
  1395  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1396  }
  1397  
  1398  func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  1399  	defer func() {
  1400  		if r := recover(); r != nil {
  1401  			ec.Error(ctx, ec.Recover(ctx, r))
  1402  			ret = graphql.Null
  1403  		}
  1404  	}()
  1405  	fc := &graphql.FieldContext{
  1406  		Object:   "__Schema",
  1407  		Field:    field,
  1408  		Args:     nil,
  1409  		IsMethod: true,
  1410  	}
  1411  
  1412  	ctx = graphql.WithFieldContext(ctx, fc)
  1413  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1414  		ctx = rctx // use context from middleware stack in children
  1415  		return obj.SubscriptionType(), nil
  1416  	})
  1417  	if err != nil {
  1418  		ec.Error(ctx, err)
  1419  		return graphql.Null
  1420  	}
  1421  	if resTmp == nil {
  1422  		return graphql.Null
  1423  	}
  1424  	res := resTmp.(*introspection.Type)
  1425  	fc.Result = res
  1426  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1427  }
  1428  
  1429  func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
  1430  	defer func() {
  1431  		if r := recover(); r != nil {
  1432  			ec.Error(ctx, ec.Recover(ctx, r))
  1433  			ret = graphql.Null
  1434  		}
  1435  	}()
  1436  	fc := &graphql.FieldContext{
  1437  		Object:   "__Schema",
  1438  		Field:    field,
  1439  		Args:     nil,
  1440  		IsMethod: true,
  1441  	}
  1442  
  1443  	ctx = graphql.WithFieldContext(ctx, fc)
  1444  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1445  		ctx = rctx // use context from middleware stack in children
  1446  		return obj.Directives(), nil
  1447  	})
  1448  	if err != nil {
  1449  		ec.Error(ctx, err)
  1450  		return graphql.Null
  1451  	}
  1452  	if resTmp == nil {
  1453  		if !graphql.HasFieldError(ctx, fc) {
  1454  			ec.Errorf(ctx, "must not be null")
  1455  		}
  1456  		return graphql.Null
  1457  	}
  1458  	res := resTmp.([]introspection.Directive)
  1459  	fc.Result = res
  1460  	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
  1461  }
  1462  
  1463  func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1464  	defer func() {
  1465  		if r := recover(); r != nil {
  1466  			ec.Error(ctx, ec.Recover(ctx, r))
  1467  			ret = graphql.Null
  1468  		}
  1469  	}()
  1470  	fc := &graphql.FieldContext{
  1471  		Object:   "__Type",
  1472  		Field:    field,
  1473  		Args:     nil,
  1474  		IsMethod: true,
  1475  	}
  1476  
  1477  	ctx = graphql.WithFieldContext(ctx, fc)
  1478  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1479  		ctx = rctx // use context from middleware stack in children
  1480  		return obj.Kind(), nil
  1481  	})
  1482  	if err != nil {
  1483  		ec.Error(ctx, err)
  1484  		return graphql.Null
  1485  	}
  1486  	if resTmp == nil {
  1487  		if !graphql.HasFieldError(ctx, fc) {
  1488  			ec.Errorf(ctx, "must not be null")
  1489  		}
  1490  		return graphql.Null
  1491  	}
  1492  	res := resTmp.(string)
  1493  	fc.Result = res
  1494  	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
  1495  }
  1496  
  1497  func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1498  	defer func() {
  1499  		if r := recover(); r != nil {
  1500  			ec.Error(ctx, ec.Recover(ctx, r))
  1501  			ret = graphql.Null
  1502  		}
  1503  	}()
  1504  	fc := &graphql.FieldContext{
  1505  		Object:   "__Type",
  1506  		Field:    field,
  1507  		Args:     nil,
  1508  		IsMethod: true,
  1509  	}
  1510  
  1511  	ctx = graphql.WithFieldContext(ctx, fc)
  1512  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1513  		ctx = rctx // use context from middleware stack in children
  1514  		return obj.Name(), nil
  1515  	})
  1516  	if err != nil {
  1517  		ec.Error(ctx, err)
  1518  		return graphql.Null
  1519  	}
  1520  	if resTmp == nil {
  1521  		return graphql.Null
  1522  	}
  1523  	res := resTmp.(*string)
  1524  	fc.Result = res
  1525  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1526  }
  1527  
  1528  func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1529  	defer func() {
  1530  		if r := recover(); r != nil {
  1531  			ec.Error(ctx, ec.Recover(ctx, r))
  1532  			ret = graphql.Null
  1533  		}
  1534  	}()
  1535  	fc := &graphql.FieldContext{
  1536  		Object:   "__Type",
  1537  		Field:    field,
  1538  		Args:     nil,
  1539  		IsMethod: true,
  1540  	}
  1541  
  1542  	ctx = graphql.WithFieldContext(ctx, fc)
  1543  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1544  		ctx = rctx // use context from middleware stack in children
  1545  		return obj.Description(), nil
  1546  	})
  1547  	if err != nil {
  1548  		ec.Error(ctx, err)
  1549  		return graphql.Null
  1550  	}
  1551  	if resTmp == nil {
  1552  		return graphql.Null
  1553  	}
  1554  	res := resTmp.(string)
  1555  	fc.Result = res
  1556  	return ec.marshalOString2string(ctx, field.Selections, res)
  1557  }
  1558  
  1559  func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1560  	defer func() {
  1561  		if r := recover(); r != nil {
  1562  			ec.Error(ctx, ec.Recover(ctx, r))
  1563  			ret = graphql.Null
  1564  		}
  1565  	}()
  1566  	fc := &graphql.FieldContext{
  1567  		Object:   "__Type",
  1568  		Field:    field,
  1569  		Args:     nil,
  1570  		IsMethod: true,
  1571  	}
  1572  
  1573  	ctx = graphql.WithFieldContext(ctx, fc)
  1574  	rawArgs := field.ArgumentMap(ec.Variables)
  1575  	args, err := ec.field___Type_fields_args(ctx, rawArgs)
  1576  	if err != nil {
  1577  		ec.Error(ctx, err)
  1578  		return graphql.Null
  1579  	}
  1580  	fc.Args = args
  1581  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1582  		ctx = rctx // use context from middleware stack in children
  1583  		return obj.Fields(args["includeDeprecated"].(bool)), nil
  1584  	})
  1585  	if err != nil {
  1586  		ec.Error(ctx, err)
  1587  		return graphql.Null
  1588  	}
  1589  	if resTmp == nil {
  1590  		return graphql.Null
  1591  	}
  1592  	res := resTmp.([]introspection.Field)
  1593  	fc.Result = res
  1594  	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
  1595  }
  1596  
  1597  func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1598  	defer func() {
  1599  		if r := recover(); r != nil {
  1600  			ec.Error(ctx, ec.Recover(ctx, r))
  1601  			ret = graphql.Null
  1602  		}
  1603  	}()
  1604  	fc := &graphql.FieldContext{
  1605  		Object:   "__Type",
  1606  		Field:    field,
  1607  		Args:     nil,
  1608  		IsMethod: true,
  1609  	}
  1610  
  1611  	ctx = graphql.WithFieldContext(ctx, fc)
  1612  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1613  		ctx = rctx // use context from middleware stack in children
  1614  		return obj.Interfaces(), nil
  1615  	})
  1616  	if err != nil {
  1617  		ec.Error(ctx, err)
  1618  		return graphql.Null
  1619  	}
  1620  	if resTmp == nil {
  1621  		return graphql.Null
  1622  	}
  1623  	res := resTmp.([]introspection.Type)
  1624  	fc.Result = res
  1625  	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  1626  }
  1627  
  1628  func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1629  	defer func() {
  1630  		if r := recover(); r != nil {
  1631  			ec.Error(ctx, ec.Recover(ctx, r))
  1632  			ret = graphql.Null
  1633  		}
  1634  	}()
  1635  	fc := &graphql.FieldContext{
  1636  		Object:   "__Type",
  1637  		Field:    field,
  1638  		Args:     nil,
  1639  		IsMethod: true,
  1640  	}
  1641  
  1642  	ctx = graphql.WithFieldContext(ctx, fc)
  1643  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1644  		ctx = rctx // use context from middleware stack in children
  1645  		return obj.PossibleTypes(), nil
  1646  	})
  1647  	if err != nil {
  1648  		ec.Error(ctx, err)
  1649  		return graphql.Null
  1650  	}
  1651  	if resTmp == nil {
  1652  		return graphql.Null
  1653  	}
  1654  	res := resTmp.([]introspection.Type)
  1655  	fc.Result = res
  1656  	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
  1657  }
  1658  
  1659  func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1660  	defer func() {
  1661  		if r := recover(); r != nil {
  1662  			ec.Error(ctx, ec.Recover(ctx, r))
  1663  			ret = graphql.Null
  1664  		}
  1665  	}()
  1666  	fc := &graphql.FieldContext{
  1667  		Object:   "__Type",
  1668  		Field:    field,
  1669  		Args:     nil,
  1670  		IsMethod: true,
  1671  	}
  1672  
  1673  	ctx = graphql.WithFieldContext(ctx, fc)
  1674  	rawArgs := field.ArgumentMap(ec.Variables)
  1675  	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
  1676  	if err != nil {
  1677  		ec.Error(ctx, err)
  1678  		return graphql.Null
  1679  	}
  1680  	fc.Args = args
  1681  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1682  		ctx = rctx // use context from middleware stack in children
  1683  		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
  1684  	})
  1685  	if err != nil {
  1686  		ec.Error(ctx, err)
  1687  		return graphql.Null
  1688  	}
  1689  	if resTmp == nil {
  1690  		return graphql.Null
  1691  	}
  1692  	res := resTmp.([]introspection.EnumValue)
  1693  	fc.Result = res
  1694  	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
  1695  }
  1696  
  1697  func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1698  	defer func() {
  1699  		if r := recover(); r != nil {
  1700  			ec.Error(ctx, ec.Recover(ctx, r))
  1701  			ret = graphql.Null
  1702  		}
  1703  	}()
  1704  	fc := &graphql.FieldContext{
  1705  		Object:   "__Type",
  1706  		Field:    field,
  1707  		Args:     nil,
  1708  		IsMethod: true,
  1709  	}
  1710  
  1711  	ctx = graphql.WithFieldContext(ctx, fc)
  1712  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1713  		ctx = rctx // use context from middleware stack in children
  1714  		return obj.InputFields(), nil
  1715  	})
  1716  	if err != nil {
  1717  		ec.Error(ctx, err)
  1718  		return graphql.Null
  1719  	}
  1720  	if resTmp == nil {
  1721  		return graphql.Null
  1722  	}
  1723  	res := resTmp.([]introspection.InputValue)
  1724  	fc.Result = res
  1725  	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
  1726  }
  1727  
  1728  func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
  1729  	defer func() {
  1730  		if r := recover(); r != nil {
  1731  			ec.Error(ctx, ec.Recover(ctx, r))
  1732  			ret = graphql.Null
  1733  		}
  1734  	}()
  1735  	fc := &graphql.FieldContext{
  1736  		Object:   "__Type",
  1737  		Field:    field,
  1738  		Args:     nil,
  1739  		IsMethod: true,
  1740  	}
  1741  
  1742  	ctx = graphql.WithFieldContext(ctx, fc)
  1743  	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
  1744  		ctx = rctx // use context from middleware stack in children
  1745  		return obj.OfType(), nil
  1746  	})
  1747  	if err != nil {
  1748  		ec.Error(ctx, err)
  1749  		return graphql.Null
  1750  	}
  1751  	if resTmp == nil {
  1752  		return graphql.Null
  1753  	}
  1754  	res := resTmp.(*introspection.Type)
  1755  	fc.Result = res
  1756  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  1757  }
  1758  
  1759  // endregion **************************** field.gotpl *****************************
  1760  
  1761  // region    **************************** input.gotpl *****************************
  1762  
  1763  func (ec *executionContext) unmarshalInputNewTodo(ctx context.Context, obj interface{}) (NewTodo, error) {
  1764  	var it NewTodo
  1765  	var asMap = obj.(map[string]interface{})
  1766  
  1767  	for k, v := range asMap {
  1768  		switch k {
  1769  		case "text":
  1770  			var err error
  1771  			it.Text, err = ec.unmarshalNString2string(ctx, v)
  1772  			if err != nil {
  1773  				return it, err
  1774  			}
  1775  		case "userId":
  1776  			var err error
  1777  			it.UserID, err = ec.unmarshalNString2string(ctx, v)
  1778  			if err != nil {
  1779  				return it, err
  1780  			}
  1781  		}
  1782  	}
  1783  
  1784  	return it, nil
  1785  }
  1786  
  1787  // endregion **************************** input.gotpl *****************************
  1788  
  1789  // region    ************************** interface.gotpl ***************************
  1790  
  1791  // endregion ************************** interface.gotpl ***************************
  1792  
  1793  // region    **************************** object.gotpl ****************************
  1794  
  1795  var mutationImplementors = []string{"Mutation"}
  1796  
  1797  func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  1798  	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
  1799  
  1800  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  1801  		Object: "Mutation",
  1802  	})
  1803  
  1804  	out := graphql.NewFieldSet(fields)
  1805  	var invalids uint32
  1806  	for i, field := range fields {
  1807  		switch field.Name {
  1808  		case "__typename":
  1809  			out.Values[i] = graphql.MarshalString("Mutation")
  1810  		case "createTodo":
  1811  			out.Values[i] = ec._Mutation_createTodo(ctx, field)
  1812  			if out.Values[i] == graphql.Null {
  1813  				invalids++
  1814  			}
  1815  		default:
  1816  			panic("unknown field " + strconv.Quote(field.Name))
  1817  		}
  1818  	}
  1819  	out.Dispatch()
  1820  	if invalids > 0 {
  1821  		return graphql.Null
  1822  	}
  1823  	return out
  1824  }
  1825  
  1826  var queryImplementors = []string{"Query"}
  1827  
  1828  func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  1829  	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
  1830  
  1831  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  1832  		Object: "Query",
  1833  	})
  1834  
  1835  	out := graphql.NewFieldSet(fields)
  1836  	var invalids uint32
  1837  	for i, field := range fields {
  1838  		switch field.Name {
  1839  		case "__typename":
  1840  			out.Values[i] = graphql.MarshalString("Query")
  1841  		case "todos":
  1842  			field := field
  1843  			out.Concurrently(i, func() (res graphql.Marshaler) {
  1844  				defer func() {
  1845  					if r := recover(); r != nil {
  1846  						ec.Error(ctx, ec.Recover(ctx, r))
  1847  					}
  1848  				}()
  1849  				res = ec._Query_todos(ctx, field)
  1850  				if res == graphql.Null {
  1851  					atomic.AddUint32(&invalids, 1)
  1852  				}
  1853  				return res
  1854  			})
  1855  		case "__type":
  1856  			out.Values[i] = ec._Query___type(ctx, field)
  1857  		case "__schema":
  1858  			out.Values[i] = ec._Query___schema(ctx, field)
  1859  		default:
  1860  			panic("unknown field " + strconv.Quote(field.Name))
  1861  		}
  1862  	}
  1863  	out.Dispatch()
  1864  	if invalids > 0 {
  1865  		return graphql.Null
  1866  	}
  1867  	return out
  1868  }
  1869  
  1870  var todoImplementors = []string{"Todo"}
  1871  
  1872  func (ec *executionContext) _Todo(ctx context.Context, sel ast.SelectionSet, obj *Todo) graphql.Marshaler {
  1873  	fields := graphql.CollectFields(ec.OperationContext, sel, todoImplementors)
  1874  
  1875  	out := graphql.NewFieldSet(fields)
  1876  	var invalids uint32
  1877  	for i, field := range fields {
  1878  		switch field.Name {
  1879  		case "__typename":
  1880  			out.Values[i] = graphql.MarshalString("Todo")
  1881  		case "id":
  1882  			field := field
  1883  			out.Concurrently(i, func() (res graphql.Marshaler) {
  1884  				defer func() {
  1885  					if r := recover(); r != nil {
  1886  						ec.Error(ctx, ec.Recover(ctx, r))
  1887  					}
  1888  				}()
  1889  				res = ec._Todo_id(ctx, field, obj)
  1890  				if res == graphql.Null {
  1891  					atomic.AddUint32(&invalids, 1)
  1892  				}
  1893  				return res
  1894  			})
  1895  		case "databaseId":
  1896  			out.Values[i] = ec._Todo_databaseId(ctx, field, obj)
  1897  			if out.Values[i] == graphql.Null {
  1898  				atomic.AddUint32(&invalids, 1)
  1899  			}
  1900  		case "text":
  1901  			out.Values[i] = ec._Todo_text(ctx, field, obj)
  1902  			if out.Values[i] == graphql.Null {
  1903  				atomic.AddUint32(&invalids, 1)
  1904  			}
  1905  		case "done":
  1906  			out.Values[i] = ec._Todo_done(ctx, field, obj)
  1907  			if out.Values[i] == graphql.Null {
  1908  				atomic.AddUint32(&invalids, 1)
  1909  			}
  1910  		case "user":
  1911  			out.Values[i] = ec._Todo_user(ctx, field, obj)
  1912  			if out.Values[i] == graphql.Null {
  1913  				atomic.AddUint32(&invalids, 1)
  1914  			}
  1915  		default:
  1916  			panic("unknown field " + strconv.Quote(field.Name))
  1917  		}
  1918  	}
  1919  	out.Dispatch()
  1920  	if invalids > 0 {
  1921  		return graphql.Null
  1922  	}
  1923  	return out
  1924  }
  1925  
  1926  var userImplementors = []string{"User"}
  1927  
  1928  func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler {
  1929  	fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)
  1930  
  1931  	out := graphql.NewFieldSet(fields)
  1932  	var invalids uint32
  1933  	for i, field := range fields {
  1934  		switch field.Name {
  1935  		case "__typename":
  1936  			out.Values[i] = graphql.MarshalString("User")
  1937  		case "id":
  1938  			out.Values[i] = ec._User_id(ctx, field, obj)
  1939  			if out.Values[i] == graphql.Null {
  1940  				invalids++
  1941  			}
  1942  		case "name":
  1943  			out.Values[i] = ec._User_name(ctx, field, obj)
  1944  			if out.Values[i] == graphql.Null {
  1945  				invalids++
  1946  			}
  1947  		default:
  1948  			panic("unknown field " + strconv.Quote(field.Name))
  1949  		}
  1950  	}
  1951  	out.Dispatch()
  1952  	if invalids > 0 {
  1953  		return graphql.Null
  1954  	}
  1955  	return out
  1956  }
  1957  
  1958  var __DirectiveImplementors = []string{"__Directive"}
  1959  
  1960  func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
  1961  	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
  1962  
  1963  	out := graphql.NewFieldSet(fields)
  1964  	var invalids uint32
  1965  	for i, field := range fields {
  1966  		switch field.Name {
  1967  		case "__typename":
  1968  			out.Values[i] = graphql.MarshalString("__Directive")
  1969  		case "name":
  1970  			out.Values[i] = ec.___Directive_name(ctx, field, obj)
  1971  			if out.Values[i] == graphql.Null {
  1972  				invalids++
  1973  			}
  1974  		case "description":
  1975  			out.Values[i] = ec.___Directive_description(ctx, field, obj)
  1976  		case "locations":
  1977  			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
  1978  			if out.Values[i] == graphql.Null {
  1979  				invalids++
  1980  			}
  1981  		case "args":
  1982  			out.Values[i] = ec.___Directive_args(ctx, field, obj)
  1983  			if out.Values[i] == graphql.Null {
  1984  				invalids++
  1985  			}
  1986  		default:
  1987  			panic("unknown field " + strconv.Quote(field.Name))
  1988  		}
  1989  	}
  1990  	out.Dispatch()
  1991  	if invalids > 0 {
  1992  		return graphql.Null
  1993  	}
  1994  	return out
  1995  }
  1996  
  1997  var __EnumValueImplementors = []string{"__EnumValue"}
  1998  
  1999  func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
  2000  	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
  2001  
  2002  	out := graphql.NewFieldSet(fields)
  2003  	var invalids uint32
  2004  	for i, field := range fields {
  2005  		switch field.Name {
  2006  		case "__typename":
  2007  			out.Values[i] = graphql.MarshalString("__EnumValue")
  2008  		case "name":
  2009  			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
  2010  			if out.Values[i] == graphql.Null {
  2011  				invalids++
  2012  			}
  2013  		case "description":
  2014  			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
  2015  		case "isDeprecated":
  2016  			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
  2017  			if out.Values[i] == graphql.Null {
  2018  				invalids++
  2019  			}
  2020  		case "deprecationReason":
  2021  			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
  2022  		default:
  2023  			panic("unknown field " + strconv.Quote(field.Name))
  2024  		}
  2025  	}
  2026  	out.Dispatch()
  2027  	if invalids > 0 {
  2028  		return graphql.Null
  2029  	}
  2030  	return out
  2031  }
  2032  
  2033  var __FieldImplementors = []string{"__Field"}
  2034  
  2035  func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
  2036  	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
  2037  
  2038  	out := graphql.NewFieldSet(fields)
  2039  	var invalids uint32
  2040  	for i, field := range fields {
  2041  		switch field.Name {
  2042  		case "__typename":
  2043  			out.Values[i] = graphql.MarshalString("__Field")
  2044  		case "name":
  2045  			out.Values[i] = ec.___Field_name(ctx, field, obj)
  2046  			if out.Values[i] == graphql.Null {
  2047  				invalids++
  2048  			}
  2049  		case "description":
  2050  			out.Values[i] = ec.___Field_description(ctx, field, obj)
  2051  		case "args":
  2052  			out.Values[i] = ec.___Field_args(ctx, field, obj)
  2053  			if out.Values[i] == graphql.Null {
  2054  				invalids++
  2055  			}
  2056  		case "type":
  2057  			out.Values[i] = ec.___Field_type(ctx, field, obj)
  2058  			if out.Values[i] == graphql.Null {
  2059  				invalids++
  2060  			}
  2061  		case "isDeprecated":
  2062  			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
  2063  			if out.Values[i] == graphql.Null {
  2064  				invalids++
  2065  			}
  2066  		case "deprecationReason":
  2067  			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
  2068  		default:
  2069  			panic("unknown field " + strconv.Quote(field.Name))
  2070  		}
  2071  	}
  2072  	out.Dispatch()
  2073  	if invalids > 0 {
  2074  		return graphql.Null
  2075  	}
  2076  	return out
  2077  }
  2078  
  2079  var __InputValueImplementors = []string{"__InputValue"}
  2080  
  2081  func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
  2082  	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
  2083  
  2084  	out := graphql.NewFieldSet(fields)
  2085  	var invalids uint32
  2086  	for i, field := range fields {
  2087  		switch field.Name {
  2088  		case "__typename":
  2089  			out.Values[i] = graphql.MarshalString("__InputValue")
  2090  		case "name":
  2091  			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
  2092  			if out.Values[i] == graphql.Null {
  2093  				invalids++
  2094  			}
  2095  		case "description":
  2096  			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
  2097  		case "type":
  2098  			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
  2099  			if out.Values[i] == graphql.Null {
  2100  				invalids++
  2101  			}
  2102  		case "defaultValue":
  2103  			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
  2104  		default:
  2105  			panic("unknown field " + strconv.Quote(field.Name))
  2106  		}
  2107  	}
  2108  	out.Dispatch()
  2109  	if invalids > 0 {
  2110  		return graphql.Null
  2111  	}
  2112  	return out
  2113  }
  2114  
  2115  var __SchemaImplementors = []string{"__Schema"}
  2116  
  2117  func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
  2118  	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
  2119  
  2120  	out := graphql.NewFieldSet(fields)
  2121  	var invalids uint32
  2122  	for i, field := range fields {
  2123  		switch field.Name {
  2124  		case "__typename":
  2125  			out.Values[i] = graphql.MarshalString("__Schema")
  2126  		case "types":
  2127  			out.Values[i] = ec.___Schema_types(ctx, field, obj)
  2128  			if out.Values[i] == graphql.Null {
  2129  				invalids++
  2130  			}
  2131  		case "queryType":
  2132  			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
  2133  			if out.Values[i] == graphql.Null {
  2134  				invalids++
  2135  			}
  2136  		case "mutationType":
  2137  			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
  2138  		case "subscriptionType":
  2139  			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
  2140  		case "directives":
  2141  			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
  2142  			if out.Values[i] == graphql.Null {
  2143  				invalids++
  2144  			}
  2145  		default:
  2146  			panic("unknown field " + strconv.Quote(field.Name))
  2147  		}
  2148  	}
  2149  	out.Dispatch()
  2150  	if invalids > 0 {
  2151  		return graphql.Null
  2152  	}
  2153  	return out
  2154  }
  2155  
  2156  var __TypeImplementors = []string{"__Type"}
  2157  
  2158  func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
  2159  	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
  2160  
  2161  	out := graphql.NewFieldSet(fields)
  2162  	var invalids uint32
  2163  	for i, field := range fields {
  2164  		switch field.Name {
  2165  		case "__typename":
  2166  			out.Values[i] = graphql.MarshalString("__Type")
  2167  		case "kind":
  2168  			out.Values[i] = ec.___Type_kind(ctx, field, obj)
  2169  			if out.Values[i] == graphql.Null {
  2170  				invalids++
  2171  			}
  2172  		case "name":
  2173  			out.Values[i] = ec.___Type_name(ctx, field, obj)
  2174  		case "description":
  2175  			out.Values[i] = ec.___Type_description(ctx, field, obj)
  2176  		case "fields":
  2177  			out.Values[i] = ec.___Type_fields(ctx, field, obj)
  2178  		case "interfaces":
  2179  			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
  2180  		case "possibleTypes":
  2181  			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
  2182  		case "enumValues":
  2183  			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
  2184  		case "inputFields":
  2185  			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
  2186  		case "ofType":
  2187  			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
  2188  		default:
  2189  			panic("unknown field " + strconv.Quote(field.Name))
  2190  		}
  2191  	}
  2192  	out.Dispatch()
  2193  	if invalids > 0 {
  2194  		return graphql.Null
  2195  	}
  2196  	return out
  2197  }
  2198  
  2199  // endregion **************************** object.gotpl ****************************
  2200  
  2201  // region    ***************************** type.gotpl *****************************
  2202  
  2203  func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
  2204  	return graphql.UnmarshalBoolean(v)
  2205  }
  2206  
  2207  func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
  2208  	res := graphql.MarshalBoolean(v)
  2209  	if res == graphql.Null {
  2210  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2211  			ec.Errorf(ctx, "must not be null")
  2212  		}
  2213  	}
  2214  	return res
  2215  }
  2216  
  2217  func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) {
  2218  	return graphql.UnmarshalID(v)
  2219  }
  2220  
  2221  func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  2222  	res := graphql.MarshalID(v)
  2223  	if res == graphql.Null {
  2224  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2225  			ec.Errorf(ctx, "must not be null")
  2226  		}
  2227  	}
  2228  	return res
  2229  }
  2230  
  2231  func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
  2232  	return graphql.UnmarshalInt(v)
  2233  }
  2234  
  2235  func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
  2236  	res := graphql.MarshalInt(v)
  2237  	if res == graphql.Null {
  2238  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2239  			ec.Errorf(ctx, "must not be null")
  2240  		}
  2241  	}
  2242  	return res
  2243  }
  2244  
  2245  func (ec *executionContext) unmarshalNNewTodo2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐNewTodo(ctx context.Context, v interface{}) (NewTodo, error) {
  2246  	return ec.unmarshalInputNewTodo(ctx, v)
  2247  }
  2248  
  2249  func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
  2250  	return graphql.UnmarshalString(v)
  2251  }
  2252  
  2253  func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  2254  	res := graphql.MarshalString(v)
  2255  	if res == graphql.Null {
  2256  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2257  			ec.Errorf(ctx, "must not be null")
  2258  		}
  2259  	}
  2260  	return res
  2261  }
  2262  
  2263  func (ec *executionContext) marshalNTodo2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx context.Context, sel ast.SelectionSet, v Todo) graphql.Marshaler {
  2264  	return ec._Todo(ctx, sel, &v)
  2265  }
  2266  
  2267  func (ec *executionContext) marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodoᚄ(ctx context.Context, sel ast.SelectionSet, v []*Todo) graphql.Marshaler {
  2268  	ret := make(graphql.Array, len(v))
  2269  	var wg sync.WaitGroup
  2270  	isLen1 := len(v) == 1
  2271  	if !isLen1 {
  2272  		wg.Add(len(v))
  2273  	}
  2274  	for i := range v {
  2275  		i := i
  2276  		fc := &graphql.FieldContext{
  2277  			Index:  &i,
  2278  			Result: &v[i],
  2279  		}
  2280  		ctx := graphql.WithFieldContext(ctx, fc)
  2281  		f := func(i int) {
  2282  			defer func() {
  2283  				if r := recover(); r != nil {
  2284  					ec.Error(ctx, ec.Recover(ctx, r))
  2285  					ret = nil
  2286  				}
  2287  			}()
  2288  			if !isLen1 {
  2289  				defer wg.Done()
  2290  			}
  2291  			ret[i] = ec.marshalNTodo2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx, sel, v[i])
  2292  		}
  2293  		if isLen1 {
  2294  			f(i)
  2295  		} else {
  2296  			go f(i)
  2297  		}
  2298  
  2299  	}
  2300  	wg.Wait()
  2301  	return ret
  2302  }
  2303  
  2304  func (ec *executionContext) marshalNTodo2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx context.Context, sel ast.SelectionSet, v *Todo) graphql.Marshaler {
  2305  	if v == nil {
  2306  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2307  			ec.Errorf(ctx, "must not be null")
  2308  		}
  2309  		return graphql.Null
  2310  	}
  2311  	return ec._Todo(ctx, sel, v)
  2312  }
  2313  
  2314  func (ec *executionContext) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler {
  2315  	return ec._User(ctx, sel, &v)
  2316  }
  2317  
  2318  func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
  2319  	if v == nil {
  2320  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2321  			ec.Errorf(ctx, "must not be null")
  2322  		}
  2323  		return graphql.Null
  2324  	}
  2325  	return ec._User(ctx, sel, v)
  2326  }
  2327  
  2328  func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
  2329  	return ec.___Directive(ctx, sel, &v)
  2330  }
  2331  
  2332  func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
  2333  	ret := make(graphql.Array, len(v))
  2334  	var wg sync.WaitGroup
  2335  	isLen1 := len(v) == 1
  2336  	if !isLen1 {
  2337  		wg.Add(len(v))
  2338  	}
  2339  	for i := range v {
  2340  		i := i
  2341  		fc := &graphql.FieldContext{
  2342  			Index:  &i,
  2343  			Result: &v[i],
  2344  		}
  2345  		ctx := graphql.WithFieldContext(ctx, fc)
  2346  		f := func(i int) {
  2347  			defer func() {
  2348  				if r := recover(); r != nil {
  2349  					ec.Error(ctx, ec.Recover(ctx, r))
  2350  					ret = nil
  2351  				}
  2352  			}()
  2353  			if !isLen1 {
  2354  				defer wg.Done()
  2355  			}
  2356  			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
  2357  		}
  2358  		if isLen1 {
  2359  			f(i)
  2360  		} else {
  2361  			go f(i)
  2362  		}
  2363  
  2364  	}
  2365  	wg.Wait()
  2366  	return ret
  2367  }
  2368  
  2369  func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
  2370  	return graphql.UnmarshalString(v)
  2371  }
  2372  
  2373  func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  2374  	res := graphql.MarshalString(v)
  2375  	if res == graphql.Null {
  2376  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2377  			ec.Errorf(ctx, "must not be null")
  2378  		}
  2379  	}
  2380  	return res
  2381  }
  2382  
  2383  func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
  2384  	var vSlice []interface{}
  2385  	if v != nil {
  2386  		if tmp1, ok := v.([]interface{}); ok {
  2387  			vSlice = tmp1
  2388  		} else {
  2389  			vSlice = []interface{}{v}
  2390  		}
  2391  	}
  2392  	var err error
  2393  	res := make([]string, len(vSlice))
  2394  	for i := range vSlice {
  2395  		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
  2396  		if err != nil {
  2397  			return nil, err
  2398  		}
  2399  	}
  2400  	return res, nil
  2401  }
  2402  
  2403  func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
  2404  	ret := make(graphql.Array, len(v))
  2405  	var wg sync.WaitGroup
  2406  	isLen1 := len(v) == 1
  2407  	if !isLen1 {
  2408  		wg.Add(len(v))
  2409  	}
  2410  	for i := range v {
  2411  		i := i
  2412  		fc := &graphql.FieldContext{
  2413  			Index:  &i,
  2414  			Result: &v[i],
  2415  		}
  2416  		ctx := graphql.WithFieldContext(ctx, fc)
  2417  		f := func(i int) {
  2418  			defer func() {
  2419  				if r := recover(); r != nil {
  2420  					ec.Error(ctx, ec.Recover(ctx, r))
  2421  					ret = nil
  2422  				}
  2423  			}()
  2424  			if !isLen1 {
  2425  				defer wg.Done()
  2426  			}
  2427  			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
  2428  		}
  2429  		if isLen1 {
  2430  			f(i)
  2431  		} else {
  2432  			go f(i)
  2433  		}
  2434  
  2435  	}
  2436  	wg.Wait()
  2437  	return ret
  2438  }
  2439  
  2440  func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
  2441  	return ec.___EnumValue(ctx, sel, &v)
  2442  }
  2443  
  2444  func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
  2445  	return ec.___Field(ctx, sel, &v)
  2446  }
  2447  
  2448  func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
  2449  	return ec.___InputValue(ctx, sel, &v)
  2450  }
  2451  
  2452  func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
  2453  	ret := make(graphql.Array, len(v))
  2454  	var wg sync.WaitGroup
  2455  	isLen1 := len(v) == 1
  2456  	if !isLen1 {
  2457  		wg.Add(len(v))
  2458  	}
  2459  	for i := range v {
  2460  		i := i
  2461  		fc := &graphql.FieldContext{
  2462  			Index:  &i,
  2463  			Result: &v[i],
  2464  		}
  2465  		ctx := graphql.WithFieldContext(ctx, fc)
  2466  		f := func(i int) {
  2467  			defer func() {
  2468  				if r := recover(); r != nil {
  2469  					ec.Error(ctx, ec.Recover(ctx, r))
  2470  					ret = nil
  2471  				}
  2472  			}()
  2473  			if !isLen1 {
  2474  				defer wg.Done()
  2475  			}
  2476  			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
  2477  		}
  2478  		if isLen1 {
  2479  			f(i)
  2480  		} else {
  2481  			go f(i)
  2482  		}
  2483  
  2484  	}
  2485  	wg.Wait()
  2486  	return ret
  2487  }
  2488  
  2489  func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
  2490  	return ec.___Type(ctx, sel, &v)
  2491  }
  2492  
  2493  func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
  2494  	ret := make(graphql.Array, len(v))
  2495  	var wg sync.WaitGroup
  2496  	isLen1 := len(v) == 1
  2497  	if !isLen1 {
  2498  		wg.Add(len(v))
  2499  	}
  2500  	for i := range v {
  2501  		i := i
  2502  		fc := &graphql.FieldContext{
  2503  			Index:  &i,
  2504  			Result: &v[i],
  2505  		}
  2506  		ctx := graphql.WithFieldContext(ctx, fc)
  2507  		f := func(i int) {
  2508  			defer func() {
  2509  				if r := recover(); r != nil {
  2510  					ec.Error(ctx, ec.Recover(ctx, r))
  2511  					ret = nil
  2512  				}
  2513  			}()
  2514  			if !isLen1 {
  2515  				defer wg.Done()
  2516  			}
  2517  			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
  2518  		}
  2519  		if isLen1 {
  2520  			f(i)
  2521  		} else {
  2522  			go f(i)
  2523  		}
  2524  
  2525  	}
  2526  	wg.Wait()
  2527  	return ret
  2528  }
  2529  
  2530  func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
  2531  	if v == nil {
  2532  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2533  			ec.Errorf(ctx, "must not be null")
  2534  		}
  2535  		return graphql.Null
  2536  	}
  2537  	return ec.___Type(ctx, sel, v)
  2538  }
  2539  
  2540  func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
  2541  	return graphql.UnmarshalString(v)
  2542  }
  2543  
  2544  func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  2545  	res := graphql.MarshalString(v)
  2546  	if res == graphql.Null {
  2547  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  2548  			ec.Errorf(ctx, "must not be null")
  2549  		}
  2550  	}
  2551  	return res
  2552  }
  2553  
  2554  func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
  2555  	return graphql.UnmarshalBoolean(v)
  2556  }
  2557  
  2558  func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
  2559  	return graphql.MarshalBoolean(v)
  2560  }
  2561  
  2562  func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
  2563  	if v == nil {
  2564  		return nil, nil
  2565  	}
  2566  	res, err := ec.unmarshalOBoolean2bool(ctx, v)
  2567  	return &res, err
  2568  }
  2569  
  2570  func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
  2571  	if v == nil {
  2572  		return graphql.Null
  2573  	}
  2574  	return ec.marshalOBoolean2bool(ctx, sel, *v)
  2575  }
  2576  
  2577  func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
  2578  	return graphql.UnmarshalString(v)
  2579  }
  2580  
  2581  func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  2582  	return graphql.MarshalString(v)
  2583  }
  2584  
  2585  func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
  2586  	var vSlice []interface{}
  2587  	if v != nil {
  2588  		if tmp1, ok := v.([]interface{}); ok {
  2589  			vSlice = tmp1
  2590  		} else {
  2591  			vSlice = []interface{}{v}
  2592  		}
  2593  	}
  2594  	var err error
  2595  	res := make([]string, len(vSlice))
  2596  	for i := range vSlice {
  2597  		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
  2598  		if err != nil {
  2599  			return nil, err
  2600  		}
  2601  	}
  2602  	return res, nil
  2603  }
  2604  
  2605  func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
  2606  	if v == nil {
  2607  		return graphql.Null
  2608  	}
  2609  	ret := make(graphql.Array, len(v))
  2610  	for i := range v {
  2611  		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
  2612  	}
  2613  
  2614  	return ret
  2615  }
  2616  
  2617  func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
  2618  	if v == nil {
  2619  		return nil, nil
  2620  	}
  2621  	res, err := ec.unmarshalOString2string(ctx, v)
  2622  	return &res, err
  2623  }
  2624  
  2625  func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
  2626  	if v == nil {
  2627  		return graphql.Null
  2628  	}
  2629  	return ec.marshalOString2string(ctx, sel, *v)
  2630  }
  2631  
  2632  func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
  2633  	if v == nil {
  2634  		return graphql.Null
  2635  	}
  2636  	ret := make(graphql.Array, len(v))
  2637  	var wg sync.WaitGroup
  2638  	isLen1 := len(v) == 1
  2639  	if !isLen1 {
  2640  		wg.Add(len(v))
  2641  	}
  2642  	for i := range v {
  2643  		i := i
  2644  		fc := &graphql.FieldContext{
  2645  			Index:  &i,
  2646  			Result: &v[i],
  2647  		}
  2648  		ctx := graphql.WithFieldContext(ctx, fc)
  2649  		f := func(i int) {
  2650  			defer func() {
  2651  				if r := recover(); r != nil {
  2652  					ec.Error(ctx, ec.Recover(ctx, r))
  2653  					ret = nil
  2654  				}
  2655  			}()
  2656  			if !isLen1 {
  2657  				defer wg.Done()
  2658  			}
  2659  			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
  2660  		}
  2661  		if isLen1 {
  2662  			f(i)
  2663  		} else {
  2664  			go f(i)
  2665  		}
  2666  
  2667  	}
  2668  	wg.Wait()
  2669  	return ret
  2670  }
  2671  
  2672  func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
  2673  	if v == nil {
  2674  		return graphql.Null
  2675  	}
  2676  	ret := make(graphql.Array, len(v))
  2677  	var wg sync.WaitGroup
  2678  	isLen1 := len(v) == 1
  2679  	if !isLen1 {
  2680  		wg.Add(len(v))
  2681  	}
  2682  	for i := range v {
  2683  		i := i
  2684  		fc := &graphql.FieldContext{
  2685  			Index:  &i,
  2686  			Result: &v[i],
  2687  		}
  2688  		ctx := graphql.WithFieldContext(ctx, fc)
  2689  		f := func(i int) {
  2690  			defer func() {
  2691  				if r := recover(); r != nil {
  2692  					ec.Error(ctx, ec.Recover(ctx, r))
  2693  					ret = nil
  2694  				}
  2695  			}()
  2696  			if !isLen1 {
  2697  				defer wg.Done()
  2698  			}
  2699  			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
  2700  		}
  2701  		if isLen1 {
  2702  			f(i)
  2703  		} else {
  2704  			go f(i)
  2705  		}
  2706  
  2707  	}
  2708  	wg.Wait()
  2709  	return ret
  2710  }
  2711  
  2712  func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
  2713  	if v == nil {
  2714  		return graphql.Null
  2715  	}
  2716  	ret := make(graphql.Array, len(v))
  2717  	var wg sync.WaitGroup
  2718  	isLen1 := len(v) == 1
  2719  	if !isLen1 {
  2720  		wg.Add(len(v))
  2721  	}
  2722  	for i := range v {
  2723  		i := i
  2724  		fc := &graphql.FieldContext{
  2725  			Index:  &i,
  2726  			Result: &v[i],
  2727  		}
  2728  		ctx := graphql.WithFieldContext(ctx, fc)
  2729  		f := func(i int) {
  2730  			defer func() {
  2731  				if r := recover(); r != nil {
  2732  					ec.Error(ctx, ec.Recover(ctx, r))
  2733  					ret = nil
  2734  				}
  2735  			}()
  2736  			if !isLen1 {
  2737  				defer wg.Done()
  2738  			}
  2739  			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
  2740  		}
  2741  		if isLen1 {
  2742  			f(i)
  2743  		} else {
  2744  			go f(i)
  2745  		}
  2746  
  2747  	}
  2748  	wg.Wait()
  2749  	return ret
  2750  }
  2751  
  2752  func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
  2753  	return ec.___Schema(ctx, sel, &v)
  2754  }
  2755  
  2756  func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
  2757  	if v == nil {
  2758  		return graphql.Null
  2759  	}
  2760  	return ec.___Schema(ctx, sel, v)
  2761  }
  2762  
  2763  func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
  2764  	return ec.___Type(ctx, sel, &v)
  2765  }
  2766  
  2767  func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
  2768  	if v == nil {
  2769  		return graphql.Null
  2770  	}
  2771  	ret := make(graphql.Array, len(v))
  2772  	var wg sync.WaitGroup
  2773  	isLen1 := len(v) == 1
  2774  	if !isLen1 {
  2775  		wg.Add(len(v))
  2776  	}
  2777  	for i := range v {
  2778  		i := i
  2779  		fc := &graphql.FieldContext{
  2780  			Index:  &i,
  2781  			Result: &v[i],
  2782  		}
  2783  		ctx := graphql.WithFieldContext(ctx, fc)
  2784  		f := func(i int) {
  2785  			defer func() {
  2786  				if r := recover(); r != nil {
  2787  					ec.Error(ctx, ec.Recover(ctx, r))
  2788  					ret = nil
  2789  				}
  2790  			}()
  2791  			if !isLen1 {
  2792  				defer wg.Done()
  2793  			}
  2794  			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
  2795  		}
  2796  		if isLen1 {
  2797  			f(i)
  2798  		} else {
  2799  			go f(i)
  2800  		}
  2801  
  2802  	}
  2803  	wg.Wait()
  2804  	return ret
  2805  }
  2806  
  2807  func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
  2808  	if v == nil {
  2809  		return graphql.Null
  2810  	}
  2811  	return ec.___Type(ctx, sel, v)
  2812  }
  2813  
  2814  // endregion ***************************** type.gotpl *****************************