github.com/spread-ai/gqlgen@v0.0.0-20221124102857-a6c8ef538a1d/codegen/testserver/followschema/schema.generated.go (about)

     1  // Code generated by github.com/spread-ai/gqlgen, DO NOT EDIT.
     2  
     3  package followschema
     4  
     5  import (
     6  	"context"
     7  	"errors"
     8  	"fmt"
     9  	"io"
    10  	"strconv"
    11  	"sync"
    12  	"sync/atomic"
    13  	"time"
    14  
    15  	introspection1 "github.com/spread-ai/gqlgen/codegen/testserver/followschema/introspection"
    16  	invalid_packagename "github.com/spread-ai/gqlgen/codegen/testserver/followschema/invalid-packagename"
    17  	"github.com/spread-ai/gqlgen/codegen/testserver/followschema/otherpkg"
    18  	"github.com/spread-ai/gqlgen/graphql"
    19  	"github.com/spread-ai/gqlgen/graphql/introspection"
    20  	"github.com/vektah/gqlparser/v2/ast"
    21  )
    22  
    23  // region    ************************** generated!.gotpl **************************
    24  
    25  type ForcedResolverResolver interface {
    26  	Field(ctx context.Context, obj *ForcedResolver) (*Circle, error)
    27  }
    28  type ModelMethodsResolver interface {
    29  	ResolverField(ctx context.Context, obj *ModelMethods) (bool, error)
    30  }
    31  type PetResolver interface {
    32  	Friends(ctx context.Context, obj *Pet, limit *int) ([]*Pet, error)
    33  }
    34  type QueryResolver interface {
    35  	InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error)
    36  	Collision(ctx context.Context) (*introspection1.It, error)
    37  	MapInput(ctx context.Context, input map[string]interface{}) (*bool, error)
    38  	Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error)
    39  	NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error)
    40  	NestedOutputs(ctx context.Context) ([][]*OuterObject, error)
    41  	ModelMethods(ctx context.Context) (*ModelMethods, error)
    42  	User(ctx context.Context, id int) (*User, error)
    43  	NullableArg(ctx context.Context, arg *int) (*string, error)
    44  	InputSlice(ctx context.Context, arg []string) (bool, error)
    45  	InputNullableSlice(ctx context.Context, arg []string) (bool, error)
    46  	ShapeUnion(ctx context.Context) (ShapeUnion, error)
    47  	Autobind(ctx context.Context) (*Autobind, error)
    48  	DeprecatedField(ctx context.Context) (string, error)
    49  	Overlapping(ctx context.Context) (*OverlappingFields, error)
    50  	DefaultParameters(ctx context.Context, falsyBoolean *bool, truthyBoolean *bool) (*DefaultParametersMirror, error)
    51  	DirectiveArg(ctx context.Context, arg string) (*string, error)
    52  	DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error)
    53  	DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error)
    54  	DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error)
    55  	DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error)
    56  	DirectiveObject(ctx context.Context) (*ObjectDirectives, error)
    57  	DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error)
    58  	DirectiveFieldDef(ctx context.Context, ret string) (string, error)
    59  	DirectiveField(ctx context.Context) (*string, error)
    60  	DirectiveDouble(ctx context.Context) (*string, error)
    61  	DirectiveUnimplemented(ctx context.Context) (*string, error)
    62  	EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error)
    63  	EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error)
    64  	EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error)
    65  	EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error)
    66  	Shapes(ctx context.Context) ([]Shape, error)
    67  	NoShape(ctx context.Context) (Shape, error)
    68  	Node(ctx context.Context) (Node, error)
    69  	NoShapeTypedNil(ctx context.Context) (Shape, error)
    70  	Animal(ctx context.Context) (Animal, error)
    71  	NotAnInterface(ctx context.Context) (BackedByInterface, error)
    72  	Dog(ctx context.Context) (*Dog, error)
    73  	Issue896a(ctx context.Context) ([]*CheckIssue896, error)
    74  	MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error)
    75  	MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error)
    76  	ErrorBubble(ctx context.Context) (*Error, error)
    77  	ErrorBubbleList(ctx context.Context) ([]*Error, error)
    78  	ErrorList(ctx context.Context) ([]*Error, error)
    79  	Errors(ctx context.Context) (*Errors, error)
    80  	Valid(ctx context.Context) (string, error)
    81  	Panics(ctx context.Context) (*Panics, error)
    82  	PrimitiveObject(ctx context.Context) ([]Primitive, error)
    83  	PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error)
    84  	PtrToSliceContainer(ctx context.Context) (*PtrToSliceContainer, error)
    85  	Infinity(ctx context.Context) (float64, error)
    86  	StringFromContextInterface(ctx context.Context) (*StringFromContextInterface, error)
    87  	StringFromContextFunction(ctx context.Context) (string, error)
    88  	DefaultScalar(ctx context.Context, arg string) (string, error)
    89  	Slices(ctx context.Context) (*Slices, error)
    90  	ScalarSlice(ctx context.Context) ([]byte, error)
    91  	Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error)
    92  	OptionalUnion(ctx context.Context) (TestUnion, error)
    93  	VOkCaseValue(ctx context.Context) (*VOkCaseValue, error)
    94  	VOkCaseNil(ctx context.Context) (*VOkCaseNil, error)
    95  	ValidType(ctx context.Context) (*ValidType, error)
    96  	VariadicModel(ctx context.Context) (*VariadicModel, error)
    97  	WrappedStruct(ctx context.Context) (*WrappedStruct, error)
    98  	WrappedScalar(ctx context.Context) (otherpkg.Scalar, error)
    99  	WrappedMap(ctx context.Context) (WrappedMap, error)
   100  	WrappedSlice(ctx context.Context) (WrappedSlice, error)
   101  }
   102  type SubscriptionResolver interface {
   103  	Updated(ctx context.Context) (<-chan string, error)
   104  	InitPayload(ctx context.Context) (<-chan string, error)
   105  	DirectiveArg(ctx context.Context, arg string) (<-chan *string, error)
   106  	DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error)
   107  	DirectiveDouble(ctx context.Context) (<-chan *string, error)
   108  	DirectiveUnimplemented(ctx context.Context) (<-chan *string, error)
   109  	Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error)
   110  	ErrorRequired(ctx context.Context) (<-chan *Error, error)
   111  }
   112  type UserResolver interface {
   113  	Friends(ctx context.Context, obj *User) ([]*User, error)
   114  
   115  	Pets(ctx context.Context, obj *User, limit *int) ([]*Pet, error)
   116  }
   117  
   118  // endregion ************************** generated!.gotpl **************************
   119  
   120  // region    ***************************** args.gotpl *****************************
   121  
   122  func (ec *executionContext) field_Pet_friends_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   123  	var err error
   124  	args := map[string]interface{}{}
   125  	var arg0 *int
   126  	if tmp, ok := rawArgs["limit"]; ok {
   127  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
   128  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   129  		if err != nil {
   130  			return nil, err
   131  		}
   132  	}
   133  	args["limit"] = arg0
   134  	return args, nil
   135  }
   136  
   137  func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   138  	var err error
   139  	args := map[string]interface{}{}
   140  	var arg0 string
   141  	if tmp, ok := rawArgs["name"]; ok {
   142  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
   143  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   144  		if err != nil {
   145  			return nil, err
   146  		}
   147  	}
   148  	args["name"] = arg0
   149  	return args, nil
   150  }
   151  
   152  func (ec *executionContext) field_Query_defaultParameters_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   153  	var err error
   154  	args := map[string]interface{}{}
   155  	var arg0 *bool
   156  	if tmp, ok := rawArgs["falsyBoolean"]; ok {
   157  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("falsyBoolean"))
   158  		arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
   159  		if err != nil {
   160  			return nil, err
   161  		}
   162  	}
   163  	args["falsyBoolean"] = arg0
   164  	var arg1 *bool
   165  	if tmp, ok := rawArgs["truthyBoolean"]; ok {
   166  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("truthyBoolean"))
   167  		arg1, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
   168  		if err != nil {
   169  			return nil, err
   170  		}
   171  	}
   172  	args["truthyBoolean"] = arg1
   173  	return args, nil
   174  }
   175  
   176  func (ec *executionContext) field_Query_defaultScalar_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   177  	var err error
   178  	args := map[string]interface{}{}
   179  	var arg0 string
   180  	if tmp, ok := rawArgs["arg"]; ok {
   181  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   182  		arg0, err = ec.unmarshalNDefaultScalarImplementation2string(ctx, tmp)
   183  		if err != nil {
   184  			return nil, err
   185  		}
   186  	}
   187  	args["arg"] = arg0
   188  	return args, nil
   189  }
   190  
   191  func (ec *executionContext) field_Query_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   192  	var err error
   193  	args := map[string]interface{}{}
   194  	var arg0 string
   195  	if tmp, ok := rawArgs["arg"]; ok {
   196  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   197  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) }
   198  		directive1 := func(ctx context.Context) (interface{}, error) {
   199  			min, err := ec.unmarshalNInt2int(ctx, 1)
   200  			if err != nil {
   201  				return nil, err
   202  			}
   203  			max, err := ec.unmarshalOInt2ᚖint(ctx, 255)
   204  			if err != nil {
   205  				return nil, err
   206  			}
   207  			message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length")
   208  			if err != nil {
   209  				return nil, err
   210  			}
   211  			if ec.directives.Length == nil {
   212  				return nil, errors.New("directive length is not implemented")
   213  			}
   214  			return ec.directives.Length(ctx, rawArgs, directive0, min, max, message)
   215  		}
   216  
   217  		tmp, err = directive1(ctx)
   218  		if err != nil {
   219  			return nil, graphql.ErrorOnPath(ctx, err)
   220  		}
   221  		if data, ok := tmp.(string); ok {
   222  			arg0 = data
   223  		} else {
   224  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp))
   225  		}
   226  	}
   227  	args["arg"] = arg0
   228  	return args, nil
   229  }
   230  
   231  func (ec *executionContext) field_Query_directiveFieldDef_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   232  	var err error
   233  	args := map[string]interface{}{}
   234  	var arg0 string
   235  	if tmp, ok := rawArgs["ret"]; ok {
   236  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ret"))
   237  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   238  		if err != nil {
   239  			return nil, err
   240  		}
   241  	}
   242  	args["ret"] = arg0
   243  	return args, nil
   244  }
   245  
   246  func (ec *executionContext) field_Query_directiveInputNullable_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   247  	var err error
   248  	args := map[string]interface{}{}
   249  	var arg0 *InputDirectives
   250  	if tmp, ok := rawArgs["arg"]; ok {
   251  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   252  		arg0, err = ec.unmarshalOInputDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputDirectives(ctx, tmp)
   253  		if err != nil {
   254  			return nil, err
   255  		}
   256  	}
   257  	args["arg"] = arg0
   258  	return args, nil
   259  }
   260  
   261  func (ec *executionContext) field_Query_directiveInputType_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   262  	var err error
   263  	args := map[string]interface{}{}
   264  	var arg0 InnerInput
   265  	if tmp, ok := rawArgs["arg"]; ok {
   266  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   267  		directive0 := func(ctx context.Context) (interface{}, error) {
   268  			return ec.unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, tmp)
   269  		}
   270  		directive1 := func(ctx context.Context) (interface{}, error) {
   271  			if ec.directives.Custom == nil {
   272  				return nil, errors.New("directive custom is not implemented")
   273  			}
   274  			return ec.directives.Custom(ctx, rawArgs, directive0)
   275  		}
   276  
   277  		tmp, err = directive1(ctx)
   278  		if err != nil {
   279  			return nil, graphql.ErrorOnPath(ctx, err)
   280  		}
   281  		if data, ok := tmp.(InnerInput); ok {
   282  			arg0 = data
   283  		} else {
   284  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be github.com/spread-ai/gqlgen/codegen/testserver/followschema.InnerInput`, tmp))
   285  		}
   286  	}
   287  	args["arg"] = arg0
   288  	return args, nil
   289  }
   290  
   291  func (ec *executionContext) field_Query_directiveInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   292  	var err error
   293  	args := map[string]interface{}{}
   294  	var arg0 InputDirectives
   295  	if tmp, ok := rawArgs["arg"]; ok {
   296  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   297  		arg0, err = ec.unmarshalNInputDirectives2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputDirectives(ctx, tmp)
   298  		if err != nil {
   299  			return nil, err
   300  		}
   301  	}
   302  	args["arg"] = arg0
   303  	return args, nil
   304  }
   305  
   306  func (ec *executionContext) field_Query_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   307  	var err error
   308  	args := map[string]interface{}{}
   309  	var arg0 *int
   310  	if tmp, ok := rawArgs["arg"]; ok {
   311  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   312  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   313  		directive1 := func(ctx context.Context) (interface{}, error) {
   314  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   315  			if err != nil {
   316  				return nil, err
   317  			}
   318  			if ec.directives.Range == nil {
   319  				return nil, errors.New("directive range is not implemented")
   320  			}
   321  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   322  		}
   323  
   324  		tmp, err = directive1(ctx)
   325  		if err != nil {
   326  			return nil, graphql.ErrorOnPath(ctx, err)
   327  		}
   328  		if data, ok := tmp.(*int); ok {
   329  			arg0 = data
   330  		} else if tmp == nil {
   331  			arg0 = nil
   332  		} else {
   333  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   334  		}
   335  	}
   336  	args["arg"] = arg0
   337  	var arg1 *int
   338  	if tmp, ok := rawArgs["arg2"]; ok {
   339  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2"))
   340  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   341  		directive1 := func(ctx context.Context) (interface{}, error) {
   342  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   343  			if err != nil {
   344  				return nil, err
   345  			}
   346  			if ec.directives.Range == nil {
   347  				return nil, errors.New("directive range is not implemented")
   348  			}
   349  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   350  		}
   351  
   352  		tmp, err = directive1(ctx)
   353  		if err != nil {
   354  			return nil, graphql.ErrorOnPath(ctx, err)
   355  		}
   356  		if data, ok := tmp.(*int); ok {
   357  			arg1 = data
   358  		} else if tmp == nil {
   359  			arg1 = nil
   360  		} else {
   361  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   362  		}
   363  	}
   364  	args["arg2"] = arg1
   365  	var arg2 *string
   366  	if tmp, ok := rawArgs["arg3"]; ok {
   367  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3"))
   368  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) }
   369  		directive1 := func(ctx context.Context) (interface{}, error) {
   370  			if ec.directives.ToNull == nil {
   371  				return nil, errors.New("directive toNull is not implemented")
   372  			}
   373  			return ec.directives.ToNull(ctx, rawArgs, directive0)
   374  		}
   375  
   376  		tmp, err = directive1(ctx)
   377  		if err != nil {
   378  			return nil, graphql.ErrorOnPath(ctx, err)
   379  		}
   380  		if data, ok := tmp.(*string); ok {
   381  			arg2 = data
   382  		} else if tmp == nil {
   383  			arg2 = nil
   384  		} else {
   385  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp))
   386  		}
   387  	}
   388  	args["arg3"] = arg2
   389  	return args, nil
   390  }
   391  
   392  func (ec *executionContext) field_Query_enumInInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   393  	var err error
   394  	args := map[string]interface{}{}
   395  	var arg0 *InputWithEnumValue
   396  	if tmp, ok := rawArgs["input"]; ok {
   397  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   398  		arg0, err = ec.unmarshalOInputWithEnumValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputWithEnumValue(ctx, tmp)
   399  		if err != nil {
   400  			return nil, err
   401  		}
   402  	}
   403  	args["input"] = arg0
   404  	return args, nil
   405  }
   406  
   407  func (ec *executionContext) field_Query_fallback_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   408  	var err error
   409  	args := map[string]interface{}{}
   410  	var arg0 FallbackToStringEncoding
   411  	if tmp, ok := rawArgs["arg"]; ok {
   412  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   413  		arg0, err = ec.unmarshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐFallbackToStringEncoding(ctx, tmp)
   414  		if err != nil {
   415  			return nil, err
   416  		}
   417  	}
   418  	args["arg"] = arg0
   419  	return args, nil
   420  }
   421  
   422  func (ec *executionContext) field_Query_inputNullableSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   423  	var err error
   424  	args := map[string]interface{}{}
   425  	var arg0 []string
   426  	if tmp, ok := rawArgs["arg"]; ok {
   427  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   428  		arg0, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
   429  		if err != nil {
   430  			return nil, err
   431  		}
   432  	}
   433  	args["arg"] = arg0
   434  	return args, nil
   435  }
   436  
   437  func (ec *executionContext) field_Query_inputSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   438  	var err error
   439  	args := map[string]interface{}{}
   440  	var arg0 []string
   441  	if tmp, ok := rawArgs["arg"]; ok {
   442  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   443  		arg0, err = ec.unmarshalNString2ᚕstringᚄ(ctx, tmp)
   444  		if err != nil {
   445  			return nil, err
   446  		}
   447  	}
   448  	args["arg"] = arg0
   449  	return args, nil
   450  }
   451  
   452  func (ec *executionContext) field_Query_mapInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   453  	var err error
   454  	args := map[string]interface{}{}
   455  	var arg0 map[string]interface{}
   456  	if tmp, ok := rawArgs["input"]; ok {
   457  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   458  		arg0, err = ec.unmarshalOChanges2map(ctx, tmp)
   459  		if err != nil {
   460  			return nil, err
   461  		}
   462  	}
   463  	args["input"] = arg0
   464  	return args, nil
   465  }
   466  
   467  func (ec *executionContext) field_Query_mapNestedStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   468  	var err error
   469  	args := map[string]interface{}{}
   470  	var arg0 *NestedMapInput
   471  	if tmp, ok := rawArgs["in"]; ok {
   472  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
   473  		arg0, err = ec.unmarshalONestedMapInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐNestedMapInput(ctx, tmp)
   474  		if err != nil {
   475  			return nil, err
   476  		}
   477  	}
   478  	args["in"] = arg0
   479  	return args, nil
   480  }
   481  
   482  func (ec *executionContext) field_Query_mapStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   483  	var err error
   484  	args := map[string]interface{}{}
   485  	var arg0 map[string]interface{}
   486  	if tmp, ok := rawArgs["in"]; ok {
   487  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
   488  		arg0, err = ec.unmarshalOMapStringInterfaceInput2map(ctx, tmp)
   489  		if err != nil {
   490  			return nil, err
   491  		}
   492  	}
   493  	args["in"] = arg0
   494  	return args, nil
   495  }
   496  
   497  func (ec *executionContext) field_Query_nestedInputs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   498  	var err error
   499  	args := map[string]interface{}{}
   500  	var arg0 [][]*OuterInput
   501  	if tmp, ok := rawArgs["input"]; ok {
   502  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   503  		arg0, err = ec.unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, tmp)
   504  		if err != nil {
   505  			return nil, err
   506  		}
   507  	}
   508  	args["input"] = arg0
   509  	return args, nil
   510  }
   511  
   512  func (ec *executionContext) field_Query_nullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   513  	var err error
   514  	args := map[string]interface{}{}
   515  	var arg0 *int
   516  	if tmp, ok := rawArgs["arg"]; ok {
   517  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   518  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   519  		if err != nil {
   520  			return nil, err
   521  		}
   522  	}
   523  	args["arg"] = arg0
   524  	return args, nil
   525  }
   526  
   527  func (ec *executionContext) field_Query_recursive_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   528  	var err error
   529  	args := map[string]interface{}{}
   530  	var arg0 *RecursiveInputSlice
   531  	if tmp, ok := rawArgs["input"]; ok {
   532  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   533  		arg0, err = ec.unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, tmp)
   534  		if err != nil {
   535  			return nil, err
   536  		}
   537  	}
   538  	args["input"] = arg0
   539  	return args, nil
   540  }
   541  
   542  func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   543  	var err error
   544  	args := map[string]interface{}{}
   545  	var arg0 int
   546  	if tmp, ok := rawArgs["id"]; ok {
   547  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
   548  		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
   549  		if err != nil {
   550  			return nil, err
   551  		}
   552  	}
   553  	args["id"] = arg0
   554  	return args, nil
   555  }
   556  
   557  func (ec *executionContext) field_Subscription_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   558  	var err error
   559  	args := map[string]interface{}{}
   560  	var arg0 string
   561  	if tmp, ok := rawArgs["arg"]; ok {
   562  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   563  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) }
   564  		directive1 := func(ctx context.Context) (interface{}, error) {
   565  			min, err := ec.unmarshalNInt2int(ctx, 1)
   566  			if err != nil {
   567  				return nil, err
   568  			}
   569  			max, err := ec.unmarshalOInt2ᚖint(ctx, 255)
   570  			if err != nil {
   571  				return nil, err
   572  			}
   573  			message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length")
   574  			if err != nil {
   575  				return nil, err
   576  			}
   577  			if ec.directives.Length == nil {
   578  				return nil, errors.New("directive length is not implemented")
   579  			}
   580  			return ec.directives.Length(ctx, rawArgs, directive0, min, max, message)
   581  		}
   582  
   583  		tmp, err = directive1(ctx)
   584  		if err != nil {
   585  			return nil, graphql.ErrorOnPath(ctx, err)
   586  		}
   587  		if data, ok := tmp.(string); ok {
   588  			arg0 = data
   589  		} else {
   590  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp))
   591  		}
   592  	}
   593  	args["arg"] = arg0
   594  	return args, nil
   595  }
   596  
   597  func (ec *executionContext) field_Subscription_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   598  	var err error
   599  	args := map[string]interface{}{}
   600  	var arg0 *int
   601  	if tmp, ok := rawArgs["arg"]; ok {
   602  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   603  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   604  		directive1 := func(ctx context.Context) (interface{}, error) {
   605  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   606  			if err != nil {
   607  				return nil, err
   608  			}
   609  			if ec.directives.Range == nil {
   610  				return nil, errors.New("directive range is not implemented")
   611  			}
   612  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   613  		}
   614  
   615  		tmp, err = directive1(ctx)
   616  		if err != nil {
   617  			return nil, graphql.ErrorOnPath(ctx, err)
   618  		}
   619  		if data, ok := tmp.(*int); ok {
   620  			arg0 = data
   621  		} else if tmp == nil {
   622  			arg0 = nil
   623  		} else {
   624  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   625  		}
   626  	}
   627  	args["arg"] = arg0
   628  	var arg1 *int
   629  	if tmp, ok := rawArgs["arg2"]; ok {
   630  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2"))
   631  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   632  		directive1 := func(ctx context.Context) (interface{}, error) {
   633  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   634  			if err != nil {
   635  				return nil, err
   636  			}
   637  			if ec.directives.Range == nil {
   638  				return nil, errors.New("directive range is not implemented")
   639  			}
   640  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   641  		}
   642  
   643  		tmp, err = directive1(ctx)
   644  		if err != nil {
   645  			return nil, graphql.ErrorOnPath(ctx, err)
   646  		}
   647  		if data, ok := tmp.(*int); ok {
   648  			arg1 = data
   649  		} else if tmp == nil {
   650  			arg1 = nil
   651  		} else {
   652  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   653  		}
   654  	}
   655  	args["arg2"] = arg1
   656  	var arg2 *string
   657  	if tmp, ok := rawArgs["arg3"]; ok {
   658  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3"))
   659  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) }
   660  		directive1 := func(ctx context.Context) (interface{}, error) {
   661  			if ec.directives.ToNull == nil {
   662  				return nil, errors.New("directive toNull is not implemented")
   663  			}
   664  			return ec.directives.ToNull(ctx, rawArgs, directive0)
   665  		}
   666  
   667  		tmp, err = directive1(ctx)
   668  		if err != nil {
   669  			return nil, graphql.ErrorOnPath(ctx, err)
   670  		}
   671  		if data, ok := tmp.(*string); ok {
   672  			arg2 = data
   673  		} else if tmp == nil {
   674  			arg2 = nil
   675  		} else {
   676  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp))
   677  		}
   678  	}
   679  	args["arg3"] = arg2
   680  	return args, nil
   681  }
   682  
   683  func (ec *executionContext) field_User_pets_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   684  	var err error
   685  	args := map[string]interface{}{}
   686  	var arg0 *int
   687  	if tmp, ok := rawArgs["limit"]; ok {
   688  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
   689  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   690  		if err != nil {
   691  			return nil, err
   692  		}
   693  	}
   694  	args["limit"] = arg0
   695  	return args, nil
   696  }
   697  
   698  // endregion ***************************** args.gotpl *****************************
   699  
   700  // region    ************************** directives.gotpl **************************
   701  
   702  // endregion ************************** directives.gotpl **************************
   703  
   704  // region    **************************** field.gotpl *****************************
   705  
   706  func (ec *executionContext) _Autobind_int(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   707  	fc, err := ec.fieldContext_Autobind_int(ctx, field)
   708  	if err != nil {
   709  		return graphql.Null
   710  	}
   711  	ctx = graphql.WithFieldContext(ctx, fc)
   712  	defer func() {
   713  		if r := recover(); r != nil {
   714  			ec.Error(ctx, ec.Recover(ctx, r))
   715  			ret = graphql.Null
   716  		}
   717  	}()
   718  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   719  		ctx = rctx // use context from middleware stack in children
   720  		return obj.Int, nil
   721  	})
   722  
   723  	if resTmp == nil {
   724  		if !graphql.HasFieldError(ctx, fc) {
   725  			ec.Errorf(ctx, "must not be null")
   726  		}
   727  		return graphql.Null
   728  	}
   729  	res := resTmp.(int)
   730  	fc.Result = res
   731  	return ec.marshalNInt2int(ctx, field.Selections, res)
   732  }
   733  
   734  func (ec *executionContext) fieldContext_Autobind_int(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   735  	fc = &graphql.FieldContext{
   736  		Object:     "Autobind",
   737  		Field:      field,
   738  		IsMethod:   false,
   739  		IsResolver: false,
   740  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   741  			return nil, errors.New("field of type Int does not have child fields")
   742  		},
   743  	}
   744  	return fc, nil
   745  }
   746  
   747  func (ec *executionContext) _Autobind_int32(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   748  	fc, err := ec.fieldContext_Autobind_int32(ctx, field)
   749  	if err != nil {
   750  		return graphql.Null
   751  	}
   752  	ctx = graphql.WithFieldContext(ctx, fc)
   753  	defer func() {
   754  		if r := recover(); r != nil {
   755  			ec.Error(ctx, ec.Recover(ctx, r))
   756  			ret = graphql.Null
   757  		}
   758  	}()
   759  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   760  		ctx = rctx // use context from middleware stack in children
   761  		return obj.Int32, nil
   762  	})
   763  
   764  	if resTmp == nil {
   765  		if !graphql.HasFieldError(ctx, fc) {
   766  			ec.Errorf(ctx, "must not be null")
   767  		}
   768  		return graphql.Null
   769  	}
   770  	res := resTmp.(int32)
   771  	fc.Result = res
   772  	return ec.marshalNInt2int32(ctx, field.Selections, res)
   773  }
   774  
   775  func (ec *executionContext) fieldContext_Autobind_int32(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   776  	fc = &graphql.FieldContext{
   777  		Object:     "Autobind",
   778  		Field:      field,
   779  		IsMethod:   false,
   780  		IsResolver: false,
   781  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   782  			return nil, errors.New("field of type Int does not have child fields")
   783  		},
   784  	}
   785  	return fc, nil
   786  }
   787  
   788  func (ec *executionContext) _Autobind_int64(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   789  	fc, err := ec.fieldContext_Autobind_int64(ctx, field)
   790  	if err != nil {
   791  		return graphql.Null
   792  	}
   793  	ctx = graphql.WithFieldContext(ctx, fc)
   794  	defer func() {
   795  		if r := recover(); r != nil {
   796  			ec.Error(ctx, ec.Recover(ctx, r))
   797  			ret = graphql.Null
   798  		}
   799  	}()
   800  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   801  		ctx = rctx // use context from middleware stack in children
   802  		return obj.Int64, nil
   803  	})
   804  
   805  	if resTmp == nil {
   806  		if !graphql.HasFieldError(ctx, fc) {
   807  			ec.Errorf(ctx, "must not be null")
   808  		}
   809  		return graphql.Null
   810  	}
   811  	res := resTmp.(int64)
   812  	fc.Result = res
   813  	return ec.marshalNInt2int64(ctx, field.Selections, res)
   814  }
   815  
   816  func (ec *executionContext) fieldContext_Autobind_int64(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   817  	fc = &graphql.FieldContext{
   818  		Object:     "Autobind",
   819  		Field:      field,
   820  		IsMethod:   false,
   821  		IsResolver: false,
   822  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   823  			return nil, errors.New("field of type Int does not have child fields")
   824  		},
   825  	}
   826  	return fc, nil
   827  }
   828  
   829  func (ec *executionContext) _Autobind_idStr(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   830  	fc, err := ec.fieldContext_Autobind_idStr(ctx, field)
   831  	if err != nil {
   832  		return graphql.Null
   833  	}
   834  	ctx = graphql.WithFieldContext(ctx, fc)
   835  	defer func() {
   836  		if r := recover(); r != nil {
   837  			ec.Error(ctx, ec.Recover(ctx, r))
   838  			ret = graphql.Null
   839  		}
   840  	}()
   841  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   842  		ctx = rctx // use context from middleware stack in children
   843  		return obj.IdStr, nil
   844  	})
   845  
   846  	if resTmp == nil {
   847  		if !graphql.HasFieldError(ctx, fc) {
   848  			ec.Errorf(ctx, "must not be null")
   849  		}
   850  		return graphql.Null
   851  	}
   852  	res := resTmp.(string)
   853  	fc.Result = res
   854  	return ec.marshalNID2string(ctx, field.Selections, res)
   855  }
   856  
   857  func (ec *executionContext) fieldContext_Autobind_idStr(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   858  	fc = &graphql.FieldContext{
   859  		Object:     "Autobind",
   860  		Field:      field,
   861  		IsMethod:   false,
   862  		IsResolver: false,
   863  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   864  			return nil, errors.New("field of type ID does not have child fields")
   865  		},
   866  	}
   867  	return fc, nil
   868  }
   869  
   870  func (ec *executionContext) _Autobind_idInt(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   871  	fc, err := ec.fieldContext_Autobind_idInt(ctx, field)
   872  	if err != nil {
   873  		return graphql.Null
   874  	}
   875  	ctx = graphql.WithFieldContext(ctx, fc)
   876  	defer func() {
   877  		if r := recover(); r != nil {
   878  			ec.Error(ctx, ec.Recover(ctx, r))
   879  			ret = graphql.Null
   880  		}
   881  	}()
   882  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   883  		ctx = rctx // use context from middleware stack in children
   884  		return obj.IdInt, nil
   885  	})
   886  
   887  	if resTmp == nil {
   888  		if !graphql.HasFieldError(ctx, fc) {
   889  			ec.Errorf(ctx, "must not be null")
   890  		}
   891  		return graphql.Null
   892  	}
   893  	res := resTmp.(int)
   894  	fc.Result = res
   895  	return ec.marshalNID2int(ctx, field.Selections, res)
   896  }
   897  
   898  func (ec *executionContext) fieldContext_Autobind_idInt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   899  	fc = &graphql.FieldContext{
   900  		Object:     "Autobind",
   901  		Field:      field,
   902  		IsMethod:   false,
   903  		IsResolver: false,
   904  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   905  			return nil, errors.New("field of type ID does not have child fields")
   906  		},
   907  	}
   908  	return fc, nil
   909  }
   910  
   911  func (ec *executionContext) _EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) {
   912  	fc, err := ec.fieldContext_EmbeddedPointer_ID(ctx, field)
   913  	if err != nil {
   914  		return graphql.Null
   915  	}
   916  	ctx = graphql.WithFieldContext(ctx, fc)
   917  	defer func() {
   918  		if r := recover(); r != nil {
   919  			ec.Error(ctx, ec.Recover(ctx, r))
   920  			ret = graphql.Null
   921  		}
   922  	}()
   923  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   924  		ctx = rctx // use context from middleware stack in children
   925  		return obj.ID, nil
   926  	})
   927  
   928  	if resTmp == nil {
   929  		return graphql.Null
   930  	}
   931  	res := resTmp.(string)
   932  	fc.Result = res
   933  	return ec.marshalOString2string(ctx, field.Selections, res)
   934  }
   935  
   936  func (ec *executionContext) fieldContext_EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   937  	fc = &graphql.FieldContext{
   938  		Object:     "EmbeddedPointer",
   939  		Field:      field,
   940  		IsMethod:   false,
   941  		IsResolver: false,
   942  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   943  			return nil, errors.New("field of type String does not have child fields")
   944  		},
   945  	}
   946  	return fc, nil
   947  }
   948  
   949  func (ec *executionContext) _EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) {
   950  	fc, err := ec.fieldContext_EmbeddedPointer_Title(ctx, field)
   951  	if err != nil {
   952  		return graphql.Null
   953  	}
   954  	ctx = graphql.WithFieldContext(ctx, fc)
   955  	defer func() {
   956  		if r := recover(); r != nil {
   957  			ec.Error(ctx, ec.Recover(ctx, r))
   958  			ret = graphql.Null
   959  		}
   960  	}()
   961  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   962  		ctx = rctx // use context from middleware stack in children
   963  		return obj.Title, nil
   964  	})
   965  
   966  	if resTmp == nil {
   967  		return graphql.Null
   968  	}
   969  	res := resTmp.(string)
   970  	fc.Result = res
   971  	return ec.marshalOString2string(ctx, field.Selections, res)
   972  }
   973  
   974  func (ec *executionContext) fieldContext_EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   975  	fc = &graphql.FieldContext{
   976  		Object:     "EmbeddedPointer",
   977  		Field:      field,
   978  		IsMethod:   false,
   979  		IsResolver: false,
   980  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   981  			return nil, errors.New("field of type String does not have child fields")
   982  		},
   983  	}
   984  	return fc, nil
   985  }
   986  
   987  func (ec *executionContext) _ForcedResolver_field(ctx context.Context, field graphql.CollectedField, obj *ForcedResolver) (ret graphql.Marshaler) {
   988  	fc, err := ec.fieldContext_ForcedResolver_field(ctx, field)
   989  	if err != nil {
   990  		return graphql.Null
   991  	}
   992  	ctx = graphql.WithFieldContext(ctx, fc)
   993  	defer func() {
   994  		if r := recover(); r != nil {
   995  			ec.Error(ctx, ec.Recover(ctx, r))
   996  			ret = graphql.Null
   997  		}
   998  	}()
   999  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1000  		ctx = rctx // use context from middleware stack in children
  1001  		return ec.resolvers.ForcedResolver().Field(rctx, obj)
  1002  	})
  1003  
  1004  	if resTmp == nil {
  1005  		return graphql.Null
  1006  	}
  1007  	res := resTmp.(*Circle)
  1008  	fc.Result = res
  1009  	return ec.marshalOCircle2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCircle(ctx, field.Selections, res)
  1010  }
  1011  
  1012  func (ec *executionContext) fieldContext_ForcedResolver_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1013  	fc = &graphql.FieldContext{
  1014  		Object:     "ForcedResolver",
  1015  		Field:      field,
  1016  		IsMethod:   true,
  1017  		IsResolver: true,
  1018  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1019  			switch field.Name {
  1020  			case "radius":
  1021  				return ec.fieldContext_Circle_radius(ctx, field)
  1022  			case "area":
  1023  				return ec.fieldContext_Circle_area(ctx, field)
  1024  			case "coordinates":
  1025  				return ec.fieldContext_Circle_coordinates(ctx, field)
  1026  			}
  1027  			return nil, fmt.Errorf("no field named %q was found under type Circle", field.Name)
  1028  		},
  1029  	}
  1030  	return fc, nil
  1031  }
  1032  
  1033  func (ec *executionContext) _InnerObject_id(ctx context.Context, field graphql.CollectedField, obj *InnerObject) (ret graphql.Marshaler) {
  1034  	fc, err := ec.fieldContext_InnerObject_id(ctx, field)
  1035  	if err != nil {
  1036  		return graphql.Null
  1037  	}
  1038  	ctx = graphql.WithFieldContext(ctx, fc)
  1039  	defer func() {
  1040  		if r := recover(); r != nil {
  1041  			ec.Error(ctx, ec.Recover(ctx, r))
  1042  			ret = graphql.Null
  1043  		}
  1044  	}()
  1045  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1046  		ctx = rctx // use context from middleware stack in children
  1047  		return obj.ID, nil
  1048  	})
  1049  
  1050  	if resTmp == nil {
  1051  		if !graphql.HasFieldError(ctx, fc) {
  1052  			ec.Errorf(ctx, "must not be null")
  1053  		}
  1054  		return graphql.Null
  1055  	}
  1056  	res := resTmp.(int)
  1057  	fc.Result = res
  1058  	return ec.marshalNInt2int(ctx, field.Selections, res)
  1059  }
  1060  
  1061  func (ec *executionContext) fieldContext_InnerObject_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1062  	fc = &graphql.FieldContext{
  1063  		Object:     "InnerObject",
  1064  		Field:      field,
  1065  		IsMethod:   false,
  1066  		IsResolver: false,
  1067  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1068  			return nil, errors.New("field of type Int does not have child fields")
  1069  		},
  1070  	}
  1071  	return fc, nil
  1072  }
  1073  
  1074  func (ec *executionContext) _InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField, obj *invalid_packagename.InvalidIdentifier) (ret graphql.Marshaler) {
  1075  	fc, err := ec.fieldContext_InvalidIdentifier_id(ctx, field)
  1076  	if err != nil {
  1077  		return graphql.Null
  1078  	}
  1079  	ctx = graphql.WithFieldContext(ctx, fc)
  1080  	defer func() {
  1081  		if r := recover(); r != nil {
  1082  			ec.Error(ctx, ec.Recover(ctx, r))
  1083  			ret = graphql.Null
  1084  		}
  1085  	}()
  1086  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1087  		ctx = rctx // use context from middleware stack in children
  1088  		return obj.ID, nil
  1089  	})
  1090  
  1091  	if resTmp == nil {
  1092  		if !graphql.HasFieldError(ctx, fc) {
  1093  			ec.Errorf(ctx, "must not be null")
  1094  		}
  1095  		return graphql.Null
  1096  	}
  1097  	res := resTmp.(int)
  1098  	fc.Result = res
  1099  	return ec.marshalNInt2int(ctx, field.Selections, res)
  1100  }
  1101  
  1102  func (ec *executionContext) fieldContext_InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1103  	fc = &graphql.FieldContext{
  1104  		Object:     "InvalidIdentifier",
  1105  		Field:      field,
  1106  		IsMethod:   false,
  1107  		IsResolver: false,
  1108  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1109  			return nil, errors.New("field of type Int does not have child fields")
  1110  		},
  1111  	}
  1112  	return fc, nil
  1113  }
  1114  
  1115  func (ec *executionContext) _It_id(ctx context.Context, field graphql.CollectedField, obj *introspection1.It) (ret graphql.Marshaler) {
  1116  	fc, err := ec.fieldContext_It_id(ctx, field)
  1117  	if err != nil {
  1118  		return graphql.Null
  1119  	}
  1120  	ctx = graphql.WithFieldContext(ctx, fc)
  1121  	defer func() {
  1122  		if r := recover(); r != nil {
  1123  			ec.Error(ctx, ec.Recover(ctx, r))
  1124  			ret = graphql.Null
  1125  		}
  1126  	}()
  1127  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1128  		ctx = rctx // use context from middleware stack in children
  1129  		return obj.ID, nil
  1130  	})
  1131  
  1132  	if resTmp == nil {
  1133  		if !graphql.HasFieldError(ctx, fc) {
  1134  			ec.Errorf(ctx, "must not be null")
  1135  		}
  1136  		return graphql.Null
  1137  	}
  1138  	res := resTmp.(string)
  1139  	fc.Result = res
  1140  	return ec.marshalNID2string(ctx, field.Selections, res)
  1141  }
  1142  
  1143  func (ec *executionContext) fieldContext_It_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1144  	fc = &graphql.FieldContext{
  1145  		Object:     "It",
  1146  		Field:      field,
  1147  		IsMethod:   false,
  1148  		IsResolver: false,
  1149  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1150  			return nil, errors.New("field of type ID does not have child fields")
  1151  		},
  1152  	}
  1153  	return fc, nil
  1154  }
  1155  
  1156  func (ec *executionContext) _ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
  1157  	fc, err := ec.fieldContext_ModelMethods_resolverField(ctx, field)
  1158  	if err != nil {
  1159  		return graphql.Null
  1160  	}
  1161  	ctx = graphql.WithFieldContext(ctx, fc)
  1162  	defer func() {
  1163  		if r := recover(); r != nil {
  1164  			ec.Error(ctx, ec.Recover(ctx, r))
  1165  			ret = graphql.Null
  1166  		}
  1167  	}()
  1168  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1169  		ctx = rctx // use context from middleware stack in children
  1170  		return ec.resolvers.ModelMethods().ResolverField(rctx, obj)
  1171  	})
  1172  
  1173  	if resTmp == nil {
  1174  		if !graphql.HasFieldError(ctx, fc) {
  1175  			ec.Errorf(ctx, "must not be null")
  1176  		}
  1177  		return graphql.Null
  1178  	}
  1179  	res := resTmp.(bool)
  1180  	fc.Result = res
  1181  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1182  }
  1183  
  1184  func (ec *executionContext) fieldContext_ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1185  	fc = &graphql.FieldContext{
  1186  		Object:     "ModelMethods",
  1187  		Field:      field,
  1188  		IsMethod:   true,
  1189  		IsResolver: true,
  1190  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1191  			return nil, errors.New("field of type Boolean does not have child fields")
  1192  		},
  1193  	}
  1194  	return fc, nil
  1195  }
  1196  
  1197  func (ec *executionContext) _ModelMethods_noContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
  1198  	fc, err := ec.fieldContext_ModelMethods_noContext(ctx, field)
  1199  	if err != nil {
  1200  		return graphql.Null
  1201  	}
  1202  	ctx = graphql.WithFieldContext(ctx, fc)
  1203  	defer func() {
  1204  		if r := recover(); r != nil {
  1205  			ec.Error(ctx, ec.Recover(ctx, r))
  1206  			ret = graphql.Null
  1207  		}
  1208  	}()
  1209  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1210  		ctx = rctx // use context from middleware stack in children
  1211  		return obj.NoContext(), nil
  1212  	})
  1213  
  1214  	if resTmp == nil {
  1215  		if !graphql.HasFieldError(ctx, fc) {
  1216  			ec.Errorf(ctx, "must not be null")
  1217  		}
  1218  		return graphql.Null
  1219  	}
  1220  	res := resTmp.(bool)
  1221  	fc.Result = res
  1222  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1223  }
  1224  
  1225  func (ec *executionContext) fieldContext_ModelMethods_noContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1226  	fc = &graphql.FieldContext{
  1227  		Object:     "ModelMethods",
  1228  		Field:      field,
  1229  		IsMethod:   true,
  1230  		IsResolver: false,
  1231  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1232  			return nil, errors.New("field of type Boolean does not have child fields")
  1233  		},
  1234  	}
  1235  	return fc, nil
  1236  }
  1237  
  1238  func (ec *executionContext) _ModelMethods_withContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
  1239  	fc, err := ec.fieldContext_ModelMethods_withContext(ctx, field)
  1240  	if err != nil {
  1241  		return graphql.Null
  1242  	}
  1243  	ctx = graphql.WithFieldContext(ctx, fc)
  1244  	defer func() {
  1245  		if r := recover(); r != nil {
  1246  			ec.Error(ctx, ec.Recover(ctx, r))
  1247  			ret = graphql.Null
  1248  		}
  1249  	}()
  1250  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1251  		ctx = rctx // use context from middleware stack in children
  1252  		return obj.WithContext(ctx), nil
  1253  	})
  1254  
  1255  	if resTmp == nil {
  1256  		if !graphql.HasFieldError(ctx, fc) {
  1257  			ec.Errorf(ctx, "must not be null")
  1258  		}
  1259  		return graphql.Null
  1260  	}
  1261  	res := resTmp.(bool)
  1262  	fc.Result = res
  1263  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1264  }
  1265  
  1266  func (ec *executionContext) fieldContext_ModelMethods_withContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1267  	fc = &graphql.FieldContext{
  1268  		Object:     "ModelMethods",
  1269  		Field:      field,
  1270  		IsMethod:   true,
  1271  		IsResolver: false,
  1272  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1273  			return nil, errors.New("field of type Boolean does not have child fields")
  1274  		},
  1275  	}
  1276  	return fc, nil
  1277  }
  1278  
  1279  func (ec *executionContext) _OuterObject_inner(ctx context.Context, field graphql.CollectedField, obj *OuterObject) (ret graphql.Marshaler) {
  1280  	fc, err := ec.fieldContext_OuterObject_inner(ctx, field)
  1281  	if err != nil {
  1282  		return graphql.Null
  1283  	}
  1284  	ctx = graphql.WithFieldContext(ctx, fc)
  1285  	defer func() {
  1286  		if r := recover(); r != nil {
  1287  			ec.Error(ctx, ec.Recover(ctx, r))
  1288  			ret = graphql.Null
  1289  		}
  1290  	}()
  1291  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1292  		ctx = rctx // use context from middleware stack in children
  1293  		return obj.Inner, nil
  1294  	})
  1295  
  1296  	if resTmp == nil {
  1297  		if !graphql.HasFieldError(ctx, fc) {
  1298  			ec.Errorf(ctx, "must not be null")
  1299  		}
  1300  		return graphql.Null
  1301  	}
  1302  	res := resTmp.(*InnerObject)
  1303  	fc.Result = res
  1304  	return ec.marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx, field.Selections, res)
  1305  }
  1306  
  1307  func (ec *executionContext) fieldContext_OuterObject_inner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1308  	fc = &graphql.FieldContext{
  1309  		Object:     "OuterObject",
  1310  		Field:      field,
  1311  		IsMethod:   false,
  1312  		IsResolver: false,
  1313  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1314  			switch field.Name {
  1315  			case "id":
  1316  				return ec.fieldContext_InnerObject_id(ctx, field)
  1317  			}
  1318  			return nil, fmt.Errorf("no field named %q was found under type InnerObject", field.Name)
  1319  		},
  1320  	}
  1321  	return fc, nil
  1322  }
  1323  
  1324  func (ec *executionContext) _Pet_id(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) {
  1325  	fc, err := ec.fieldContext_Pet_id(ctx, field)
  1326  	if err != nil {
  1327  		return graphql.Null
  1328  	}
  1329  	ctx = graphql.WithFieldContext(ctx, fc)
  1330  	defer func() {
  1331  		if r := recover(); r != nil {
  1332  			ec.Error(ctx, ec.Recover(ctx, r))
  1333  			ret = graphql.Null
  1334  		}
  1335  	}()
  1336  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1337  		ctx = rctx // use context from middleware stack in children
  1338  		return obj.ID, nil
  1339  	})
  1340  
  1341  	if resTmp == nil {
  1342  		if !graphql.HasFieldError(ctx, fc) {
  1343  			ec.Errorf(ctx, "must not be null")
  1344  		}
  1345  		return graphql.Null
  1346  	}
  1347  	res := resTmp.(int)
  1348  	fc.Result = res
  1349  	return ec.marshalNInt2int(ctx, field.Selections, res)
  1350  }
  1351  
  1352  func (ec *executionContext) fieldContext_Pet_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1353  	fc = &graphql.FieldContext{
  1354  		Object:     "Pet",
  1355  		Field:      field,
  1356  		IsMethod:   false,
  1357  		IsResolver: false,
  1358  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1359  			return nil, errors.New("field of type Int does not have child fields")
  1360  		},
  1361  	}
  1362  	return fc, nil
  1363  }
  1364  
  1365  func (ec *executionContext) _Pet_friends(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) {
  1366  	fc, err := ec.fieldContext_Pet_friends(ctx, field)
  1367  	if err != nil {
  1368  		return graphql.Null
  1369  	}
  1370  	ctx = graphql.WithFieldContext(ctx, fc)
  1371  	defer func() {
  1372  		if r := recover(); r != nil {
  1373  			ec.Error(ctx, ec.Recover(ctx, r))
  1374  			ret = graphql.Null
  1375  		}
  1376  	}()
  1377  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1378  		ctx = rctx // use context from middleware stack in children
  1379  		return ec.resolvers.Pet().Friends(rctx, obj, fc.Args["limit"].(*int))
  1380  	})
  1381  
  1382  	if resTmp == nil {
  1383  		return graphql.Null
  1384  	}
  1385  	res := resTmp.([]*Pet)
  1386  	fc.Result = res
  1387  	return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx, field.Selections, res)
  1388  }
  1389  
  1390  func (ec *executionContext) fieldContext_Pet_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1391  	fc = &graphql.FieldContext{
  1392  		Object:     "Pet",
  1393  		Field:      field,
  1394  		IsMethod:   true,
  1395  		IsResolver: true,
  1396  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1397  			switch field.Name {
  1398  			case "id":
  1399  				return ec.fieldContext_Pet_id(ctx, field)
  1400  			case "friends":
  1401  				return ec.fieldContext_Pet_friends(ctx, field)
  1402  			}
  1403  			return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name)
  1404  		},
  1405  	}
  1406  	defer func() {
  1407  		if r := recover(); r != nil {
  1408  			err = ec.Recover(ctx, r)
  1409  			ec.Error(ctx, err)
  1410  		}
  1411  	}()
  1412  	ctx = graphql.WithFieldContext(ctx, fc)
  1413  	if fc.Args, err = ec.field_Pet_friends_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1414  		ec.Error(ctx, err)
  1415  		return
  1416  	}
  1417  	return fc, nil
  1418  }
  1419  
  1420  func (ec *executionContext) _Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1421  	fc, err := ec.fieldContext_Query_invalidIdentifier(ctx, field)
  1422  	if err != nil {
  1423  		return graphql.Null
  1424  	}
  1425  	ctx = graphql.WithFieldContext(ctx, fc)
  1426  	defer func() {
  1427  		if r := recover(); r != nil {
  1428  			ec.Error(ctx, ec.Recover(ctx, r))
  1429  			ret = graphql.Null
  1430  		}
  1431  	}()
  1432  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1433  		ctx = rctx // use context from middleware stack in children
  1434  		return ec.resolvers.Query().InvalidIdentifier(rctx)
  1435  	})
  1436  
  1437  	if resTmp == nil {
  1438  		return graphql.Null
  1439  	}
  1440  	res := resTmp.(*invalid_packagename.InvalidIdentifier)
  1441  	fc.Result = res
  1442  	return ec.marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx, field.Selections, res)
  1443  }
  1444  
  1445  func (ec *executionContext) fieldContext_Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1446  	fc = &graphql.FieldContext{
  1447  		Object:     "Query",
  1448  		Field:      field,
  1449  		IsMethod:   true,
  1450  		IsResolver: true,
  1451  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1452  			switch field.Name {
  1453  			case "id":
  1454  				return ec.fieldContext_InvalidIdentifier_id(ctx, field)
  1455  			}
  1456  			return nil, fmt.Errorf("no field named %q was found under type InvalidIdentifier", field.Name)
  1457  		},
  1458  	}
  1459  	return fc, nil
  1460  }
  1461  
  1462  func (ec *executionContext) _Query_collision(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1463  	fc, err := ec.fieldContext_Query_collision(ctx, field)
  1464  	if err != nil {
  1465  		return graphql.Null
  1466  	}
  1467  	ctx = graphql.WithFieldContext(ctx, fc)
  1468  	defer func() {
  1469  		if r := recover(); r != nil {
  1470  			ec.Error(ctx, ec.Recover(ctx, r))
  1471  			ret = graphql.Null
  1472  		}
  1473  	}()
  1474  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1475  		ctx = rctx // use context from middleware stack in children
  1476  		return ec.resolvers.Query().Collision(rctx)
  1477  	})
  1478  
  1479  	if resTmp == nil {
  1480  		return graphql.Null
  1481  	}
  1482  	res := resTmp.(*introspection1.It)
  1483  	fc.Result = res
  1484  	return ec.marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx, field.Selections, res)
  1485  }
  1486  
  1487  func (ec *executionContext) fieldContext_Query_collision(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1488  	fc = &graphql.FieldContext{
  1489  		Object:     "Query",
  1490  		Field:      field,
  1491  		IsMethod:   true,
  1492  		IsResolver: true,
  1493  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1494  			switch field.Name {
  1495  			case "id":
  1496  				return ec.fieldContext_It_id(ctx, field)
  1497  			}
  1498  			return nil, fmt.Errorf("no field named %q was found under type It", field.Name)
  1499  		},
  1500  	}
  1501  	return fc, nil
  1502  }
  1503  
  1504  func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1505  	fc, err := ec.fieldContext_Query_mapInput(ctx, field)
  1506  	if err != nil {
  1507  		return graphql.Null
  1508  	}
  1509  	ctx = graphql.WithFieldContext(ctx, fc)
  1510  	defer func() {
  1511  		if r := recover(); r != nil {
  1512  			ec.Error(ctx, ec.Recover(ctx, r))
  1513  			ret = graphql.Null
  1514  		}
  1515  	}()
  1516  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1517  		ctx = rctx // use context from middleware stack in children
  1518  		return ec.resolvers.Query().MapInput(rctx, fc.Args["input"].(map[string]interface{}))
  1519  	})
  1520  
  1521  	if resTmp == nil {
  1522  		return graphql.Null
  1523  	}
  1524  	res := resTmp.(*bool)
  1525  	fc.Result = res
  1526  	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
  1527  }
  1528  
  1529  func (ec *executionContext) fieldContext_Query_mapInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1530  	fc = &graphql.FieldContext{
  1531  		Object:     "Query",
  1532  		Field:      field,
  1533  		IsMethod:   true,
  1534  		IsResolver: true,
  1535  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1536  			return nil, errors.New("field of type Boolean does not have child fields")
  1537  		},
  1538  	}
  1539  	defer func() {
  1540  		if r := recover(); r != nil {
  1541  			err = ec.Recover(ctx, r)
  1542  			ec.Error(ctx, err)
  1543  		}
  1544  	}()
  1545  	ctx = graphql.WithFieldContext(ctx, fc)
  1546  	if fc.Args, err = ec.field_Query_mapInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1547  		ec.Error(ctx, err)
  1548  		return
  1549  	}
  1550  	return fc, nil
  1551  }
  1552  
  1553  func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1554  	fc, err := ec.fieldContext_Query_recursive(ctx, field)
  1555  	if err != nil {
  1556  		return graphql.Null
  1557  	}
  1558  	ctx = graphql.WithFieldContext(ctx, fc)
  1559  	defer func() {
  1560  		if r := recover(); r != nil {
  1561  			ec.Error(ctx, ec.Recover(ctx, r))
  1562  			ret = graphql.Null
  1563  		}
  1564  	}()
  1565  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1566  		ctx = rctx // use context from middleware stack in children
  1567  		return ec.resolvers.Query().Recursive(rctx, fc.Args["input"].(*RecursiveInputSlice))
  1568  	})
  1569  
  1570  	if resTmp == nil {
  1571  		return graphql.Null
  1572  	}
  1573  	res := resTmp.(*bool)
  1574  	fc.Result = res
  1575  	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
  1576  }
  1577  
  1578  func (ec *executionContext) fieldContext_Query_recursive(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1579  	fc = &graphql.FieldContext{
  1580  		Object:     "Query",
  1581  		Field:      field,
  1582  		IsMethod:   true,
  1583  		IsResolver: true,
  1584  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1585  			return nil, errors.New("field of type Boolean does not have child fields")
  1586  		},
  1587  	}
  1588  	defer func() {
  1589  		if r := recover(); r != nil {
  1590  			err = ec.Recover(ctx, r)
  1591  			ec.Error(ctx, err)
  1592  		}
  1593  	}()
  1594  	ctx = graphql.WithFieldContext(ctx, fc)
  1595  	if fc.Args, err = ec.field_Query_recursive_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1596  		ec.Error(ctx, err)
  1597  		return
  1598  	}
  1599  	return fc, nil
  1600  }
  1601  
  1602  func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1603  	fc, err := ec.fieldContext_Query_nestedInputs(ctx, field)
  1604  	if err != nil {
  1605  		return graphql.Null
  1606  	}
  1607  	ctx = graphql.WithFieldContext(ctx, fc)
  1608  	defer func() {
  1609  		if r := recover(); r != nil {
  1610  			ec.Error(ctx, ec.Recover(ctx, r))
  1611  			ret = graphql.Null
  1612  		}
  1613  	}()
  1614  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1615  		ctx = rctx // use context from middleware stack in children
  1616  		return ec.resolvers.Query().NestedInputs(rctx, fc.Args["input"].([][]*OuterInput))
  1617  	})
  1618  
  1619  	if resTmp == nil {
  1620  		return graphql.Null
  1621  	}
  1622  	res := resTmp.(*bool)
  1623  	fc.Result = res
  1624  	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
  1625  }
  1626  
  1627  func (ec *executionContext) fieldContext_Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1628  	fc = &graphql.FieldContext{
  1629  		Object:     "Query",
  1630  		Field:      field,
  1631  		IsMethod:   true,
  1632  		IsResolver: true,
  1633  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1634  			return nil, errors.New("field of type Boolean does not have child fields")
  1635  		},
  1636  	}
  1637  	defer func() {
  1638  		if r := recover(); r != nil {
  1639  			err = ec.Recover(ctx, r)
  1640  			ec.Error(ctx, err)
  1641  		}
  1642  	}()
  1643  	ctx = graphql.WithFieldContext(ctx, fc)
  1644  	if fc.Args, err = ec.field_Query_nestedInputs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1645  		ec.Error(ctx, err)
  1646  		return
  1647  	}
  1648  	return fc, nil
  1649  }
  1650  
  1651  func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1652  	fc, err := ec.fieldContext_Query_nestedOutputs(ctx, field)
  1653  	if err != nil {
  1654  		return graphql.Null
  1655  	}
  1656  	ctx = graphql.WithFieldContext(ctx, fc)
  1657  	defer func() {
  1658  		if r := recover(); r != nil {
  1659  			ec.Error(ctx, ec.Recover(ctx, r))
  1660  			ret = graphql.Null
  1661  		}
  1662  	}()
  1663  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1664  		ctx = rctx // use context from middleware stack in children
  1665  		return ec.resolvers.Query().NestedOutputs(rctx)
  1666  	})
  1667  
  1668  	if resTmp == nil {
  1669  		return graphql.Null
  1670  	}
  1671  	res := resTmp.([][]*OuterObject)
  1672  	fc.Result = res
  1673  	return ec.marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, field.Selections, res)
  1674  }
  1675  
  1676  func (ec *executionContext) fieldContext_Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1677  	fc = &graphql.FieldContext{
  1678  		Object:     "Query",
  1679  		Field:      field,
  1680  		IsMethod:   true,
  1681  		IsResolver: true,
  1682  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1683  			switch field.Name {
  1684  			case "inner":
  1685  				return ec.fieldContext_OuterObject_inner(ctx, field)
  1686  			}
  1687  			return nil, fmt.Errorf("no field named %q was found under type OuterObject", field.Name)
  1688  		},
  1689  	}
  1690  	return fc, nil
  1691  }
  1692  
  1693  func (ec *executionContext) _Query_modelMethods(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1694  	fc, err := ec.fieldContext_Query_modelMethods(ctx, field)
  1695  	if err != nil {
  1696  		return graphql.Null
  1697  	}
  1698  	ctx = graphql.WithFieldContext(ctx, fc)
  1699  	defer func() {
  1700  		if r := recover(); r != nil {
  1701  			ec.Error(ctx, ec.Recover(ctx, r))
  1702  			ret = graphql.Null
  1703  		}
  1704  	}()
  1705  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1706  		ctx = rctx // use context from middleware stack in children
  1707  		return ec.resolvers.Query().ModelMethods(rctx)
  1708  	})
  1709  
  1710  	if resTmp == nil {
  1711  		return graphql.Null
  1712  	}
  1713  	res := resTmp.(*ModelMethods)
  1714  	fc.Result = res
  1715  	return ec.marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx, field.Selections, res)
  1716  }
  1717  
  1718  func (ec *executionContext) fieldContext_Query_modelMethods(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1719  	fc = &graphql.FieldContext{
  1720  		Object:     "Query",
  1721  		Field:      field,
  1722  		IsMethod:   true,
  1723  		IsResolver: true,
  1724  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1725  			switch field.Name {
  1726  			case "resolverField":
  1727  				return ec.fieldContext_ModelMethods_resolverField(ctx, field)
  1728  			case "noContext":
  1729  				return ec.fieldContext_ModelMethods_noContext(ctx, field)
  1730  			case "withContext":
  1731  				return ec.fieldContext_ModelMethods_withContext(ctx, field)
  1732  			}
  1733  			return nil, fmt.Errorf("no field named %q was found under type ModelMethods", field.Name)
  1734  		},
  1735  	}
  1736  	return fc, nil
  1737  }
  1738  
  1739  func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1740  	fc, err := ec.fieldContext_Query_user(ctx, field)
  1741  	if err != nil {
  1742  		return graphql.Null
  1743  	}
  1744  	ctx = graphql.WithFieldContext(ctx, fc)
  1745  	defer func() {
  1746  		if r := recover(); r != nil {
  1747  			ec.Error(ctx, ec.Recover(ctx, r))
  1748  			ret = graphql.Null
  1749  		}
  1750  	}()
  1751  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1752  		ctx = rctx // use context from middleware stack in children
  1753  		return ec.resolvers.Query().User(rctx, fc.Args["id"].(int))
  1754  	})
  1755  
  1756  	if resTmp == nil {
  1757  		if !graphql.HasFieldError(ctx, fc) {
  1758  			ec.Errorf(ctx, "must not be null")
  1759  		}
  1760  		return graphql.Null
  1761  	}
  1762  	res := resTmp.(*User)
  1763  	fc.Result = res
  1764  	return ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, field.Selections, res)
  1765  }
  1766  
  1767  func (ec *executionContext) fieldContext_Query_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1768  	fc = &graphql.FieldContext{
  1769  		Object:     "Query",
  1770  		Field:      field,
  1771  		IsMethod:   true,
  1772  		IsResolver: true,
  1773  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1774  			switch field.Name {
  1775  			case "id":
  1776  				return ec.fieldContext_User_id(ctx, field)
  1777  			case "friends":
  1778  				return ec.fieldContext_User_friends(ctx, field)
  1779  			case "created":
  1780  				return ec.fieldContext_User_created(ctx, field)
  1781  			case "updated":
  1782  				return ec.fieldContext_User_updated(ctx, field)
  1783  			case "pets":
  1784  				return ec.fieldContext_User_pets(ctx, field)
  1785  			}
  1786  			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
  1787  		},
  1788  	}
  1789  	defer func() {
  1790  		if r := recover(); r != nil {
  1791  			err = ec.Recover(ctx, r)
  1792  			ec.Error(ctx, err)
  1793  		}
  1794  	}()
  1795  	ctx = graphql.WithFieldContext(ctx, fc)
  1796  	if fc.Args, err = ec.field_Query_user_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1797  		ec.Error(ctx, err)
  1798  		return
  1799  	}
  1800  	return fc, nil
  1801  }
  1802  
  1803  func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1804  	fc, err := ec.fieldContext_Query_nullableArg(ctx, field)
  1805  	if err != nil {
  1806  		return graphql.Null
  1807  	}
  1808  	ctx = graphql.WithFieldContext(ctx, fc)
  1809  	defer func() {
  1810  		if r := recover(); r != nil {
  1811  			ec.Error(ctx, ec.Recover(ctx, r))
  1812  			ret = graphql.Null
  1813  		}
  1814  	}()
  1815  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1816  		ctx = rctx // use context from middleware stack in children
  1817  		return ec.resolvers.Query().NullableArg(rctx, fc.Args["arg"].(*int))
  1818  	})
  1819  
  1820  	if resTmp == nil {
  1821  		return graphql.Null
  1822  	}
  1823  	res := resTmp.(*string)
  1824  	fc.Result = res
  1825  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1826  }
  1827  
  1828  func (ec *executionContext) fieldContext_Query_nullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1829  	fc = &graphql.FieldContext{
  1830  		Object:     "Query",
  1831  		Field:      field,
  1832  		IsMethod:   true,
  1833  		IsResolver: true,
  1834  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1835  			return nil, errors.New("field of type String does not have child fields")
  1836  		},
  1837  	}
  1838  	defer func() {
  1839  		if r := recover(); r != nil {
  1840  			err = ec.Recover(ctx, r)
  1841  			ec.Error(ctx, err)
  1842  		}
  1843  	}()
  1844  	ctx = graphql.WithFieldContext(ctx, fc)
  1845  	if fc.Args, err = ec.field_Query_nullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1846  		ec.Error(ctx, err)
  1847  		return
  1848  	}
  1849  	return fc, nil
  1850  }
  1851  
  1852  func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1853  	fc, err := ec.fieldContext_Query_inputSlice(ctx, field)
  1854  	if err != nil {
  1855  		return graphql.Null
  1856  	}
  1857  	ctx = graphql.WithFieldContext(ctx, fc)
  1858  	defer func() {
  1859  		if r := recover(); r != nil {
  1860  			ec.Error(ctx, ec.Recover(ctx, r))
  1861  			ret = graphql.Null
  1862  		}
  1863  	}()
  1864  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1865  		ctx = rctx // use context from middleware stack in children
  1866  		return ec.resolvers.Query().InputSlice(rctx, fc.Args["arg"].([]string))
  1867  	})
  1868  
  1869  	if resTmp == nil {
  1870  		if !graphql.HasFieldError(ctx, fc) {
  1871  			ec.Errorf(ctx, "must not be null")
  1872  		}
  1873  		return graphql.Null
  1874  	}
  1875  	res := resTmp.(bool)
  1876  	fc.Result = res
  1877  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1878  }
  1879  
  1880  func (ec *executionContext) fieldContext_Query_inputSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1881  	fc = &graphql.FieldContext{
  1882  		Object:     "Query",
  1883  		Field:      field,
  1884  		IsMethod:   true,
  1885  		IsResolver: true,
  1886  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1887  			return nil, errors.New("field of type Boolean does not have child fields")
  1888  		},
  1889  	}
  1890  	defer func() {
  1891  		if r := recover(); r != nil {
  1892  			err = ec.Recover(ctx, r)
  1893  			ec.Error(ctx, err)
  1894  		}
  1895  	}()
  1896  	ctx = graphql.WithFieldContext(ctx, fc)
  1897  	if fc.Args, err = ec.field_Query_inputSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1898  		ec.Error(ctx, err)
  1899  		return
  1900  	}
  1901  	return fc, nil
  1902  }
  1903  
  1904  func (ec *executionContext) _Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1905  	fc, err := ec.fieldContext_Query_inputNullableSlice(ctx, field)
  1906  	if err != nil {
  1907  		return graphql.Null
  1908  	}
  1909  	ctx = graphql.WithFieldContext(ctx, fc)
  1910  	defer func() {
  1911  		if r := recover(); r != nil {
  1912  			ec.Error(ctx, ec.Recover(ctx, r))
  1913  			ret = graphql.Null
  1914  		}
  1915  	}()
  1916  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1917  		ctx = rctx // use context from middleware stack in children
  1918  		return ec.resolvers.Query().InputNullableSlice(rctx, fc.Args["arg"].([]string))
  1919  	})
  1920  
  1921  	if resTmp == nil {
  1922  		if !graphql.HasFieldError(ctx, fc) {
  1923  			ec.Errorf(ctx, "must not be null")
  1924  		}
  1925  		return graphql.Null
  1926  	}
  1927  	res := resTmp.(bool)
  1928  	fc.Result = res
  1929  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1930  }
  1931  
  1932  func (ec *executionContext) fieldContext_Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1933  	fc = &graphql.FieldContext{
  1934  		Object:     "Query",
  1935  		Field:      field,
  1936  		IsMethod:   true,
  1937  		IsResolver: true,
  1938  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1939  			return nil, errors.New("field of type Boolean does not have child fields")
  1940  		},
  1941  	}
  1942  	defer func() {
  1943  		if r := recover(); r != nil {
  1944  			err = ec.Recover(ctx, r)
  1945  			ec.Error(ctx, err)
  1946  		}
  1947  	}()
  1948  	ctx = graphql.WithFieldContext(ctx, fc)
  1949  	if fc.Args, err = ec.field_Query_inputNullableSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1950  		ec.Error(ctx, err)
  1951  		return
  1952  	}
  1953  	return fc, nil
  1954  }
  1955  
  1956  func (ec *executionContext) _Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1957  	fc, err := ec.fieldContext_Query_shapeUnion(ctx, field)
  1958  	if err != nil {
  1959  		return graphql.Null
  1960  	}
  1961  	ctx = graphql.WithFieldContext(ctx, fc)
  1962  	defer func() {
  1963  		if r := recover(); r != nil {
  1964  			ec.Error(ctx, ec.Recover(ctx, r))
  1965  			ret = graphql.Null
  1966  		}
  1967  	}()
  1968  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1969  		ctx = rctx // use context from middleware stack in children
  1970  		return ec.resolvers.Query().ShapeUnion(rctx)
  1971  	})
  1972  
  1973  	if resTmp == nil {
  1974  		if !graphql.HasFieldError(ctx, fc) {
  1975  			ec.Errorf(ctx, "must not be null")
  1976  		}
  1977  		return graphql.Null
  1978  	}
  1979  	res := resTmp.(ShapeUnion)
  1980  	fc.Result = res
  1981  	return ec.marshalNShapeUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShapeUnion(ctx, field.Selections, res)
  1982  }
  1983  
  1984  func (ec *executionContext) fieldContext_Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1985  	fc = &graphql.FieldContext{
  1986  		Object:     "Query",
  1987  		Field:      field,
  1988  		IsMethod:   true,
  1989  		IsResolver: true,
  1990  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1991  			return nil, errors.New("field of type ShapeUnion does not have child fields")
  1992  		},
  1993  	}
  1994  	return fc, nil
  1995  }
  1996  
  1997  func (ec *executionContext) _Query_autobind(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1998  	fc, err := ec.fieldContext_Query_autobind(ctx, field)
  1999  	if err != nil {
  2000  		return graphql.Null
  2001  	}
  2002  	ctx = graphql.WithFieldContext(ctx, fc)
  2003  	defer func() {
  2004  		if r := recover(); r != nil {
  2005  			ec.Error(ctx, ec.Recover(ctx, r))
  2006  			ret = graphql.Null
  2007  		}
  2008  	}()
  2009  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2010  		ctx = rctx // use context from middleware stack in children
  2011  		return ec.resolvers.Query().Autobind(rctx)
  2012  	})
  2013  
  2014  	if resTmp == nil {
  2015  		return graphql.Null
  2016  	}
  2017  	res := resTmp.(*Autobind)
  2018  	fc.Result = res
  2019  	return ec.marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx, field.Selections, res)
  2020  }
  2021  
  2022  func (ec *executionContext) fieldContext_Query_autobind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2023  	fc = &graphql.FieldContext{
  2024  		Object:     "Query",
  2025  		Field:      field,
  2026  		IsMethod:   true,
  2027  		IsResolver: true,
  2028  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2029  			switch field.Name {
  2030  			case "int":
  2031  				return ec.fieldContext_Autobind_int(ctx, field)
  2032  			case "int32":
  2033  				return ec.fieldContext_Autobind_int32(ctx, field)
  2034  			case "int64":
  2035  				return ec.fieldContext_Autobind_int64(ctx, field)
  2036  			case "idStr":
  2037  				return ec.fieldContext_Autobind_idStr(ctx, field)
  2038  			case "idInt":
  2039  				return ec.fieldContext_Autobind_idInt(ctx, field)
  2040  			}
  2041  			return nil, fmt.Errorf("no field named %q was found under type Autobind", field.Name)
  2042  		},
  2043  	}
  2044  	return fc, nil
  2045  }
  2046  
  2047  func (ec *executionContext) _Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2048  	fc, err := ec.fieldContext_Query_deprecatedField(ctx, field)
  2049  	if err != nil {
  2050  		return graphql.Null
  2051  	}
  2052  	ctx = graphql.WithFieldContext(ctx, fc)
  2053  	defer func() {
  2054  		if r := recover(); r != nil {
  2055  			ec.Error(ctx, ec.Recover(ctx, r))
  2056  			ret = graphql.Null
  2057  		}
  2058  	}()
  2059  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2060  		ctx = rctx // use context from middleware stack in children
  2061  		return ec.resolvers.Query().DeprecatedField(rctx)
  2062  	})
  2063  
  2064  	if resTmp == nil {
  2065  		if !graphql.HasFieldError(ctx, fc) {
  2066  			ec.Errorf(ctx, "must not be null")
  2067  		}
  2068  		return graphql.Null
  2069  	}
  2070  	res := resTmp.(string)
  2071  	fc.Result = res
  2072  	return ec.marshalNString2string(ctx, field.Selections, res)
  2073  }
  2074  
  2075  func (ec *executionContext) fieldContext_Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2076  	fc = &graphql.FieldContext{
  2077  		Object:     "Query",
  2078  		Field:      field,
  2079  		IsMethod:   true,
  2080  		IsResolver: true,
  2081  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2082  			return nil, errors.New("field of type String does not have child fields")
  2083  		},
  2084  	}
  2085  	return fc, nil
  2086  }
  2087  
  2088  func (ec *executionContext) _Query_overlapping(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2089  	fc, err := ec.fieldContext_Query_overlapping(ctx, field)
  2090  	if err != nil {
  2091  		return graphql.Null
  2092  	}
  2093  	ctx = graphql.WithFieldContext(ctx, fc)
  2094  	defer func() {
  2095  		if r := recover(); r != nil {
  2096  			ec.Error(ctx, ec.Recover(ctx, r))
  2097  			ret = graphql.Null
  2098  		}
  2099  	}()
  2100  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2101  		ctx = rctx // use context from middleware stack in children
  2102  		return ec.resolvers.Query().Overlapping(rctx)
  2103  	})
  2104  
  2105  	if resTmp == nil {
  2106  		return graphql.Null
  2107  	}
  2108  	res := resTmp.(*OverlappingFields)
  2109  	fc.Result = res
  2110  	return ec.marshalOOverlappingFields2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOverlappingFields(ctx, field.Selections, res)
  2111  }
  2112  
  2113  func (ec *executionContext) fieldContext_Query_overlapping(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2114  	fc = &graphql.FieldContext{
  2115  		Object:     "Query",
  2116  		Field:      field,
  2117  		IsMethod:   true,
  2118  		IsResolver: true,
  2119  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2120  			switch field.Name {
  2121  			case "oneFoo":
  2122  				return ec.fieldContext_OverlappingFields_oneFoo(ctx, field)
  2123  			case "twoFoo":
  2124  				return ec.fieldContext_OverlappingFields_twoFoo(ctx, field)
  2125  			case "oldFoo":
  2126  				return ec.fieldContext_OverlappingFields_oldFoo(ctx, field)
  2127  			case "newFoo":
  2128  				return ec.fieldContext_OverlappingFields_newFoo(ctx, field)
  2129  			case "new_foo":
  2130  				return ec.fieldContext_OverlappingFields_new_foo(ctx, field)
  2131  			}
  2132  			return nil, fmt.Errorf("no field named %q was found under type OverlappingFields", field.Name)
  2133  		},
  2134  	}
  2135  	return fc, nil
  2136  }
  2137  
  2138  func (ec *executionContext) _Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2139  	fc, err := ec.fieldContext_Query_defaultParameters(ctx, field)
  2140  	if err != nil {
  2141  		return graphql.Null
  2142  	}
  2143  	ctx = graphql.WithFieldContext(ctx, fc)
  2144  	defer func() {
  2145  		if r := recover(); r != nil {
  2146  			ec.Error(ctx, ec.Recover(ctx, r))
  2147  			ret = graphql.Null
  2148  		}
  2149  	}()
  2150  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2151  		ctx = rctx // use context from middleware stack in children
  2152  		return ec.resolvers.Query().DefaultParameters(rctx, fc.Args["falsyBoolean"].(*bool), fc.Args["truthyBoolean"].(*bool))
  2153  	})
  2154  
  2155  	if resTmp == nil {
  2156  		if !graphql.HasFieldError(ctx, fc) {
  2157  			ec.Errorf(ctx, "must not be null")
  2158  		}
  2159  		return graphql.Null
  2160  	}
  2161  	res := resTmp.(*DefaultParametersMirror)
  2162  	fc.Result = res
  2163  	return ec.marshalNDefaultParametersMirror2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐDefaultParametersMirror(ctx, field.Selections, res)
  2164  }
  2165  
  2166  func (ec *executionContext) fieldContext_Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2167  	fc = &graphql.FieldContext{
  2168  		Object:     "Query",
  2169  		Field:      field,
  2170  		IsMethod:   true,
  2171  		IsResolver: true,
  2172  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2173  			switch field.Name {
  2174  			case "falsyBoolean":
  2175  				return ec.fieldContext_DefaultParametersMirror_falsyBoolean(ctx, field)
  2176  			case "truthyBoolean":
  2177  				return ec.fieldContext_DefaultParametersMirror_truthyBoolean(ctx, field)
  2178  			}
  2179  			return nil, fmt.Errorf("no field named %q was found under type DefaultParametersMirror", field.Name)
  2180  		},
  2181  	}
  2182  	defer func() {
  2183  		if r := recover(); r != nil {
  2184  			err = ec.Recover(ctx, r)
  2185  			ec.Error(ctx, err)
  2186  		}
  2187  	}()
  2188  	ctx = graphql.WithFieldContext(ctx, fc)
  2189  	if fc.Args, err = ec.field_Query_defaultParameters_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2190  		ec.Error(ctx, err)
  2191  		return
  2192  	}
  2193  	return fc, nil
  2194  }
  2195  
  2196  func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2197  	fc, err := ec.fieldContext_Query_directiveArg(ctx, field)
  2198  	if err != nil {
  2199  		return graphql.Null
  2200  	}
  2201  	ctx = graphql.WithFieldContext(ctx, fc)
  2202  	defer func() {
  2203  		if r := recover(); r != nil {
  2204  			ec.Error(ctx, ec.Recover(ctx, r))
  2205  			ret = graphql.Null
  2206  		}
  2207  	}()
  2208  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2209  		ctx = rctx // use context from middleware stack in children
  2210  		return ec.resolvers.Query().DirectiveArg(rctx, fc.Args["arg"].(string))
  2211  	})
  2212  
  2213  	if resTmp == nil {
  2214  		return graphql.Null
  2215  	}
  2216  	res := resTmp.(*string)
  2217  	fc.Result = res
  2218  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2219  }
  2220  
  2221  func (ec *executionContext) fieldContext_Query_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2222  	fc = &graphql.FieldContext{
  2223  		Object:     "Query",
  2224  		Field:      field,
  2225  		IsMethod:   true,
  2226  		IsResolver: true,
  2227  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2228  			return nil, errors.New("field of type String does not have child fields")
  2229  		},
  2230  	}
  2231  	defer func() {
  2232  		if r := recover(); r != nil {
  2233  			err = ec.Recover(ctx, r)
  2234  			ec.Error(ctx, err)
  2235  		}
  2236  	}()
  2237  	ctx = graphql.WithFieldContext(ctx, fc)
  2238  	if fc.Args, err = ec.field_Query_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2239  		ec.Error(ctx, err)
  2240  		return
  2241  	}
  2242  	return fc, nil
  2243  }
  2244  
  2245  func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2246  	fc, err := ec.fieldContext_Query_directiveNullableArg(ctx, field)
  2247  	if err != nil {
  2248  		return graphql.Null
  2249  	}
  2250  	ctx = graphql.WithFieldContext(ctx, fc)
  2251  	defer func() {
  2252  		if r := recover(); r != nil {
  2253  			ec.Error(ctx, ec.Recover(ctx, r))
  2254  			ret = graphql.Null
  2255  		}
  2256  	}()
  2257  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2258  		ctx = rctx // use context from middleware stack in children
  2259  		return ec.resolvers.Query().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string))
  2260  	})
  2261  
  2262  	if resTmp == nil {
  2263  		return graphql.Null
  2264  	}
  2265  	res := resTmp.(*string)
  2266  	fc.Result = res
  2267  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2268  }
  2269  
  2270  func (ec *executionContext) fieldContext_Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2271  	fc = &graphql.FieldContext{
  2272  		Object:     "Query",
  2273  		Field:      field,
  2274  		IsMethod:   true,
  2275  		IsResolver: true,
  2276  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2277  			return nil, errors.New("field of type String does not have child fields")
  2278  		},
  2279  	}
  2280  	defer func() {
  2281  		if r := recover(); r != nil {
  2282  			err = ec.Recover(ctx, r)
  2283  			ec.Error(ctx, err)
  2284  		}
  2285  	}()
  2286  	ctx = graphql.WithFieldContext(ctx, fc)
  2287  	if fc.Args, err = ec.field_Query_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2288  		ec.Error(ctx, err)
  2289  		return
  2290  	}
  2291  	return fc, nil
  2292  }
  2293  
  2294  func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2295  	fc, err := ec.fieldContext_Query_directiveInputNullable(ctx, field)
  2296  	if err != nil {
  2297  		return graphql.Null
  2298  	}
  2299  	ctx = graphql.WithFieldContext(ctx, fc)
  2300  	defer func() {
  2301  		if r := recover(); r != nil {
  2302  			ec.Error(ctx, ec.Recover(ctx, r))
  2303  			ret = graphql.Null
  2304  		}
  2305  	}()
  2306  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2307  		ctx = rctx // use context from middleware stack in children
  2308  		return ec.resolvers.Query().DirectiveInputNullable(rctx, fc.Args["arg"].(*InputDirectives))
  2309  	})
  2310  
  2311  	if resTmp == nil {
  2312  		return graphql.Null
  2313  	}
  2314  	res := resTmp.(*string)
  2315  	fc.Result = res
  2316  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2317  }
  2318  
  2319  func (ec *executionContext) fieldContext_Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2320  	fc = &graphql.FieldContext{
  2321  		Object:     "Query",
  2322  		Field:      field,
  2323  		IsMethod:   true,
  2324  		IsResolver: true,
  2325  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2326  			return nil, errors.New("field of type String does not have child fields")
  2327  		},
  2328  	}
  2329  	defer func() {
  2330  		if r := recover(); r != nil {
  2331  			err = ec.Recover(ctx, r)
  2332  			ec.Error(ctx, err)
  2333  		}
  2334  	}()
  2335  	ctx = graphql.WithFieldContext(ctx, fc)
  2336  	if fc.Args, err = ec.field_Query_directiveInputNullable_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2337  		ec.Error(ctx, err)
  2338  		return
  2339  	}
  2340  	return fc, nil
  2341  }
  2342  
  2343  func (ec *executionContext) _Query_directiveInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2344  	fc, err := ec.fieldContext_Query_directiveInput(ctx, field)
  2345  	if err != nil {
  2346  		return graphql.Null
  2347  	}
  2348  	ctx = graphql.WithFieldContext(ctx, fc)
  2349  	defer func() {
  2350  		if r := recover(); r != nil {
  2351  			ec.Error(ctx, ec.Recover(ctx, r))
  2352  			ret = graphql.Null
  2353  		}
  2354  	}()
  2355  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2356  		ctx = rctx // use context from middleware stack in children
  2357  		return ec.resolvers.Query().DirectiveInput(rctx, fc.Args["arg"].(InputDirectives))
  2358  	})
  2359  
  2360  	if resTmp == nil {
  2361  		return graphql.Null
  2362  	}
  2363  	res := resTmp.(*string)
  2364  	fc.Result = res
  2365  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2366  }
  2367  
  2368  func (ec *executionContext) fieldContext_Query_directiveInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2369  	fc = &graphql.FieldContext{
  2370  		Object:     "Query",
  2371  		Field:      field,
  2372  		IsMethod:   true,
  2373  		IsResolver: true,
  2374  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2375  			return nil, errors.New("field of type String does not have child fields")
  2376  		},
  2377  	}
  2378  	defer func() {
  2379  		if r := recover(); r != nil {
  2380  			err = ec.Recover(ctx, r)
  2381  			ec.Error(ctx, err)
  2382  		}
  2383  	}()
  2384  	ctx = graphql.WithFieldContext(ctx, fc)
  2385  	if fc.Args, err = ec.field_Query_directiveInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2386  		ec.Error(ctx, err)
  2387  		return
  2388  	}
  2389  	return fc, nil
  2390  }
  2391  
  2392  func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2393  	fc, err := ec.fieldContext_Query_directiveInputType(ctx, field)
  2394  	if err != nil {
  2395  		return graphql.Null
  2396  	}
  2397  	ctx = graphql.WithFieldContext(ctx, fc)
  2398  	defer func() {
  2399  		if r := recover(); r != nil {
  2400  			ec.Error(ctx, ec.Recover(ctx, r))
  2401  			ret = graphql.Null
  2402  		}
  2403  	}()
  2404  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2405  		ctx = rctx // use context from middleware stack in children
  2406  		return ec.resolvers.Query().DirectiveInputType(rctx, fc.Args["arg"].(InnerInput))
  2407  	})
  2408  
  2409  	if resTmp == nil {
  2410  		return graphql.Null
  2411  	}
  2412  	res := resTmp.(*string)
  2413  	fc.Result = res
  2414  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2415  }
  2416  
  2417  func (ec *executionContext) fieldContext_Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2418  	fc = &graphql.FieldContext{
  2419  		Object:     "Query",
  2420  		Field:      field,
  2421  		IsMethod:   true,
  2422  		IsResolver: true,
  2423  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2424  			return nil, errors.New("field of type String does not have child fields")
  2425  		},
  2426  	}
  2427  	defer func() {
  2428  		if r := recover(); r != nil {
  2429  			err = ec.Recover(ctx, r)
  2430  			ec.Error(ctx, err)
  2431  		}
  2432  	}()
  2433  	ctx = graphql.WithFieldContext(ctx, fc)
  2434  	if fc.Args, err = ec.field_Query_directiveInputType_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2435  		ec.Error(ctx, err)
  2436  		return
  2437  	}
  2438  	return fc, nil
  2439  }
  2440  
  2441  func (ec *executionContext) _Query_directiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2442  	fc, err := ec.fieldContext_Query_directiveObject(ctx, field)
  2443  	if err != nil {
  2444  		return graphql.Null
  2445  	}
  2446  	ctx = graphql.WithFieldContext(ctx, fc)
  2447  	defer func() {
  2448  		if r := recover(); r != nil {
  2449  			ec.Error(ctx, ec.Recover(ctx, r))
  2450  			ret = graphql.Null
  2451  		}
  2452  	}()
  2453  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2454  		directive0 := func(rctx context.Context) (interface{}, error) {
  2455  			ctx = rctx // use context from middleware stack in children
  2456  			return ec.resolvers.Query().DirectiveObject(rctx)
  2457  		}
  2458  		directive1 := func(ctx context.Context) (interface{}, error) {
  2459  			location, err := ec.unmarshalNString2string(ctx, "order1_1")
  2460  			if err != nil {
  2461  				return nil, err
  2462  			}
  2463  			if ec.directives.Order1 == nil {
  2464  				return nil, errors.New("directive order1 is not implemented")
  2465  			}
  2466  			return ec.directives.Order1(ctx, nil, directive0, location)
  2467  		}
  2468  		directive2 := func(ctx context.Context) (interface{}, error) {
  2469  			location, err := ec.unmarshalNString2string(ctx, "order1_2")
  2470  			if err != nil {
  2471  				return nil, err
  2472  			}
  2473  			if ec.directives.Order1 == nil {
  2474  				return nil, errors.New("directive order1 is not implemented")
  2475  			}
  2476  			return ec.directives.Order1(ctx, nil, directive1, location)
  2477  		}
  2478  		directive3 := func(ctx context.Context) (interface{}, error) {
  2479  			location, err := ec.unmarshalNString2string(ctx, "order2_1")
  2480  			if err != nil {
  2481  				return nil, err
  2482  			}
  2483  			if ec.directives.Order2 == nil {
  2484  				return nil, errors.New("directive order2 is not implemented")
  2485  			}
  2486  			return ec.directives.Order2(ctx, nil, directive2, location)
  2487  		}
  2488  		directive4 := func(ctx context.Context) (interface{}, error) {
  2489  			location, err := ec.unmarshalNString2string(ctx, "Query_field")
  2490  			if err != nil {
  2491  				return nil, err
  2492  			}
  2493  			if ec.directives.Order1 == nil {
  2494  				return nil, errors.New("directive order1 is not implemented")
  2495  			}
  2496  			return ec.directives.Order1(ctx, nil, directive3, location)
  2497  		}
  2498  
  2499  		tmp, err := directive4(rctx)
  2500  		if err != nil {
  2501  			return nil, graphql.ErrorOnPath(ctx, err)
  2502  		}
  2503  		if tmp == nil {
  2504  			return nil, nil
  2505  		}
  2506  		if data, ok := tmp.(*ObjectDirectives); ok {
  2507  			return data, nil
  2508  		}
  2509  		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/spread-ai/gqlgen/codegen/testserver/followschema.ObjectDirectives`, tmp)
  2510  	})
  2511  
  2512  	if resTmp == nil {
  2513  		return graphql.Null
  2514  	}
  2515  	res := resTmp.(*ObjectDirectives)
  2516  	fc.Result = res
  2517  	return ec.marshalOObjectDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐObjectDirectives(ctx, field.Selections, res)
  2518  }
  2519  
  2520  func (ec *executionContext) fieldContext_Query_directiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2521  	fc = &graphql.FieldContext{
  2522  		Object:     "Query",
  2523  		Field:      field,
  2524  		IsMethod:   true,
  2525  		IsResolver: true,
  2526  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2527  			switch field.Name {
  2528  			case "text":
  2529  				return ec.fieldContext_ObjectDirectives_text(ctx, field)
  2530  			case "nullableText":
  2531  				return ec.fieldContext_ObjectDirectives_nullableText(ctx, field)
  2532  			case "order":
  2533  				return ec.fieldContext_ObjectDirectives_order(ctx, field)
  2534  			}
  2535  			return nil, fmt.Errorf("no field named %q was found under type ObjectDirectives", field.Name)
  2536  		},
  2537  	}
  2538  	return fc, nil
  2539  }
  2540  
  2541  func (ec *executionContext) _Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2542  	fc, err := ec.fieldContext_Query_directiveObjectWithCustomGoModel(ctx, field)
  2543  	if err != nil {
  2544  		return graphql.Null
  2545  	}
  2546  	ctx = graphql.WithFieldContext(ctx, fc)
  2547  	defer func() {
  2548  		if r := recover(); r != nil {
  2549  			ec.Error(ctx, ec.Recover(ctx, r))
  2550  			ret = graphql.Null
  2551  		}
  2552  	}()
  2553  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2554  		ctx = rctx // use context from middleware stack in children
  2555  		return ec.resolvers.Query().DirectiveObjectWithCustomGoModel(rctx)
  2556  	})
  2557  
  2558  	if resTmp == nil {
  2559  		return graphql.Null
  2560  	}
  2561  	res := resTmp.(*ObjectDirectivesWithCustomGoModel)
  2562  	fc.Result = res
  2563  	return ec.marshalOObjectDirectivesWithCustomGoModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐObjectDirectivesWithCustomGoModel(ctx, field.Selections, res)
  2564  }
  2565  
  2566  func (ec *executionContext) fieldContext_Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2567  	fc = &graphql.FieldContext{
  2568  		Object:     "Query",
  2569  		Field:      field,
  2570  		IsMethod:   true,
  2571  		IsResolver: true,
  2572  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2573  			switch field.Name {
  2574  			case "nullableText":
  2575  				return ec.fieldContext_ObjectDirectivesWithCustomGoModel_nullableText(ctx, field)
  2576  			}
  2577  			return nil, fmt.Errorf("no field named %q was found under type ObjectDirectivesWithCustomGoModel", field.Name)
  2578  		},
  2579  	}
  2580  	return fc, nil
  2581  }
  2582  
  2583  func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2584  	fc, err := ec.fieldContext_Query_directiveFieldDef(ctx, field)
  2585  	if err != nil {
  2586  		return graphql.Null
  2587  	}
  2588  	ctx = graphql.WithFieldContext(ctx, fc)
  2589  	defer func() {
  2590  		if r := recover(); r != nil {
  2591  			ec.Error(ctx, ec.Recover(ctx, r))
  2592  			ret = graphql.Null
  2593  		}
  2594  	}()
  2595  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2596  		directive0 := func(rctx context.Context) (interface{}, error) {
  2597  			ctx = rctx // use context from middleware stack in children
  2598  			return ec.resolvers.Query().DirectiveFieldDef(rctx, fc.Args["ret"].(string))
  2599  		}
  2600  		directive1 := func(ctx context.Context) (interface{}, error) {
  2601  			min, err := ec.unmarshalNInt2int(ctx, 1)
  2602  			if err != nil {
  2603  				return nil, err
  2604  			}
  2605  			message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid")
  2606  			if err != nil {
  2607  				return nil, err
  2608  			}
  2609  			if ec.directives.Length == nil {
  2610  				return nil, errors.New("directive length is not implemented")
  2611  			}
  2612  			return ec.directives.Length(ctx, nil, directive0, min, nil, message)
  2613  		}
  2614  
  2615  		tmp, err := directive1(rctx)
  2616  		if err != nil {
  2617  			return nil, graphql.ErrorOnPath(ctx, err)
  2618  		}
  2619  		if tmp == nil {
  2620  			return nil, nil
  2621  		}
  2622  		if data, ok := tmp.(string); ok {
  2623  			return data, nil
  2624  		}
  2625  		return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
  2626  	})
  2627  
  2628  	if resTmp == nil {
  2629  		if !graphql.HasFieldError(ctx, fc) {
  2630  			ec.Errorf(ctx, "must not be null")
  2631  		}
  2632  		return graphql.Null
  2633  	}
  2634  	res := resTmp.(string)
  2635  	fc.Result = res
  2636  	return ec.marshalNString2string(ctx, field.Selections, res)
  2637  }
  2638  
  2639  func (ec *executionContext) fieldContext_Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2640  	fc = &graphql.FieldContext{
  2641  		Object:     "Query",
  2642  		Field:      field,
  2643  		IsMethod:   true,
  2644  		IsResolver: true,
  2645  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2646  			return nil, errors.New("field of type String does not have child fields")
  2647  		},
  2648  	}
  2649  	defer func() {
  2650  		if r := recover(); r != nil {
  2651  			err = ec.Recover(ctx, r)
  2652  			ec.Error(ctx, err)
  2653  		}
  2654  	}()
  2655  	ctx = graphql.WithFieldContext(ctx, fc)
  2656  	if fc.Args, err = ec.field_Query_directiveFieldDef_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2657  		ec.Error(ctx, err)
  2658  		return
  2659  	}
  2660  	return fc, nil
  2661  }
  2662  
  2663  func (ec *executionContext) _Query_directiveField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2664  	fc, err := ec.fieldContext_Query_directiveField(ctx, field)
  2665  	if err != nil {
  2666  		return graphql.Null
  2667  	}
  2668  	ctx = graphql.WithFieldContext(ctx, fc)
  2669  	defer func() {
  2670  		if r := recover(); r != nil {
  2671  			ec.Error(ctx, ec.Recover(ctx, r))
  2672  			ret = graphql.Null
  2673  		}
  2674  	}()
  2675  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2676  		ctx = rctx // use context from middleware stack in children
  2677  		return ec.resolvers.Query().DirectiveField(rctx)
  2678  	})
  2679  
  2680  	if resTmp == nil {
  2681  		return graphql.Null
  2682  	}
  2683  	res := resTmp.(*string)
  2684  	fc.Result = res
  2685  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2686  }
  2687  
  2688  func (ec *executionContext) fieldContext_Query_directiveField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2689  	fc = &graphql.FieldContext{
  2690  		Object:     "Query",
  2691  		Field:      field,
  2692  		IsMethod:   true,
  2693  		IsResolver: true,
  2694  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2695  			return nil, errors.New("field of type String does not have child fields")
  2696  		},
  2697  	}
  2698  	return fc, nil
  2699  }
  2700  
  2701  func (ec *executionContext) _Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2702  	fc, err := ec.fieldContext_Query_directiveDouble(ctx, field)
  2703  	if err != nil {
  2704  		return graphql.Null
  2705  	}
  2706  	ctx = graphql.WithFieldContext(ctx, fc)
  2707  	defer func() {
  2708  		if r := recover(); r != nil {
  2709  			ec.Error(ctx, ec.Recover(ctx, r))
  2710  			ret = graphql.Null
  2711  		}
  2712  	}()
  2713  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2714  		directive0 := func(rctx context.Context) (interface{}, error) {
  2715  			ctx = rctx // use context from middleware stack in children
  2716  			return ec.resolvers.Query().DirectiveDouble(rctx)
  2717  		}
  2718  		directive1 := func(ctx context.Context) (interface{}, error) {
  2719  			if ec.directives.Directive1 == nil {
  2720  				return nil, errors.New("directive directive1 is not implemented")
  2721  			}
  2722  			return ec.directives.Directive1(ctx, nil, directive0)
  2723  		}
  2724  		directive2 := func(ctx context.Context) (interface{}, error) {
  2725  			if ec.directives.Directive2 == nil {
  2726  				return nil, errors.New("directive directive2 is not implemented")
  2727  			}
  2728  			return ec.directives.Directive2(ctx, nil, directive1)
  2729  		}
  2730  
  2731  		tmp, err := directive2(rctx)
  2732  		if err != nil {
  2733  			return nil, graphql.ErrorOnPath(ctx, err)
  2734  		}
  2735  		if tmp == nil {
  2736  			return nil, nil
  2737  		}
  2738  		if data, ok := tmp.(*string); ok {
  2739  			return data, nil
  2740  		}
  2741  		return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
  2742  	})
  2743  
  2744  	if resTmp == nil {
  2745  		return graphql.Null
  2746  	}
  2747  	res := resTmp.(*string)
  2748  	fc.Result = res
  2749  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2750  }
  2751  
  2752  func (ec *executionContext) fieldContext_Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2753  	fc = &graphql.FieldContext{
  2754  		Object:     "Query",
  2755  		Field:      field,
  2756  		IsMethod:   true,
  2757  		IsResolver: true,
  2758  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2759  			return nil, errors.New("field of type String does not have child fields")
  2760  		},
  2761  	}
  2762  	return fc, nil
  2763  }
  2764  
  2765  func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2766  	fc, err := ec.fieldContext_Query_directiveUnimplemented(ctx, field)
  2767  	if err != nil {
  2768  		return graphql.Null
  2769  	}
  2770  	ctx = graphql.WithFieldContext(ctx, fc)
  2771  	defer func() {
  2772  		if r := recover(); r != nil {
  2773  			ec.Error(ctx, ec.Recover(ctx, r))
  2774  			ret = graphql.Null
  2775  		}
  2776  	}()
  2777  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2778  		directive0 := func(rctx context.Context) (interface{}, error) {
  2779  			ctx = rctx // use context from middleware stack in children
  2780  			return ec.resolvers.Query().DirectiveUnimplemented(rctx)
  2781  		}
  2782  		directive1 := func(ctx context.Context) (interface{}, error) {
  2783  			if ec.directives.Unimplemented == nil {
  2784  				return nil, errors.New("directive unimplemented is not implemented")
  2785  			}
  2786  			return ec.directives.Unimplemented(ctx, nil, directive0)
  2787  		}
  2788  
  2789  		tmp, err := directive1(rctx)
  2790  		if err != nil {
  2791  			return nil, graphql.ErrorOnPath(ctx, err)
  2792  		}
  2793  		if tmp == nil {
  2794  			return nil, nil
  2795  		}
  2796  		if data, ok := tmp.(*string); ok {
  2797  			return data, nil
  2798  		}
  2799  		return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
  2800  	})
  2801  
  2802  	if resTmp == nil {
  2803  		return graphql.Null
  2804  	}
  2805  	res := resTmp.(*string)
  2806  	fc.Result = res
  2807  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2808  }
  2809  
  2810  func (ec *executionContext) fieldContext_Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2811  	fc = &graphql.FieldContext{
  2812  		Object:     "Query",
  2813  		Field:      field,
  2814  		IsMethod:   true,
  2815  		IsResolver: true,
  2816  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2817  			return nil, errors.New("field of type String does not have child fields")
  2818  		},
  2819  	}
  2820  	return fc, nil
  2821  }
  2822  
  2823  func (ec *executionContext) _Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2824  	fc, err := ec.fieldContext_Query_embeddedCase1(ctx, field)
  2825  	if err != nil {
  2826  		return graphql.Null
  2827  	}
  2828  	ctx = graphql.WithFieldContext(ctx, fc)
  2829  	defer func() {
  2830  		if r := recover(); r != nil {
  2831  			ec.Error(ctx, ec.Recover(ctx, r))
  2832  			ret = graphql.Null
  2833  		}
  2834  	}()
  2835  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2836  		ctx = rctx // use context from middleware stack in children
  2837  		return ec.resolvers.Query().EmbeddedCase1(rctx)
  2838  	})
  2839  
  2840  	if resTmp == nil {
  2841  		return graphql.Null
  2842  	}
  2843  	res := resTmp.(*EmbeddedCase1)
  2844  	fc.Result = res
  2845  	return ec.marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase1(ctx, field.Selections, res)
  2846  }
  2847  
  2848  func (ec *executionContext) fieldContext_Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2849  	fc = &graphql.FieldContext{
  2850  		Object:     "Query",
  2851  		Field:      field,
  2852  		IsMethod:   true,
  2853  		IsResolver: true,
  2854  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2855  			switch field.Name {
  2856  			case "exportedEmbeddedPointerExportedMethod":
  2857  				return ec.fieldContext_EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field)
  2858  			}
  2859  			return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase1", field.Name)
  2860  		},
  2861  	}
  2862  	return fc, nil
  2863  }
  2864  
  2865  func (ec *executionContext) _Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2866  	fc, err := ec.fieldContext_Query_embeddedCase2(ctx, field)
  2867  	if err != nil {
  2868  		return graphql.Null
  2869  	}
  2870  	ctx = graphql.WithFieldContext(ctx, fc)
  2871  	defer func() {
  2872  		if r := recover(); r != nil {
  2873  			ec.Error(ctx, ec.Recover(ctx, r))
  2874  			ret = graphql.Null
  2875  		}
  2876  	}()
  2877  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2878  		ctx = rctx // use context from middleware stack in children
  2879  		return ec.resolvers.Query().EmbeddedCase2(rctx)
  2880  	})
  2881  
  2882  	if resTmp == nil {
  2883  		return graphql.Null
  2884  	}
  2885  	res := resTmp.(*EmbeddedCase2)
  2886  	fc.Result = res
  2887  	return ec.marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase2(ctx, field.Selections, res)
  2888  }
  2889  
  2890  func (ec *executionContext) fieldContext_Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2891  	fc = &graphql.FieldContext{
  2892  		Object:     "Query",
  2893  		Field:      field,
  2894  		IsMethod:   true,
  2895  		IsResolver: true,
  2896  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2897  			switch field.Name {
  2898  			case "unexportedEmbeddedPointerExportedMethod":
  2899  				return ec.fieldContext_EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field)
  2900  			}
  2901  			return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase2", field.Name)
  2902  		},
  2903  	}
  2904  	return fc, nil
  2905  }
  2906  
  2907  func (ec *executionContext) _Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2908  	fc, err := ec.fieldContext_Query_embeddedCase3(ctx, field)
  2909  	if err != nil {
  2910  		return graphql.Null
  2911  	}
  2912  	ctx = graphql.WithFieldContext(ctx, fc)
  2913  	defer func() {
  2914  		if r := recover(); r != nil {
  2915  			ec.Error(ctx, ec.Recover(ctx, r))
  2916  			ret = graphql.Null
  2917  		}
  2918  	}()
  2919  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2920  		ctx = rctx // use context from middleware stack in children
  2921  		return ec.resolvers.Query().EmbeddedCase3(rctx)
  2922  	})
  2923  
  2924  	if resTmp == nil {
  2925  		return graphql.Null
  2926  	}
  2927  	res := resTmp.(*EmbeddedCase3)
  2928  	fc.Result = res
  2929  	return ec.marshalOEmbeddedCase32ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase3(ctx, field.Selections, res)
  2930  }
  2931  
  2932  func (ec *executionContext) fieldContext_Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2933  	fc = &graphql.FieldContext{
  2934  		Object:     "Query",
  2935  		Field:      field,
  2936  		IsMethod:   true,
  2937  		IsResolver: true,
  2938  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2939  			switch field.Name {
  2940  			case "unexportedEmbeddedInterfaceExportedMethod":
  2941  				return ec.fieldContext_EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx, field)
  2942  			}
  2943  			return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase3", field.Name)
  2944  		},
  2945  	}
  2946  	return fc, nil
  2947  }
  2948  
  2949  func (ec *executionContext) _Query_enumInInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2950  	fc, err := ec.fieldContext_Query_enumInInput(ctx, field)
  2951  	if err != nil {
  2952  		return graphql.Null
  2953  	}
  2954  	ctx = graphql.WithFieldContext(ctx, fc)
  2955  	defer func() {
  2956  		if r := recover(); r != nil {
  2957  			ec.Error(ctx, ec.Recover(ctx, r))
  2958  			ret = graphql.Null
  2959  		}
  2960  	}()
  2961  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2962  		ctx = rctx // use context from middleware stack in children
  2963  		return ec.resolvers.Query().EnumInInput(rctx, fc.Args["input"].(*InputWithEnumValue))
  2964  	})
  2965  
  2966  	if resTmp == nil {
  2967  		if !graphql.HasFieldError(ctx, fc) {
  2968  			ec.Errorf(ctx, "must not be null")
  2969  		}
  2970  		return graphql.Null
  2971  	}
  2972  	res := resTmp.(EnumTest)
  2973  	fc.Result = res
  2974  	return ec.marshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEnumTest(ctx, field.Selections, res)
  2975  }
  2976  
  2977  func (ec *executionContext) fieldContext_Query_enumInInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2978  	fc = &graphql.FieldContext{
  2979  		Object:     "Query",
  2980  		Field:      field,
  2981  		IsMethod:   true,
  2982  		IsResolver: true,
  2983  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2984  			return nil, errors.New("field of type EnumTest does not have child fields")
  2985  		},
  2986  	}
  2987  	defer func() {
  2988  		if r := recover(); r != nil {
  2989  			err = ec.Recover(ctx, r)
  2990  			ec.Error(ctx, err)
  2991  		}
  2992  	}()
  2993  	ctx = graphql.WithFieldContext(ctx, fc)
  2994  	if fc.Args, err = ec.field_Query_enumInInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2995  		ec.Error(ctx, err)
  2996  		return
  2997  	}
  2998  	return fc, nil
  2999  }
  3000  
  3001  func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3002  	fc, err := ec.fieldContext_Query_shapes(ctx, field)
  3003  	if err != nil {
  3004  		return graphql.Null
  3005  	}
  3006  	ctx = graphql.WithFieldContext(ctx, fc)
  3007  	defer func() {
  3008  		if r := recover(); r != nil {
  3009  			ec.Error(ctx, ec.Recover(ctx, r))
  3010  			ret = graphql.Null
  3011  		}
  3012  	}()
  3013  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3014  		ctx = rctx // use context from middleware stack in children
  3015  		return ec.resolvers.Query().Shapes(rctx)
  3016  	})
  3017  
  3018  	if resTmp == nil {
  3019  		return graphql.Null
  3020  	}
  3021  	res := resTmp.([]Shape)
  3022  	fc.Result = res
  3023  	return ec.marshalOShape2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res)
  3024  }
  3025  
  3026  func (ec *executionContext) fieldContext_Query_shapes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3027  	fc = &graphql.FieldContext{
  3028  		Object:     "Query",
  3029  		Field:      field,
  3030  		IsMethod:   true,
  3031  		IsResolver: true,
  3032  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3033  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3034  		},
  3035  	}
  3036  	return fc, nil
  3037  }
  3038  
  3039  func (ec *executionContext) _Query_noShape(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3040  	fc, err := ec.fieldContext_Query_noShape(ctx, field)
  3041  	if err != nil {
  3042  		return graphql.Null
  3043  	}
  3044  	ctx = graphql.WithFieldContext(ctx, fc)
  3045  	defer func() {
  3046  		if r := recover(); r != nil {
  3047  			ec.Error(ctx, ec.Recover(ctx, r))
  3048  			ret = graphql.Null
  3049  		}
  3050  	}()
  3051  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3052  		directive0 := func(rctx context.Context) (interface{}, error) {
  3053  			ctx = rctx // use context from middleware stack in children
  3054  			return ec.resolvers.Query().NoShape(rctx)
  3055  		}
  3056  		directive1 := func(ctx context.Context) (interface{}, error) {
  3057  			if ec.directives.MakeNil == nil {
  3058  				return nil, errors.New("directive makeNil is not implemented")
  3059  			}
  3060  			return ec.directives.MakeNil(ctx, nil, directive0)
  3061  		}
  3062  
  3063  		tmp, err := directive1(rctx)
  3064  		if err != nil {
  3065  			return nil, graphql.ErrorOnPath(ctx, err)
  3066  		}
  3067  		if tmp == nil {
  3068  			return nil, nil
  3069  		}
  3070  		if data, ok := tmp.(Shape); ok {
  3071  			return data, nil
  3072  		}
  3073  		return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/spread-ai/gqlgen/codegen/testserver/followschema.Shape`, tmp)
  3074  	})
  3075  
  3076  	if resTmp == nil {
  3077  		return graphql.Null
  3078  	}
  3079  	res := resTmp.(Shape)
  3080  	fc.Result = res
  3081  	return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res)
  3082  }
  3083  
  3084  func (ec *executionContext) fieldContext_Query_noShape(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3085  	fc = &graphql.FieldContext{
  3086  		Object:     "Query",
  3087  		Field:      field,
  3088  		IsMethod:   true,
  3089  		IsResolver: true,
  3090  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3091  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3092  		},
  3093  	}
  3094  	return fc, nil
  3095  }
  3096  
  3097  func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3098  	fc, err := ec.fieldContext_Query_node(ctx, field)
  3099  	if err != nil {
  3100  		return graphql.Null
  3101  	}
  3102  	ctx = graphql.WithFieldContext(ctx, fc)
  3103  	defer func() {
  3104  		if r := recover(); r != nil {
  3105  			ec.Error(ctx, ec.Recover(ctx, r))
  3106  			ret = graphql.Null
  3107  		}
  3108  	}()
  3109  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3110  		ctx = rctx // use context from middleware stack in children
  3111  		return ec.resolvers.Query().Node(rctx)
  3112  	})
  3113  
  3114  	if resTmp == nil {
  3115  		if !graphql.HasFieldError(ctx, fc) {
  3116  			ec.Errorf(ctx, "must not be null")
  3117  		}
  3118  		return graphql.Null
  3119  	}
  3120  	res := resTmp.(Node)
  3121  	fc.Result = res
  3122  	return ec.marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐNode(ctx, field.Selections, res)
  3123  }
  3124  
  3125  func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3126  	fc = &graphql.FieldContext{
  3127  		Object:     "Query",
  3128  		Field:      field,
  3129  		IsMethod:   true,
  3130  		IsResolver: true,
  3131  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3132  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3133  		},
  3134  	}
  3135  	return fc, nil
  3136  }
  3137  
  3138  func (ec *executionContext) _Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3139  	fc, err := ec.fieldContext_Query_noShapeTypedNil(ctx, field)
  3140  	if err != nil {
  3141  		return graphql.Null
  3142  	}
  3143  	ctx = graphql.WithFieldContext(ctx, fc)
  3144  	defer func() {
  3145  		if r := recover(); r != nil {
  3146  			ec.Error(ctx, ec.Recover(ctx, r))
  3147  			ret = graphql.Null
  3148  		}
  3149  	}()
  3150  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3151  		directive0 := func(rctx context.Context) (interface{}, error) {
  3152  			ctx = rctx // use context from middleware stack in children
  3153  			return ec.resolvers.Query().NoShapeTypedNil(rctx)
  3154  		}
  3155  		directive1 := func(ctx context.Context) (interface{}, error) {
  3156  			if ec.directives.MakeTypedNil == nil {
  3157  				return nil, errors.New("directive makeTypedNil is not implemented")
  3158  			}
  3159  			return ec.directives.MakeTypedNil(ctx, nil, directive0)
  3160  		}
  3161  
  3162  		tmp, err := directive1(rctx)
  3163  		if err != nil {
  3164  			return nil, graphql.ErrorOnPath(ctx, err)
  3165  		}
  3166  		if tmp == nil {
  3167  			return nil, nil
  3168  		}
  3169  		if data, ok := tmp.(Shape); ok {
  3170  			return data, nil
  3171  		}
  3172  		return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/spread-ai/gqlgen/codegen/testserver/followschema.Shape`, tmp)
  3173  	})
  3174  
  3175  	if resTmp == nil {
  3176  		return graphql.Null
  3177  	}
  3178  	res := resTmp.(Shape)
  3179  	fc.Result = res
  3180  	return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res)
  3181  }
  3182  
  3183  func (ec *executionContext) fieldContext_Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3184  	fc = &graphql.FieldContext{
  3185  		Object:     "Query",
  3186  		Field:      field,
  3187  		IsMethod:   true,
  3188  		IsResolver: true,
  3189  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3190  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3191  		},
  3192  	}
  3193  	return fc, nil
  3194  }
  3195  
  3196  func (ec *executionContext) _Query_animal(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3197  	fc, err := ec.fieldContext_Query_animal(ctx, field)
  3198  	if err != nil {
  3199  		return graphql.Null
  3200  	}
  3201  	ctx = graphql.WithFieldContext(ctx, fc)
  3202  	defer func() {
  3203  		if r := recover(); r != nil {
  3204  			ec.Error(ctx, ec.Recover(ctx, r))
  3205  			ret = graphql.Null
  3206  		}
  3207  	}()
  3208  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3209  		directive0 := func(rctx context.Context) (interface{}, error) {
  3210  			ctx = rctx // use context from middleware stack in children
  3211  			return ec.resolvers.Query().Animal(rctx)
  3212  		}
  3213  		directive1 := func(ctx context.Context) (interface{}, error) {
  3214  			if ec.directives.MakeTypedNil == nil {
  3215  				return nil, errors.New("directive makeTypedNil is not implemented")
  3216  			}
  3217  			return ec.directives.MakeTypedNil(ctx, nil, directive0)
  3218  		}
  3219  
  3220  		tmp, err := directive1(rctx)
  3221  		if err != nil {
  3222  			return nil, graphql.ErrorOnPath(ctx, err)
  3223  		}
  3224  		if tmp == nil {
  3225  			return nil, nil
  3226  		}
  3227  		if data, ok := tmp.(Animal); ok {
  3228  			return data, nil
  3229  		}
  3230  		return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/spread-ai/gqlgen/codegen/testserver/followschema.Animal`, tmp)
  3231  	})
  3232  
  3233  	if resTmp == nil {
  3234  		return graphql.Null
  3235  	}
  3236  	res := resTmp.(Animal)
  3237  	fc.Result = res
  3238  	return ec.marshalOAnimal2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAnimal(ctx, field.Selections, res)
  3239  }
  3240  
  3241  func (ec *executionContext) fieldContext_Query_animal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3242  	fc = &graphql.FieldContext{
  3243  		Object:     "Query",
  3244  		Field:      field,
  3245  		IsMethod:   true,
  3246  		IsResolver: true,
  3247  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3248  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3249  		},
  3250  	}
  3251  	return fc, nil
  3252  }
  3253  
  3254  func (ec *executionContext) _Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3255  	fc, err := ec.fieldContext_Query_notAnInterface(ctx, field)
  3256  	if err != nil {
  3257  		return graphql.Null
  3258  	}
  3259  	ctx = graphql.WithFieldContext(ctx, fc)
  3260  	defer func() {
  3261  		if r := recover(); r != nil {
  3262  			ec.Error(ctx, ec.Recover(ctx, r))
  3263  			ret = graphql.Null
  3264  		}
  3265  	}()
  3266  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3267  		ctx = rctx // use context from middleware stack in children
  3268  		return ec.resolvers.Query().NotAnInterface(rctx)
  3269  	})
  3270  
  3271  	if resTmp == nil {
  3272  		return graphql.Null
  3273  	}
  3274  	res := resTmp.(BackedByInterface)
  3275  	fc.Result = res
  3276  	return ec.marshalOBackedByInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐBackedByInterface(ctx, field.Selections, res)
  3277  }
  3278  
  3279  func (ec *executionContext) fieldContext_Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3280  	fc = &graphql.FieldContext{
  3281  		Object:     "Query",
  3282  		Field:      field,
  3283  		IsMethod:   true,
  3284  		IsResolver: true,
  3285  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3286  			switch field.Name {
  3287  			case "id":
  3288  				return ec.fieldContext_BackedByInterface_id(ctx, field)
  3289  			case "thisShouldBind":
  3290  				return ec.fieldContext_BackedByInterface_thisShouldBind(ctx, field)
  3291  			case "thisShouldBindWithError":
  3292  				return ec.fieldContext_BackedByInterface_thisShouldBindWithError(ctx, field)
  3293  			}
  3294  			return nil, fmt.Errorf("no field named %q was found under type BackedByInterface", field.Name)
  3295  		},
  3296  	}
  3297  	return fc, nil
  3298  }
  3299  
  3300  func (ec *executionContext) _Query_dog(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3301  	fc, err := ec.fieldContext_Query_dog(ctx, field)
  3302  	if err != nil {
  3303  		return graphql.Null
  3304  	}
  3305  	ctx = graphql.WithFieldContext(ctx, fc)
  3306  	defer func() {
  3307  		if r := recover(); r != nil {
  3308  			ec.Error(ctx, ec.Recover(ctx, r))
  3309  			ret = graphql.Null
  3310  		}
  3311  	}()
  3312  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3313  		ctx = rctx // use context from middleware stack in children
  3314  		return ec.resolvers.Query().Dog(rctx)
  3315  	})
  3316  
  3317  	if resTmp == nil {
  3318  		return graphql.Null
  3319  	}
  3320  	res := resTmp.(*Dog)
  3321  	fc.Result = res
  3322  	return ec.marshalODog2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐDog(ctx, field.Selections, res)
  3323  }
  3324  
  3325  func (ec *executionContext) fieldContext_Query_dog(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3326  	fc = &graphql.FieldContext{
  3327  		Object:     "Query",
  3328  		Field:      field,
  3329  		IsMethod:   true,
  3330  		IsResolver: true,
  3331  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3332  			switch field.Name {
  3333  			case "species":
  3334  				return ec.fieldContext_Dog_species(ctx, field)
  3335  			case "size":
  3336  				return ec.fieldContext_Dog_size(ctx, field)
  3337  			case "dogBreed":
  3338  				return ec.fieldContext_Dog_dogBreed(ctx, field)
  3339  			}
  3340  			return nil, fmt.Errorf("no field named %q was found under type Dog", field.Name)
  3341  		},
  3342  	}
  3343  	return fc, nil
  3344  }
  3345  
  3346  func (ec *executionContext) _Query_issue896a(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3347  	fc, err := ec.fieldContext_Query_issue896a(ctx, field)
  3348  	if err != nil {
  3349  		return graphql.Null
  3350  	}
  3351  	ctx = graphql.WithFieldContext(ctx, fc)
  3352  	defer func() {
  3353  		if r := recover(); r != nil {
  3354  			ec.Error(ctx, ec.Recover(ctx, r))
  3355  			ret = graphql.Null
  3356  		}
  3357  	}()
  3358  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3359  		ctx = rctx // use context from middleware stack in children
  3360  		return ec.resolvers.Query().Issue896a(rctx)
  3361  	})
  3362  
  3363  	if resTmp == nil {
  3364  		return graphql.Null
  3365  	}
  3366  	res := resTmp.([]*CheckIssue896)
  3367  	fc.Result = res
  3368  	return ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCheckIssue896ᚄ(ctx, field.Selections, res)
  3369  }
  3370  
  3371  func (ec *executionContext) fieldContext_Query_issue896a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3372  	fc = &graphql.FieldContext{
  3373  		Object:     "Query",
  3374  		Field:      field,
  3375  		IsMethod:   true,
  3376  		IsResolver: true,
  3377  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3378  			switch field.Name {
  3379  			case "id":
  3380  				return ec.fieldContext_CheckIssue896_id(ctx, field)
  3381  			}
  3382  			return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name)
  3383  		},
  3384  	}
  3385  	return fc, nil
  3386  }
  3387  
  3388  func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3389  	fc, err := ec.fieldContext_Query_mapStringInterface(ctx, field)
  3390  	if err != nil {
  3391  		return graphql.Null
  3392  	}
  3393  	ctx = graphql.WithFieldContext(ctx, fc)
  3394  	defer func() {
  3395  		if r := recover(); r != nil {
  3396  			ec.Error(ctx, ec.Recover(ctx, r))
  3397  			ret = graphql.Null
  3398  		}
  3399  	}()
  3400  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3401  		ctx = rctx // use context from middleware stack in children
  3402  		return ec.resolvers.Query().MapStringInterface(rctx, fc.Args["in"].(map[string]interface{}))
  3403  	})
  3404  
  3405  	if resTmp == nil {
  3406  		return graphql.Null
  3407  	}
  3408  	res := resTmp.(map[string]interface{})
  3409  	fc.Result = res
  3410  	return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res)
  3411  }
  3412  
  3413  func (ec *executionContext) fieldContext_Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3414  	fc = &graphql.FieldContext{
  3415  		Object:     "Query",
  3416  		Field:      field,
  3417  		IsMethod:   true,
  3418  		IsResolver: true,
  3419  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3420  			switch field.Name {
  3421  			case "a":
  3422  				return ec.fieldContext_MapStringInterfaceType_a(ctx, field)
  3423  			case "b":
  3424  				return ec.fieldContext_MapStringInterfaceType_b(ctx, field)
  3425  			}
  3426  			return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name)
  3427  		},
  3428  	}
  3429  	defer func() {
  3430  		if r := recover(); r != nil {
  3431  			err = ec.Recover(ctx, r)
  3432  			ec.Error(ctx, err)
  3433  		}
  3434  	}()
  3435  	ctx = graphql.WithFieldContext(ctx, fc)
  3436  	if fc.Args, err = ec.field_Query_mapStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  3437  		ec.Error(ctx, err)
  3438  		return
  3439  	}
  3440  	return fc, nil
  3441  }
  3442  
  3443  func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3444  	fc, err := ec.fieldContext_Query_mapNestedStringInterface(ctx, field)
  3445  	if err != nil {
  3446  		return graphql.Null
  3447  	}
  3448  	ctx = graphql.WithFieldContext(ctx, fc)
  3449  	defer func() {
  3450  		if r := recover(); r != nil {
  3451  			ec.Error(ctx, ec.Recover(ctx, r))
  3452  			ret = graphql.Null
  3453  		}
  3454  	}()
  3455  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3456  		ctx = rctx // use context from middleware stack in children
  3457  		return ec.resolvers.Query().MapNestedStringInterface(rctx, fc.Args["in"].(*NestedMapInput))
  3458  	})
  3459  
  3460  	if resTmp == nil {
  3461  		return graphql.Null
  3462  	}
  3463  	res := resTmp.(map[string]interface{})
  3464  	fc.Result = res
  3465  	return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res)
  3466  }
  3467  
  3468  func (ec *executionContext) fieldContext_Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3469  	fc = &graphql.FieldContext{
  3470  		Object:     "Query",
  3471  		Field:      field,
  3472  		IsMethod:   true,
  3473  		IsResolver: true,
  3474  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3475  			switch field.Name {
  3476  			case "a":
  3477  				return ec.fieldContext_MapStringInterfaceType_a(ctx, field)
  3478  			case "b":
  3479  				return ec.fieldContext_MapStringInterfaceType_b(ctx, field)
  3480  			}
  3481  			return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name)
  3482  		},
  3483  	}
  3484  	defer func() {
  3485  		if r := recover(); r != nil {
  3486  			err = ec.Recover(ctx, r)
  3487  			ec.Error(ctx, err)
  3488  		}
  3489  	}()
  3490  	ctx = graphql.WithFieldContext(ctx, fc)
  3491  	if fc.Args, err = ec.field_Query_mapNestedStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  3492  		ec.Error(ctx, err)
  3493  		return
  3494  	}
  3495  	return fc, nil
  3496  }
  3497  
  3498  func (ec *executionContext) _Query_errorBubble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3499  	fc, err := ec.fieldContext_Query_errorBubble(ctx, field)
  3500  	if err != nil {
  3501  		return graphql.Null
  3502  	}
  3503  	ctx = graphql.WithFieldContext(ctx, fc)
  3504  	defer func() {
  3505  		if r := recover(); r != nil {
  3506  			ec.Error(ctx, ec.Recover(ctx, r))
  3507  			ret = graphql.Null
  3508  		}
  3509  	}()
  3510  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3511  		ctx = rctx // use context from middleware stack in children
  3512  		return ec.resolvers.Query().ErrorBubble(rctx)
  3513  	})
  3514  
  3515  	if resTmp == nil {
  3516  		return graphql.Null
  3517  	}
  3518  	res := resTmp.(*Error)
  3519  	fc.Result = res
  3520  	return ec.marshalOError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res)
  3521  }
  3522  
  3523  func (ec *executionContext) fieldContext_Query_errorBubble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3524  	fc = &graphql.FieldContext{
  3525  		Object:     "Query",
  3526  		Field:      field,
  3527  		IsMethod:   true,
  3528  		IsResolver: true,
  3529  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3530  			switch field.Name {
  3531  			case "id":
  3532  				return ec.fieldContext_Error_id(ctx, field)
  3533  			case "errorOnNonRequiredField":
  3534  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  3535  			case "errorOnRequiredField":
  3536  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  3537  			case "nilOnRequiredField":
  3538  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  3539  			}
  3540  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  3541  		},
  3542  	}
  3543  	return fc, nil
  3544  }
  3545  
  3546  func (ec *executionContext) _Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3547  	fc, err := ec.fieldContext_Query_errorBubbleList(ctx, field)
  3548  	if err != nil {
  3549  		return graphql.Null
  3550  	}
  3551  	ctx = graphql.WithFieldContext(ctx, fc)
  3552  	defer func() {
  3553  		if r := recover(); r != nil {
  3554  			ec.Error(ctx, ec.Recover(ctx, r))
  3555  			ret = graphql.Null
  3556  		}
  3557  	}()
  3558  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3559  		ctx = rctx // use context from middleware stack in children
  3560  		return ec.resolvers.Query().ErrorBubbleList(rctx)
  3561  	})
  3562  
  3563  	if resTmp == nil {
  3564  		return graphql.Null
  3565  	}
  3566  	res := resTmp.([]*Error)
  3567  	fc.Result = res
  3568  	return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐErrorᚄ(ctx, field.Selections, res)
  3569  }
  3570  
  3571  func (ec *executionContext) fieldContext_Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3572  	fc = &graphql.FieldContext{
  3573  		Object:     "Query",
  3574  		Field:      field,
  3575  		IsMethod:   true,
  3576  		IsResolver: true,
  3577  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3578  			switch field.Name {
  3579  			case "id":
  3580  				return ec.fieldContext_Error_id(ctx, field)
  3581  			case "errorOnNonRequiredField":
  3582  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  3583  			case "errorOnRequiredField":
  3584  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  3585  			case "nilOnRequiredField":
  3586  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  3587  			}
  3588  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  3589  		},
  3590  	}
  3591  	return fc, nil
  3592  }
  3593  
  3594  func (ec *executionContext) _Query_errorList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3595  	fc, err := ec.fieldContext_Query_errorList(ctx, field)
  3596  	if err != nil {
  3597  		return graphql.Null
  3598  	}
  3599  	ctx = graphql.WithFieldContext(ctx, fc)
  3600  	defer func() {
  3601  		if r := recover(); r != nil {
  3602  			ec.Error(ctx, ec.Recover(ctx, r))
  3603  			ret = graphql.Null
  3604  		}
  3605  	}()
  3606  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3607  		ctx = rctx // use context from middleware stack in children
  3608  		return ec.resolvers.Query().ErrorList(rctx)
  3609  	})
  3610  
  3611  	if resTmp == nil {
  3612  		return graphql.Null
  3613  	}
  3614  	res := resTmp.([]*Error)
  3615  	fc.Result = res
  3616  	return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res)
  3617  }
  3618  
  3619  func (ec *executionContext) fieldContext_Query_errorList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3620  	fc = &graphql.FieldContext{
  3621  		Object:     "Query",
  3622  		Field:      field,
  3623  		IsMethod:   true,
  3624  		IsResolver: true,
  3625  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3626  			switch field.Name {
  3627  			case "id":
  3628  				return ec.fieldContext_Error_id(ctx, field)
  3629  			case "errorOnNonRequiredField":
  3630  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  3631  			case "errorOnRequiredField":
  3632  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  3633  			case "nilOnRequiredField":
  3634  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  3635  			}
  3636  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  3637  		},
  3638  	}
  3639  	return fc, nil
  3640  }
  3641  
  3642  func (ec *executionContext) _Query_errors(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3643  	fc, err := ec.fieldContext_Query_errors(ctx, field)
  3644  	if err != nil {
  3645  		return graphql.Null
  3646  	}
  3647  	ctx = graphql.WithFieldContext(ctx, fc)
  3648  	defer func() {
  3649  		if r := recover(); r != nil {
  3650  			ec.Error(ctx, ec.Recover(ctx, r))
  3651  			ret = graphql.Null
  3652  		}
  3653  	}()
  3654  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3655  		ctx = rctx // use context from middleware stack in children
  3656  		return ec.resolvers.Query().Errors(rctx)
  3657  	})
  3658  
  3659  	if resTmp == nil {
  3660  		return graphql.Null
  3661  	}
  3662  	res := resTmp.(*Errors)
  3663  	fc.Result = res
  3664  	return ec.marshalOErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐErrors(ctx, field.Selections, res)
  3665  }
  3666  
  3667  func (ec *executionContext) fieldContext_Query_errors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3668  	fc = &graphql.FieldContext{
  3669  		Object:     "Query",
  3670  		Field:      field,
  3671  		IsMethod:   true,
  3672  		IsResolver: true,
  3673  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3674  			switch field.Name {
  3675  			case "a":
  3676  				return ec.fieldContext_Errors_a(ctx, field)
  3677  			case "b":
  3678  				return ec.fieldContext_Errors_b(ctx, field)
  3679  			case "c":
  3680  				return ec.fieldContext_Errors_c(ctx, field)
  3681  			case "d":
  3682  				return ec.fieldContext_Errors_d(ctx, field)
  3683  			case "e":
  3684  				return ec.fieldContext_Errors_e(ctx, field)
  3685  			}
  3686  			return nil, fmt.Errorf("no field named %q was found under type Errors", field.Name)
  3687  		},
  3688  	}
  3689  	return fc, nil
  3690  }
  3691  
  3692  func (ec *executionContext) _Query_valid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3693  	fc, err := ec.fieldContext_Query_valid(ctx, field)
  3694  	if err != nil {
  3695  		return graphql.Null
  3696  	}
  3697  	ctx = graphql.WithFieldContext(ctx, fc)
  3698  	defer func() {
  3699  		if r := recover(); r != nil {
  3700  			ec.Error(ctx, ec.Recover(ctx, r))
  3701  			ret = graphql.Null
  3702  		}
  3703  	}()
  3704  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3705  		ctx = rctx // use context from middleware stack in children
  3706  		return ec.resolvers.Query().Valid(rctx)
  3707  	})
  3708  
  3709  	if resTmp == nil {
  3710  		if !graphql.HasFieldError(ctx, fc) {
  3711  			ec.Errorf(ctx, "must not be null")
  3712  		}
  3713  		return graphql.Null
  3714  	}
  3715  	res := resTmp.(string)
  3716  	fc.Result = res
  3717  	return ec.marshalNString2string(ctx, field.Selections, res)
  3718  }
  3719  
  3720  func (ec *executionContext) fieldContext_Query_valid(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3721  	fc = &graphql.FieldContext{
  3722  		Object:     "Query",
  3723  		Field:      field,
  3724  		IsMethod:   true,
  3725  		IsResolver: true,
  3726  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3727  			return nil, errors.New("field of type String does not have child fields")
  3728  		},
  3729  	}
  3730  	return fc, nil
  3731  }
  3732  
  3733  func (ec *executionContext) _Query_panics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3734  	fc, err := ec.fieldContext_Query_panics(ctx, field)
  3735  	if err != nil {
  3736  		return graphql.Null
  3737  	}
  3738  	ctx = graphql.WithFieldContext(ctx, fc)
  3739  	defer func() {
  3740  		if r := recover(); r != nil {
  3741  			ec.Error(ctx, ec.Recover(ctx, r))
  3742  			ret = graphql.Null
  3743  		}
  3744  	}()
  3745  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3746  		ctx = rctx // use context from middleware stack in children
  3747  		return ec.resolvers.Query().Panics(rctx)
  3748  	})
  3749  
  3750  	if resTmp == nil {
  3751  		return graphql.Null
  3752  	}
  3753  	res := resTmp.(*Panics)
  3754  	fc.Result = res
  3755  	return ec.marshalOPanics2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPanics(ctx, field.Selections, res)
  3756  }
  3757  
  3758  func (ec *executionContext) fieldContext_Query_panics(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3759  	fc = &graphql.FieldContext{
  3760  		Object:     "Query",
  3761  		Field:      field,
  3762  		IsMethod:   true,
  3763  		IsResolver: true,
  3764  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3765  			switch field.Name {
  3766  			case "fieldScalarMarshal":
  3767  				return ec.fieldContext_Panics_fieldScalarMarshal(ctx, field)
  3768  			case "fieldFuncMarshal":
  3769  				return ec.fieldContext_Panics_fieldFuncMarshal(ctx, field)
  3770  			case "argUnmarshal":
  3771  				return ec.fieldContext_Panics_argUnmarshal(ctx, field)
  3772  			}
  3773  			return nil, fmt.Errorf("no field named %q was found under type Panics", field.Name)
  3774  		},
  3775  	}
  3776  	return fc, nil
  3777  }
  3778  
  3779  func (ec *executionContext) _Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3780  	fc, err := ec.fieldContext_Query_primitiveObject(ctx, field)
  3781  	if err != nil {
  3782  		return graphql.Null
  3783  	}
  3784  	ctx = graphql.WithFieldContext(ctx, fc)
  3785  	defer func() {
  3786  		if r := recover(); r != nil {
  3787  			ec.Error(ctx, ec.Recover(ctx, r))
  3788  			ret = graphql.Null
  3789  		}
  3790  	}()
  3791  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3792  		ctx = rctx // use context from middleware stack in children
  3793  		return ec.resolvers.Query().PrimitiveObject(rctx)
  3794  	})
  3795  
  3796  	if resTmp == nil {
  3797  		if !graphql.HasFieldError(ctx, fc) {
  3798  			ec.Errorf(ctx, "must not be null")
  3799  		}
  3800  		return graphql.Null
  3801  	}
  3802  	res := resTmp.([]Primitive)
  3803  	fc.Result = res
  3804  	return ec.marshalNPrimitive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPrimitiveᚄ(ctx, field.Selections, res)
  3805  }
  3806  
  3807  func (ec *executionContext) fieldContext_Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3808  	fc = &graphql.FieldContext{
  3809  		Object:     "Query",
  3810  		Field:      field,
  3811  		IsMethod:   true,
  3812  		IsResolver: true,
  3813  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3814  			switch field.Name {
  3815  			case "value":
  3816  				return ec.fieldContext_Primitive_value(ctx, field)
  3817  			case "squared":
  3818  				return ec.fieldContext_Primitive_squared(ctx, field)
  3819  			}
  3820  			return nil, fmt.Errorf("no field named %q was found under type Primitive", field.Name)
  3821  		},
  3822  	}
  3823  	return fc, nil
  3824  }
  3825  
  3826  func (ec *executionContext) _Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3827  	fc, err := ec.fieldContext_Query_primitiveStringObject(ctx, field)
  3828  	if err != nil {
  3829  		return graphql.Null
  3830  	}
  3831  	ctx = graphql.WithFieldContext(ctx, fc)
  3832  	defer func() {
  3833  		if r := recover(); r != nil {
  3834  			ec.Error(ctx, ec.Recover(ctx, r))
  3835  			ret = graphql.Null
  3836  		}
  3837  	}()
  3838  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3839  		ctx = rctx // use context from middleware stack in children
  3840  		return ec.resolvers.Query().PrimitiveStringObject(rctx)
  3841  	})
  3842  
  3843  	if resTmp == nil {
  3844  		if !graphql.HasFieldError(ctx, fc) {
  3845  			ec.Errorf(ctx, "must not be null")
  3846  		}
  3847  		return graphql.Null
  3848  	}
  3849  	res := resTmp.([]PrimitiveString)
  3850  	fc.Result = res
  3851  	return ec.marshalNPrimitiveString2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPrimitiveStringᚄ(ctx, field.Selections, res)
  3852  }
  3853  
  3854  func (ec *executionContext) fieldContext_Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3855  	fc = &graphql.FieldContext{
  3856  		Object:     "Query",
  3857  		Field:      field,
  3858  		IsMethod:   true,
  3859  		IsResolver: true,
  3860  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3861  			switch field.Name {
  3862  			case "value":
  3863  				return ec.fieldContext_PrimitiveString_value(ctx, field)
  3864  			case "doubled":
  3865  				return ec.fieldContext_PrimitiveString_doubled(ctx, field)
  3866  			case "len":
  3867  				return ec.fieldContext_PrimitiveString_len(ctx, field)
  3868  			}
  3869  			return nil, fmt.Errorf("no field named %q was found under type PrimitiveString", field.Name)
  3870  		},
  3871  	}
  3872  	return fc, nil
  3873  }
  3874  
  3875  func (ec *executionContext) _Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3876  	fc, err := ec.fieldContext_Query_ptrToSliceContainer(ctx, field)
  3877  	if err != nil {
  3878  		return graphql.Null
  3879  	}
  3880  	ctx = graphql.WithFieldContext(ctx, fc)
  3881  	defer func() {
  3882  		if r := recover(); r != nil {
  3883  			ec.Error(ctx, ec.Recover(ctx, r))
  3884  			ret = graphql.Null
  3885  		}
  3886  	}()
  3887  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3888  		ctx = rctx // use context from middleware stack in children
  3889  		return ec.resolvers.Query().PtrToSliceContainer(rctx)
  3890  	})
  3891  
  3892  	if resTmp == nil {
  3893  		if !graphql.HasFieldError(ctx, fc) {
  3894  			ec.Errorf(ctx, "must not be null")
  3895  		}
  3896  		return graphql.Null
  3897  	}
  3898  	res := resTmp.(*PtrToSliceContainer)
  3899  	fc.Result = res
  3900  	return ec.marshalNPtrToSliceContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPtrToSliceContainer(ctx, field.Selections, res)
  3901  }
  3902  
  3903  func (ec *executionContext) fieldContext_Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3904  	fc = &graphql.FieldContext{
  3905  		Object:     "Query",
  3906  		Field:      field,
  3907  		IsMethod:   true,
  3908  		IsResolver: true,
  3909  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3910  			switch field.Name {
  3911  			case "ptrToSlice":
  3912  				return ec.fieldContext_PtrToSliceContainer_ptrToSlice(ctx, field)
  3913  			}
  3914  			return nil, fmt.Errorf("no field named %q was found under type PtrToSliceContainer", field.Name)
  3915  		},
  3916  	}
  3917  	return fc, nil
  3918  }
  3919  
  3920  func (ec *executionContext) _Query_infinity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3921  	fc, err := ec.fieldContext_Query_infinity(ctx, field)
  3922  	if err != nil {
  3923  		return graphql.Null
  3924  	}
  3925  	ctx = graphql.WithFieldContext(ctx, fc)
  3926  	defer func() {
  3927  		if r := recover(); r != nil {
  3928  			ec.Error(ctx, ec.Recover(ctx, r))
  3929  			ret = graphql.Null
  3930  		}
  3931  	}()
  3932  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3933  		ctx = rctx // use context from middleware stack in children
  3934  		return ec.resolvers.Query().Infinity(rctx)
  3935  	})
  3936  
  3937  	if resTmp == nil {
  3938  		if !graphql.HasFieldError(ctx, fc) {
  3939  			ec.Errorf(ctx, "must not be null")
  3940  		}
  3941  		return graphql.Null
  3942  	}
  3943  	res := resTmp.(float64)
  3944  	fc.Result = res
  3945  	return ec.marshalNFloat2float64(ctx, field.Selections, res)
  3946  }
  3947  
  3948  func (ec *executionContext) fieldContext_Query_infinity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3949  	fc = &graphql.FieldContext{
  3950  		Object:     "Query",
  3951  		Field:      field,
  3952  		IsMethod:   true,
  3953  		IsResolver: true,
  3954  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3955  			return nil, errors.New("field of type Float does not have child fields")
  3956  		},
  3957  	}
  3958  	return fc, nil
  3959  }
  3960  
  3961  func (ec *executionContext) _Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3962  	fc, err := ec.fieldContext_Query_stringFromContextInterface(ctx, field)
  3963  	if err != nil {
  3964  		return graphql.Null
  3965  	}
  3966  	ctx = graphql.WithFieldContext(ctx, fc)
  3967  	defer func() {
  3968  		if r := recover(); r != nil {
  3969  			ec.Error(ctx, ec.Recover(ctx, r))
  3970  			ret = graphql.Null
  3971  		}
  3972  	}()
  3973  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3974  		ctx = rctx // use context from middleware stack in children
  3975  		return ec.resolvers.Query().StringFromContextInterface(rctx)
  3976  	})
  3977  
  3978  	if resTmp == nil {
  3979  		if !graphql.HasFieldError(ctx, fc) {
  3980  			ec.Errorf(ctx, "must not be null")
  3981  		}
  3982  		return graphql.Null
  3983  	}
  3984  	res := resTmp.(*StringFromContextInterface)
  3985  	fc.Result = res
  3986  	return ec.marshalNStringFromContextInterface2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐStringFromContextInterface(ctx, field.Selections, res)
  3987  }
  3988  
  3989  func (ec *executionContext) fieldContext_Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3990  	fc = &graphql.FieldContext{
  3991  		Object:     "Query",
  3992  		Field:      field,
  3993  		IsMethod:   true,
  3994  		IsResolver: true,
  3995  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3996  			return nil, errors.New("field of type StringFromContextInterface does not have child fields")
  3997  		},
  3998  	}
  3999  	return fc, nil
  4000  }
  4001  
  4002  func (ec *executionContext) _Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4003  	fc, err := ec.fieldContext_Query_stringFromContextFunction(ctx, field)
  4004  	if err != nil {
  4005  		return graphql.Null
  4006  	}
  4007  	ctx = graphql.WithFieldContext(ctx, fc)
  4008  	defer func() {
  4009  		if r := recover(); r != nil {
  4010  			ec.Error(ctx, ec.Recover(ctx, r))
  4011  			ret = graphql.Null
  4012  		}
  4013  	}()
  4014  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4015  		ctx = rctx // use context from middleware stack in children
  4016  		return ec.resolvers.Query().StringFromContextFunction(rctx)
  4017  	})
  4018  
  4019  	if resTmp == nil {
  4020  		if !graphql.HasFieldError(ctx, fc) {
  4021  			ec.Errorf(ctx, "must not be null")
  4022  		}
  4023  		return graphql.Null
  4024  	}
  4025  	res := resTmp.(string)
  4026  	fc.Result = res
  4027  	return ec.marshalNStringFromContextFunction2string(ctx, field.Selections, res)
  4028  }
  4029  
  4030  func (ec *executionContext) fieldContext_Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4031  	fc = &graphql.FieldContext{
  4032  		Object:     "Query",
  4033  		Field:      field,
  4034  		IsMethod:   true,
  4035  		IsResolver: true,
  4036  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4037  			return nil, errors.New("field of type StringFromContextFunction does not have child fields")
  4038  		},
  4039  	}
  4040  	return fc, nil
  4041  }
  4042  
  4043  func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4044  	fc, err := ec.fieldContext_Query_defaultScalar(ctx, field)
  4045  	if err != nil {
  4046  		return graphql.Null
  4047  	}
  4048  	ctx = graphql.WithFieldContext(ctx, fc)
  4049  	defer func() {
  4050  		if r := recover(); r != nil {
  4051  			ec.Error(ctx, ec.Recover(ctx, r))
  4052  			ret = graphql.Null
  4053  		}
  4054  	}()
  4055  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4056  		ctx = rctx // use context from middleware stack in children
  4057  		return ec.resolvers.Query().DefaultScalar(rctx, fc.Args["arg"].(string))
  4058  	})
  4059  
  4060  	if resTmp == nil {
  4061  		if !graphql.HasFieldError(ctx, fc) {
  4062  			ec.Errorf(ctx, "must not be null")
  4063  		}
  4064  		return graphql.Null
  4065  	}
  4066  	res := resTmp.(string)
  4067  	fc.Result = res
  4068  	return ec.marshalNDefaultScalarImplementation2string(ctx, field.Selections, res)
  4069  }
  4070  
  4071  func (ec *executionContext) fieldContext_Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4072  	fc = &graphql.FieldContext{
  4073  		Object:     "Query",
  4074  		Field:      field,
  4075  		IsMethod:   true,
  4076  		IsResolver: true,
  4077  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4078  			return nil, errors.New("field of type DefaultScalarImplementation does not have child fields")
  4079  		},
  4080  	}
  4081  	defer func() {
  4082  		if r := recover(); r != nil {
  4083  			err = ec.Recover(ctx, r)
  4084  			ec.Error(ctx, err)
  4085  		}
  4086  	}()
  4087  	ctx = graphql.WithFieldContext(ctx, fc)
  4088  	if fc.Args, err = ec.field_Query_defaultScalar_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4089  		ec.Error(ctx, err)
  4090  		return
  4091  	}
  4092  	return fc, nil
  4093  }
  4094  
  4095  func (ec *executionContext) _Query_slices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4096  	fc, err := ec.fieldContext_Query_slices(ctx, field)
  4097  	if err != nil {
  4098  		return graphql.Null
  4099  	}
  4100  	ctx = graphql.WithFieldContext(ctx, fc)
  4101  	defer func() {
  4102  		if r := recover(); r != nil {
  4103  			ec.Error(ctx, ec.Recover(ctx, r))
  4104  			ret = graphql.Null
  4105  		}
  4106  	}()
  4107  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4108  		ctx = rctx // use context from middleware stack in children
  4109  		return ec.resolvers.Query().Slices(rctx)
  4110  	})
  4111  
  4112  	if resTmp == nil {
  4113  		return graphql.Null
  4114  	}
  4115  	res := resTmp.(*Slices)
  4116  	fc.Result = res
  4117  	return ec.marshalOSlices2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐSlices(ctx, field.Selections, res)
  4118  }
  4119  
  4120  func (ec *executionContext) fieldContext_Query_slices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4121  	fc = &graphql.FieldContext{
  4122  		Object:     "Query",
  4123  		Field:      field,
  4124  		IsMethod:   true,
  4125  		IsResolver: true,
  4126  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4127  			switch field.Name {
  4128  			case "test1":
  4129  				return ec.fieldContext_Slices_test1(ctx, field)
  4130  			case "test2":
  4131  				return ec.fieldContext_Slices_test2(ctx, field)
  4132  			case "test3":
  4133  				return ec.fieldContext_Slices_test3(ctx, field)
  4134  			case "test4":
  4135  				return ec.fieldContext_Slices_test4(ctx, field)
  4136  			}
  4137  			return nil, fmt.Errorf("no field named %q was found under type Slices", field.Name)
  4138  		},
  4139  	}
  4140  	return fc, nil
  4141  }
  4142  
  4143  func (ec *executionContext) _Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4144  	fc, err := ec.fieldContext_Query_scalarSlice(ctx, field)
  4145  	if err != nil {
  4146  		return graphql.Null
  4147  	}
  4148  	ctx = graphql.WithFieldContext(ctx, fc)
  4149  	defer func() {
  4150  		if r := recover(); r != nil {
  4151  			ec.Error(ctx, ec.Recover(ctx, r))
  4152  			ret = graphql.Null
  4153  		}
  4154  	}()
  4155  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4156  		ctx = rctx // use context from middleware stack in children
  4157  		return ec.resolvers.Query().ScalarSlice(rctx)
  4158  	})
  4159  
  4160  	if resTmp == nil {
  4161  		if !graphql.HasFieldError(ctx, fc) {
  4162  			ec.Errorf(ctx, "must not be null")
  4163  		}
  4164  		return graphql.Null
  4165  	}
  4166  	res := resTmp.([]byte)
  4167  	fc.Result = res
  4168  	return ec.marshalNBytes2ᚕbyte(ctx, field.Selections, res)
  4169  }
  4170  
  4171  func (ec *executionContext) fieldContext_Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4172  	fc = &graphql.FieldContext{
  4173  		Object:     "Query",
  4174  		Field:      field,
  4175  		IsMethod:   true,
  4176  		IsResolver: true,
  4177  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4178  			return nil, errors.New("field of type Bytes does not have child fields")
  4179  		},
  4180  	}
  4181  	return fc, nil
  4182  }
  4183  
  4184  func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4185  	fc, err := ec.fieldContext_Query_fallback(ctx, field)
  4186  	if err != nil {
  4187  		return graphql.Null
  4188  	}
  4189  	ctx = graphql.WithFieldContext(ctx, fc)
  4190  	defer func() {
  4191  		if r := recover(); r != nil {
  4192  			ec.Error(ctx, ec.Recover(ctx, r))
  4193  			ret = graphql.Null
  4194  		}
  4195  	}()
  4196  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4197  		ctx = rctx // use context from middleware stack in children
  4198  		return ec.resolvers.Query().Fallback(rctx, fc.Args["arg"].(FallbackToStringEncoding))
  4199  	})
  4200  
  4201  	if resTmp == nil {
  4202  		if !graphql.HasFieldError(ctx, fc) {
  4203  			ec.Errorf(ctx, "must not be null")
  4204  		}
  4205  		return graphql.Null
  4206  	}
  4207  	res := resTmp.(FallbackToStringEncoding)
  4208  	fc.Result = res
  4209  	return ec.marshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐFallbackToStringEncoding(ctx, field.Selections, res)
  4210  }
  4211  
  4212  func (ec *executionContext) fieldContext_Query_fallback(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4213  	fc = &graphql.FieldContext{
  4214  		Object:     "Query",
  4215  		Field:      field,
  4216  		IsMethod:   true,
  4217  		IsResolver: true,
  4218  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4219  			return nil, errors.New("field of type FallbackToStringEncoding does not have child fields")
  4220  		},
  4221  	}
  4222  	defer func() {
  4223  		if r := recover(); r != nil {
  4224  			err = ec.Recover(ctx, r)
  4225  			ec.Error(ctx, err)
  4226  		}
  4227  	}()
  4228  	ctx = graphql.WithFieldContext(ctx, fc)
  4229  	if fc.Args, err = ec.field_Query_fallback_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4230  		ec.Error(ctx, err)
  4231  		return
  4232  	}
  4233  	return fc, nil
  4234  }
  4235  
  4236  func (ec *executionContext) _Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4237  	fc, err := ec.fieldContext_Query_optionalUnion(ctx, field)
  4238  	if err != nil {
  4239  		return graphql.Null
  4240  	}
  4241  	ctx = graphql.WithFieldContext(ctx, fc)
  4242  	defer func() {
  4243  		if r := recover(); r != nil {
  4244  			ec.Error(ctx, ec.Recover(ctx, r))
  4245  			ret = graphql.Null
  4246  		}
  4247  	}()
  4248  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4249  		ctx = rctx // use context from middleware stack in children
  4250  		return ec.resolvers.Query().OptionalUnion(rctx)
  4251  	})
  4252  
  4253  	if resTmp == nil {
  4254  		return graphql.Null
  4255  	}
  4256  	res := resTmp.(TestUnion)
  4257  	fc.Result = res
  4258  	return ec.marshalOTestUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐTestUnion(ctx, field.Selections, res)
  4259  }
  4260  
  4261  func (ec *executionContext) fieldContext_Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4262  	fc = &graphql.FieldContext{
  4263  		Object:     "Query",
  4264  		Field:      field,
  4265  		IsMethod:   true,
  4266  		IsResolver: true,
  4267  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4268  			return nil, errors.New("field of type TestUnion does not have child fields")
  4269  		},
  4270  	}
  4271  	return fc, nil
  4272  }
  4273  
  4274  func (ec *executionContext) _Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4275  	fc, err := ec.fieldContext_Query_vOkCaseValue(ctx, field)
  4276  	if err != nil {
  4277  		return graphql.Null
  4278  	}
  4279  	ctx = graphql.WithFieldContext(ctx, fc)
  4280  	defer func() {
  4281  		if r := recover(); r != nil {
  4282  			ec.Error(ctx, ec.Recover(ctx, r))
  4283  			ret = graphql.Null
  4284  		}
  4285  	}()
  4286  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4287  		ctx = rctx // use context from middleware stack in children
  4288  		return ec.resolvers.Query().VOkCaseValue(rctx)
  4289  	})
  4290  
  4291  	if resTmp == nil {
  4292  		return graphql.Null
  4293  	}
  4294  	res := resTmp.(*VOkCaseValue)
  4295  	fc.Result = res
  4296  	return ec.marshalOVOkCaseValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVOkCaseValue(ctx, field.Selections, res)
  4297  }
  4298  
  4299  func (ec *executionContext) fieldContext_Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4300  	fc = &graphql.FieldContext{
  4301  		Object:     "Query",
  4302  		Field:      field,
  4303  		IsMethod:   true,
  4304  		IsResolver: true,
  4305  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4306  			switch field.Name {
  4307  			case "value":
  4308  				return ec.fieldContext_VOkCaseValue_value(ctx, field)
  4309  			}
  4310  			return nil, fmt.Errorf("no field named %q was found under type VOkCaseValue", field.Name)
  4311  		},
  4312  	}
  4313  	return fc, nil
  4314  }
  4315  
  4316  func (ec *executionContext) _Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4317  	fc, err := ec.fieldContext_Query_vOkCaseNil(ctx, field)
  4318  	if err != nil {
  4319  		return graphql.Null
  4320  	}
  4321  	ctx = graphql.WithFieldContext(ctx, fc)
  4322  	defer func() {
  4323  		if r := recover(); r != nil {
  4324  			ec.Error(ctx, ec.Recover(ctx, r))
  4325  			ret = graphql.Null
  4326  		}
  4327  	}()
  4328  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4329  		ctx = rctx // use context from middleware stack in children
  4330  		return ec.resolvers.Query().VOkCaseNil(rctx)
  4331  	})
  4332  
  4333  	if resTmp == nil {
  4334  		return graphql.Null
  4335  	}
  4336  	res := resTmp.(*VOkCaseNil)
  4337  	fc.Result = res
  4338  	return ec.marshalOVOkCaseNil2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVOkCaseNil(ctx, field.Selections, res)
  4339  }
  4340  
  4341  func (ec *executionContext) fieldContext_Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4342  	fc = &graphql.FieldContext{
  4343  		Object:     "Query",
  4344  		Field:      field,
  4345  		IsMethod:   true,
  4346  		IsResolver: true,
  4347  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4348  			switch field.Name {
  4349  			case "value":
  4350  				return ec.fieldContext_VOkCaseNil_value(ctx, field)
  4351  			}
  4352  			return nil, fmt.Errorf("no field named %q was found under type VOkCaseNil", field.Name)
  4353  		},
  4354  	}
  4355  	return fc, nil
  4356  }
  4357  
  4358  func (ec *executionContext) _Query_validType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4359  	fc, err := ec.fieldContext_Query_validType(ctx, field)
  4360  	if err != nil {
  4361  		return graphql.Null
  4362  	}
  4363  	ctx = graphql.WithFieldContext(ctx, fc)
  4364  	defer func() {
  4365  		if r := recover(); r != nil {
  4366  			ec.Error(ctx, ec.Recover(ctx, r))
  4367  			ret = graphql.Null
  4368  		}
  4369  	}()
  4370  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4371  		ctx = rctx // use context from middleware stack in children
  4372  		return ec.resolvers.Query().ValidType(rctx)
  4373  	})
  4374  
  4375  	if resTmp == nil {
  4376  		return graphql.Null
  4377  	}
  4378  	res := resTmp.(*ValidType)
  4379  	fc.Result = res
  4380  	return ec.marshalOValidType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐValidType(ctx, field.Selections, res)
  4381  }
  4382  
  4383  func (ec *executionContext) fieldContext_Query_validType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4384  	fc = &graphql.FieldContext{
  4385  		Object:     "Query",
  4386  		Field:      field,
  4387  		IsMethod:   true,
  4388  		IsResolver: true,
  4389  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4390  			switch field.Name {
  4391  			case "differentCase":
  4392  				return ec.fieldContext_ValidType_differentCase(ctx, field)
  4393  			case "different_case":
  4394  				return ec.fieldContext_ValidType_different_case(ctx, field)
  4395  			case "validInputKeywords":
  4396  				return ec.fieldContext_ValidType_validInputKeywords(ctx, field)
  4397  			case "validArgs":
  4398  				return ec.fieldContext_ValidType_validArgs(ctx, field)
  4399  			}
  4400  			return nil, fmt.Errorf("no field named %q was found under type ValidType", field.Name)
  4401  		},
  4402  	}
  4403  	return fc, nil
  4404  }
  4405  
  4406  func (ec *executionContext) _Query_variadicModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4407  	fc, err := ec.fieldContext_Query_variadicModel(ctx, field)
  4408  	if err != nil {
  4409  		return graphql.Null
  4410  	}
  4411  	ctx = graphql.WithFieldContext(ctx, fc)
  4412  	defer func() {
  4413  		if r := recover(); r != nil {
  4414  			ec.Error(ctx, ec.Recover(ctx, r))
  4415  			ret = graphql.Null
  4416  		}
  4417  	}()
  4418  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4419  		ctx = rctx // use context from middleware stack in children
  4420  		return ec.resolvers.Query().VariadicModel(rctx)
  4421  	})
  4422  
  4423  	if resTmp == nil {
  4424  		return graphql.Null
  4425  	}
  4426  	res := resTmp.(*VariadicModel)
  4427  	fc.Result = res
  4428  	return ec.marshalOVariadicModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVariadicModel(ctx, field.Selections, res)
  4429  }
  4430  
  4431  func (ec *executionContext) fieldContext_Query_variadicModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4432  	fc = &graphql.FieldContext{
  4433  		Object:     "Query",
  4434  		Field:      field,
  4435  		IsMethod:   true,
  4436  		IsResolver: true,
  4437  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4438  			switch field.Name {
  4439  			case "value":
  4440  				return ec.fieldContext_VariadicModel_value(ctx, field)
  4441  			}
  4442  			return nil, fmt.Errorf("no field named %q was found under type VariadicModel", field.Name)
  4443  		},
  4444  	}
  4445  	return fc, nil
  4446  }
  4447  
  4448  func (ec *executionContext) _Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4449  	fc, err := ec.fieldContext_Query_wrappedStruct(ctx, field)
  4450  	if err != nil {
  4451  		return graphql.Null
  4452  	}
  4453  	ctx = graphql.WithFieldContext(ctx, fc)
  4454  	defer func() {
  4455  		if r := recover(); r != nil {
  4456  			ec.Error(ctx, ec.Recover(ctx, r))
  4457  			ret = graphql.Null
  4458  		}
  4459  	}()
  4460  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4461  		ctx = rctx // use context from middleware stack in children
  4462  		return ec.resolvers.Query().WrappedStruct(rctx)
  4463  	})
  4464  
  4465  	if resTmp == nil {
  4466  		if !graphql.HasFieldError(ctx, fc) {
  4467  			ec.Errorf(ctx, "must not be null")
  4468  		}
  4469  		return graphql.Null
  4470  	}
  4471  	res := resTmp.(*WrappedStruct)
  4472  	fc.Result = res
  4473  	return ec.marshalNWrappedStruct2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedStruct(ctx, field.Selections, res)
  4474  }
  4475  
  4476  func (ec *executionContext) fieldContext_Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4477  	fc = &graphql.FieldContext{
  4478  		Object:     "Query",
  4479  		Field:      field,
  4480  		IsMethod:   true,
  4481  		IsResolver: true,
  4482  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4483  			switch field.Name {
  4484  			case "name":
  4485  				return ec.fieldContext_WrappedStruct_name(ctx, field)
  4486  			case "desc":
  4487  				return ec.fieldContext_WrappedStruct_desc(ctx, field)
  4488  			}
  4489  			return nil, fmt.Errorf("no field named %q was found under type WrappedStruct", field.Name)
  4490  		},
  4491  	}
  4492  	return fc, nil
  4493  }
  4494  
  4495  func (ec *executionContext) _Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4496  	fc, err := ec.fieldContext_Query_wrappedScalar(ctx, field)
  4497  	if err != nil {
  4498  		return graphql.Null
  4499  	}
  4500  	ctx = graphql.WithFieldContext(ctx, fc)
  4501  	defer func() {
  4502  		if r := recover(); r != nil {
  4503  			ec.Error(ctx, ec.Recover(ctx, r))
  4504  			ret = graphql.Null
  4505  		}
  4506  	}()
  4507  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4508  		ctx = rctx // use context from middleware stack in children
  4509  		return ec.resolvers.Query().WrappedScalar(rctx)
  4510  	})
  4511  
  4512  	if resTmp == nil {
  4513  		if !graphql.HasFieldError(ctx, fc) {
  4514  			ec.Errorf(ctx, "must not be null")
  4515  		}
  4516  		return graphql.Null
  4517  	}
  4518  	res := resTmp.(otherpkg.Scalar)
  4519  	fc.Result = res
  4520  	return ec.marshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋotherpkgᚐScalar(ctx, field.Selections, res)
  4521  }
  4522  
  4523  func (ec *executionContext) fieldContext_Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4524  	fc = &graphql.FieldContext{
  4525  		Object:     "Query",
  4526  		Field:      field,
  4527  		IsMethod:   true,
  4528  		IsResolver: true,
  4529  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4530  			return nil, errors.New("field of type WrappedScalar does not have child fields")
  4531  		},
  4532  	}
  4533  	return fc, nil
  4534  }
  4535  
  4536  func (ec *executionContext) _Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4537  	fc, err := ec.fieldContext_Query_wrappedMap(ctx, field)
  4538  	if err != nil {
  4539  		return graphql.Null
  4540  	}
  4541  	ctx = graphql.WithFieldContext(ctx, fc)
  4542  	defer func() {
  4543  		if r := recover(); r != nil {
  4544  			ec.Error(ctx, ec.Recover(ctx, r))
  4545  			ret = graphql.Null
  4546  		}
  4547  	}()
  4548  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4549  		ctx = rctx // use context from middleware stack in children
  4550  		return ec.resolvers.Query().WrappedMap(rctx)
  4551  	})
  4552  
  4553  	if resTmp == nil {
  4554  		if !graphql.HasFieldError(ctx, fc) {
  4555  			ec.Errorf(ctx, "must not be null")
  4556  		}
  4557  		return graphql.Null
  4558  	}
  4559  	res := resTmp.(WrappedMap)
  4560  	fc.Result = res
  4561  	return ec.marshalNWrappedMap2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedMap(ctx, field.Selections, res)
  4562  }
  4563  
  4564  func (ec *executionContext) fieldContext_Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4565  	fc = &graphql.FieldContext{
  4566  		Object:     "Query",
  4567  		Field:      field,
  4568  		IsMethod:   true,
  4569  		IsResolver: true,
  4570  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4571  			switch field.Name {
  4572  			case "get":
  4573  				return ec.fieldContext_WrappedMap_get(ctx, field)
  4574  			}
  4575  			return nil, fmt.Errorf("no field named %q was found under type WrappedMap", field.Name)
  4576  		},
  4577  	}
  4578  	return fc, nil
  4579  }
  4580  
  4581  func (ec *executionContext) _Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4582  	fc, err := ec.fieldContext_Query_wrappedSlice(ctx, field)
  4583  	if err != nil {
  4584  		return graphql.Null
  4585  	}
  4586  	ctx = graphql.WithFieldContext(ctx, fc)
  4587  	defer func() {
  4588  		if r := recover(); r != nil {
  4589  			ec.Error(ctx, ec.Recover(ctx, r))
  4590  			ret = graphql.Null
  4591  		}
  4592  	}()
  4593  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4594  		ctx = rctx // use context from middleware stack in children
  4595  		return ec.resolvers.Query().WrappedSlice(rctx)
  4596  	})
  4597  
  4598  	if resTmp == nil {
  4599  		if !graphql.HasFieldError(ctx, fc) {
  4600  			ec.Errorf(ctx, "must not be null")
  4601  		}
  4602  		return graphql.Null
  4603  	}
  4604  	res := resTmp.(WrappedSlice)
  4605  	fc.Result = res
  4606  	return ec.marshalNWrappedSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedSlice(ctx, field.Selections, res)
  4607  }
  4608  
  4609  func (ec *executionContext) fieldContext_Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4610  	fc = &graphql.FieldContext{
  4611  		Object:     "Query",
  4612  		Field:      field,
  4613  		IsMethod:   true,
  4614  		IsResolver: true,
  4615  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4616  			switch field.Name {
  4617  			case "get":
  4618  				return ec.fieldContext_WrappedSlice_get(ctx, field)
  4619  			}
  4620  			return nil, fmt.Errorf("no field named %q was found under type WrappedSlice", field.Name)
  4621  		},
  4622  	}
  4623  	return fc, nil
  4624  }
  4625  
  4626  func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4627  	fc, err := ec.fieldContext_Query___type(ctx, field)
  4628  	if err != nil {
  4629  		return graphql.Null
  4630  	}
  4631  	ctx = graphql.WithFieldContext(ctx, fc)
  4632  	defer func() {
  4633  		if r := recover(); r != nil {
  4634  			ec.Error(ctx, ec.Recover(ctx, r))
  4635  			ret = graphql.Null
  4636  		}
  4637  	}()
  4638  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4639  		ctx = rctx // use context from middleware stack in children
  4640  		return ec.introspectType(fc.Args["name"].(string))
  4641  	})
  4642  
  4643  	if resTmp == nil {
  4644  		return graphql.Null
  4645  	}
  4646  	res := resTmp.(*introspection.Type)
  4647  	fc.Result = res
  4648  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  4649  }
  4650  
  4651  func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4652  	fc = &graphql.FieldContext{
  4653  		Object:     "Query",
  4654  		Field:      field,
  4655  		IsMethod:   true,
  4656  		IsResolver: false,
  4657  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4658  			switch field.Name {
  4659  			case "kind":
  4660  				return ec.fieldContext___Type_kind(ctx, field)
  4661  			case "name":
  4662  				return ec.fieldContext___Type_name(ctx, field)
  4663  			case "description":
  4664  				return ec.fieldContext___Type_description(ctx, field)
  4665  			case "fields":
  4666  				return ec.fieldContext___Type_fields(ctx, field)
  4667  			case "interfaces":
  4668  				return ec.fieldContext___Type_interfaces(ctx, field)
  4669  			case "possibleTypes":
  4670  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  4671  			case "enumValues":
  4672  				return ec.fieldContext___Type_enumValues(ctx, field)
  4673  			case "inputFields":
  4674  				return ec.fieldContext___Type_inputFields(ctx, field)
  4675  			case "ofType":
  4676  				return ec.fieldContext___Type_ofType(ctx, field)
  4677  			case "specifiedByURL":
  4678  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  4679  			}
  4680  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  4681  		},
  4682  	}
  4683  	defer func() {
  4684  		if r := recover(); r != nil {
  4685  			err = ec.Recover(ctx, r)
  4686  			ec.Error(ctx, err)
  4687  		}
  4688  	}()
  4689  	ctx = graphql.WithFieldContext(ctx, fc)
  4690  	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4691  		ec.Error(ctx, err)
  4692  		return
  4693  	}
  4694  	return fc, nil
  4695  }
  4696  
  4697  func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4698  	fc, err := ec.fieldContext_Query___schema(ctx, field)
  4699  	if err != nil {
  4700  		return graphql.Null
  4701  	}
  4702  	ctx = graphql.WithFieldContext(ctx, fc)
  4703  	defer func() {
  4704  		if r := recover(); r != nil {
  4705  			ec.Error(ctx, ec.Recover(ctx, r))
  4706  			ret = graphql.Null
  4707  		}
  4708  	}()
  4709  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4710  		ctx = rctx // use context from middleware stack in children
  4711  		return ec.introspectSchema()
  4712  	})
  4713  
  4714  	if resTmp == nil {
  4715  		return graphql.Null
  4716  	}
  4717  	res := resTmp.(*introspection.Schema)
  4718  	fc.Result = res
  4719  	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
  4720  }
  4721  
  4722  func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4723  	fc = &graphql.FieldContext{
  4724  		Object:     "Query",
  4725  		Field:      field,
  4726  		IsMethod:   true,
  4727  		IsResolver: false,
  4728  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4729  			switch field.Name {
  4730  			case "description":
  4731  				return ec.fieldContext___Schema_description(ctx, field)
  4732  			case "types":
  4733  				return ec.fieldContext___Schema_types(ctx, field)
  4734  			case "queryType":
  4735  				return ec.fieldContext___Schema_queryType(ctx, field)
  4736  			case "mutationType":
  4737  				return ec.fieldContext___Schema_mutationType(ctx, field)
  4738  			case "subscriptionType":
  4739  				return ec.fieldContext___Schema_subscriptionType(ctx, field)
  4740  			case "directives":
  4741  				return ec.fieldContext___Schema_directives(ctx, field)
  4742  			}
  4743  			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
  4744  		},
  4745  	}
  4746  	return fc, nil
  4747  }
  4748  
  4749  func (ec *executionContext) _Subscription_updated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4750  	fc, err := ec.fieldContext_Subscription_updated(ctx, field)
  4751  	if err != nil {
  4752  		return nil
  4753  	}
  4754  	ctx = graphql.WithFieldContext(ctx, fc)
  4755  	defer func() {
  4756  		if r := recover(); r != nil {
  4757  			ec.Error(ctx, ec.Recover(ctx, r))
  4758  			ret = nil
  4759  		}
  4760  	}()
  4761  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4762  		ctx = rctx // use context from middleware stack in children
  4763  		return ec.resolvers.Subscription().Updated(rctx)
  4764  	})
  4765  
  4766  	if resTmp == nil {
  4767  		if !graphql.HasFieldError(ctx, fc) {
  4768  			ec.Errorf(ctx, "must not be null")
  4769  		}
  4770  		return nil
  4771  	}
  4772  	return func(ctx context.Context) graphql.Marshaler {
  4773  		select {
  4774  		case res, ok := <-resTmp.(<-chan string):
  4775  			if !ok {
  4776  				return nil
  4777  			}
  4778  			return graphql.WriterFunc(func(w io.Writer) {
  4779  				w.Write([]byte{'{'})
  4780  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4781  				w.Write([]byte{':'})
  4782  				ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w)
  4783  				w.Write([]byte{'}'})
  4784  			})
  4785  		case <-ctx.Done():
  4786  			return nil
  4787  		}
  4788  	}
  4789  }
  4790  
  4791  func (ec *executionContext) fieldContext_Subscription_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4792  	fc = &graphql.FieldContext{
  4793  		Object:     "Subscription",
  4794  		Field:      field,
  4795  		IsMethod:   true,
  4796  		IsResolver: true,
  4797  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4798  			return nil, errors.New("field of type String does not have child fields")
  4799  		},
  4800  	}
  4801  	return fc, nil
  4802  }
  4803  
  4804  func (ec *executionContext) _Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4805  	fc, err := ec.fieldContext_Subscription_initPayload(ctx, field)
  4806  	if err != nil {
  4807  		return nil
  4808  	}
  4809  	ctx = graphql.WithFieldContext(ctx, fc)
  4810  	defer func() {
  4811  		if r := recover(); r != nil {
  4812  			ec.Error(ctx, ec.Recover(ctx, r))
  4813  			ret = nil
  4814  		}
  4815  	}()
  4816  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4817  		ctx = rctx // use context from middleware stack in children
  4818  		return ec.resolvers.Subscription().InitPayload(rctx)
  4819  	})
  4820  
  4821  	if resTmp == nil {
  4822  		if !graphql.HasFieldError(ctx, fc) {
  4823  			ec.Errorf(ctx, "must not be null")
  4824  		}
  4825  		return nil
  4826  	}
  4827  	return func(ctx context.Context) graphql.Marshaler {
  4828  		select {
  4829  		case res, ok := <-resTmp.(<-chan string):
  4830  			if !ok {
  4831  				return nil
  4832  			}
  4833  			return graphql.WriterFunc(func(w io.Writer) {
  4834  				w.Write([]byte{'{'})
  4835  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4836  				w.Write([]byte{':'})
  4837  				ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w)
  4838  				w.Write([]byte{'}'})
  4839  			})
  4840  		case <-ctx.Done():
  4841  			return nil
  4842  		}
  4843  	}
  4844  }
  4845  
  4846  func (ec *executionContext) fieldContext_Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4847  	fc = &graphql.FieldContext{
  4848  		Object:     "Subscription",
  4849  		Field:      field,
  4850  		IsMethod:   true,
  4851  		IsResolver: true,
  4852  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4853  			return nil, errors.New("field of type String does not have child fields")
  4854  		},
  4855  	}
  4856  	return fc, nil
  4857  }
  4858  
  4859  func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4860  	fc, err := ec.fieldContext_Subscription_directiveArg(ctx, field)
  4861  	if err != nil {
  4862  		return nil
  4863  	}
  4864  	ctx = graphql.WithFieldContext(ctx, fc)
  4865  	defer func() {
  4866  		if r := recover(); r != nil {
  4867  			ec.Error(ctx, ec.Recover(ctx, r))
  4868  			ret = nil
  4869  		}
  4870  	}()
  4871  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4872  		ctx = rctx // use context from middleware stack in children
  4873  		return ec.resolvers.Subscription().DirectiveArg(rctx, fc.Args["arg"].(string))
  4874  	})
  4875  
  4876  	if resTmp == nil {
  4877  		return nil
  4878  	}
  4879  	return func(ctx context.Context) graphql.Marshaler {
  4880  		select {
  4881  		case res, ok := <-resTmp.(<-chan *string):
  4882  			if !ok {
  4883  				return nil
  4884  			}
  4885  			return graphql.WriterFunc(func(w io.Writer) {
  4886  				w.Write([]byte{'{'})
  4887  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4888  				w.Write([]byte{':'})
  4889  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  4890  				w.Write([]byte{'}'})
  4891  			})
  4892  		case <-ctx.Done():
  4893  			return nil
  4894  		}
  4895  	}
  4896  }
  4897  
  4898  func (ec *executionContext) fieldContext_Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4899  	fc = &graphql.FieldContext{
  4900  		Object:     "Subscription",
  4901  		Field:      field,
  4902  		IsMethod:   true,
  4903  		IsResolver: true,
  4904  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4905  			return nil, errors.New("field of type String does not have child fields")
  4906  		},
  4907  	}
  4908  	defer func() {
  4909  		if r := recover(); r != nil {
  4910  			err = ec.Recover(ctx, r)
  4911  			ec.Error(ctx, err)
  4912  		}
  4913  	}()
  4914  	ctx = graphql.WithFieldContext(ctx, fc)
  4915  	if fc.Args, err = ec.field_Subscription_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4916  		ec.Error(ctx, err)
  4917  		return
  4918  	}
  4919  	return fc, nil
  4920  }
  4921  
  4922  func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4923  	fc, err := ec.fieldContext_Subscription_directiveNullableArg(ctx, field)
  4924  	if err != nil {
  4925  		return nil
  4926  	}
  4927  	ctx = graphql.WithFieldContext(ctx, fc)
  4928  	defer func() {
  4929  		if r := recover(); r != nil {
  4930  			ec.Error(ctx, ec.Recover(ctx, r))
  4931  			ret = nil
  4932  		}
  4933  	}()
  4934  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4935  		ctx = rctx // use context from middleware stack in children
  4936  		return ec.resolvers.Subscription().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string))
  4937  	})
  4938  
  4939  	if resTmp == nil {
  4940  		return nil
  4941  	}
  4942  	return func(ctx context.Context) graphql.Marshaler {
  4943  		select {
  4944  		case res, ok := <-resTmp.(<-chan *string):
  4945  			if !ok {
  4946  				return nil
  4947  			}
  4948  			return graphql.WriterFunc(func(w io.Writer) {
  4949  				w.Write([]byte{'{'})
  4950  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4951  				w.Write([]byte{':'})
  4952  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  4953  				w.Write([]byte{'}'})
  4954  			})
  4955  		case <-ctx.Done():
  4956  			return nil
  4957  		}
  4958  	}
  4959  }
  4960  
  4961  func (ec *executionContext) fieldContext_Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4962  	fc = &graphql.FieldContext{
  4963  		Object:     "Subscription",
  4964  		Field:      field,
  4965  		IsMethod:   true,
  4966  		IsResolver: true,
  4967  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4968  			return nil, errors.New("field of type String does not have child fields")
  4969  		},
  4970  	}
  4971  	defer func() {
  4972  		if r := recover(); r != nil {
  4973  			err = ec.Recover(ctx, r)
  4974  			ec.Error(ctx, err)
  4975  		}
  4976  	}()
  4977  	ctx = graphql.WithFieldContext(ctx, fc)
  4978  	if fc.Args, err = ec.field_Subscription_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4979  		ec.Error(ctx, err)
  4980  		return
  4981  	}
  4982  	return fc, nil
  4983  }
  4984  
  4985  func (ec *executionContext) _Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4986  	fc, err := ec.fieldContext_Subscription_directiveDouble(ctx, field)
  4987  	if err != nil {
  4988  		return nil
  4989  	}
  4990  	ctx = graphql.WithFieldContext(ctx, fc)
  4991  	defer func() {
  4992  		if r := recover(); r != nil {
  4993  			ec.Error(ctx, ec.Recover(ctx, r))
  4994  			ret = nil
  4995  		}
  4996  	}()
  4997  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4998  		directive0 := func(rctx context.Context) (interface{}, error) {
  4999  			ctx = rctx // use context from middleware stack in children
  5000  			return ec.resolvers.Subscription().DirectiveDouble(rctx)
  5001  		}
  5002  		directive1 := func(ctx context.Context) (interface{}, error) {
  5003  			if ec.directives.Directive1 == nil {
  5004  				return nil, errors.New("directive directive1 is not implemented")
  5005  			}
  5006  			return ec.directives.Directive1(ctx, nil, directive0)
  5007  		}
  5008  		directive2 := func(ctx context.Context) (interface{}, error) {
  5009  			if ec.directives.Directive2 == nil {
  5010  				return nil, errors.New("directive directive2 is not implemented")
  5011  			}
  5012  			return ec.directives.Directive2(ctx, nil, directive1)
  5013  		}
  5014  
  5015  		tmp, err := directive2(rctx)
  5016  		if err != nil {
  5017  			return nil, graphql.ErrorOnPath(ctx, err)
  5018  		}
  5019  		if tmp == nil {
  5020  			return nil, nil
  5021  		}
  5022  		if data, ok := tmp.(<-chan *string); ok {
  5023  			return data, nil
  5024  		}
  5025  		return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp)
  5026  	})
  5027  
  5028  	if resTmp == nil {
  5029  		return nil
  5030  	}
  5031  	return func(ctx context.Context) graphql.Marshaler {
  5032  		select {
  5033  		case res, ok := <-resTmp.(<-chan *string):
  5034  			if !ok {
  5035  				return nil
  5036  			}
  5037  			return graphql.WriterFunc(func(w io.Writer) {
  5038  				w.Write([]byte{'{'})
  5039  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5040  				w.Write([]byte{':'})
  5041  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  5042  				w.Write([]byte{'}'})
  5043  			})
  5044  		case <-ctx.Done():
  5045  			return nil
  5046  		}
  5047  	}
  5048  }
  5049  
  5050  func (ec *executionContext) fieldContext_Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5051  	fc = &graphql.FieldContext{
  5052  		Object:     "Subscription",
  5053  		Field:      field,
  5054  		IsMethod:   true,
  5055  		IsResolver: true,
  5056  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5057  			return nil, errors.New("field of type String does not have child fields")
  5058  		},
  5059  	}
  5060  	return fc, nil
  5061  }
  5062  
  5063  func (ec *executionContext) _Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  5064  	fc, err := ec.fieldContext_Subscription_directiveUnimplemented(ctx, field)
  5065  	if err != nil {
  5066  		return nil
  5067  	}
  5068  	ctx = graphql.WithFieldContext(ctx, fc)
  5069  	defer func() {
  5070  		if r := recover(); r != nil {
  5071  			ec.Error(ctx, ec.Recover(ctx, r))
  5072  			ret = nil
  5073  		}
  5074  	}()
  5075  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  5076  		directive0 := func(rctx context.Context) (interface{}, error) {
  5077  			ctx = rctx // use context from middleware stack in children
  5078  			return ec.resolvers.Subscription().DirectiveUnimplemented(rctx)
  5079  		}
  5080  		directive1 := func(ctx context.Context) (interface{}, error) {
  5081  			if ec.directives.Unimplemented == nil {
  5082  				return nil, errors.New("directive unimplemented is not implemented")
  5083  			}
  5084  			return ec.directives.Unimplemented(ctx, nil, directive0)
  5085  		}
  5086  
  5087  		tmp, err := directive1(rctx)
  5088  		if err != nil {
  5089  			return nil, graphql.ErrorOnPath(ctx, err)
  5090  		}
  5091  		if tmp == nil {
  5092  			return nil, nil
  5093  		}
  5094  		if data, ok := tmp.(<-chan *string); ok {
  5095  			return data, nil
  5096  		}
  5097  		return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp)
  5098  	})
  5099  
  5100  	if resTmp == nil {
  5101  		return nil
  5102  	}
  5103  	return func(ctx context.Context) graphql.Marshaler {
  5104  		select {
  5105  		case res, ok := <-resTmp.(<-chan *string):
  5106  			if !ok {
  5107  				return nil
  5108  			}
  5109  			return graphql.WriterFunc(func(w io.Writer) {
  5110  				w.Write([]byte{'{'})
  5111  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5112  				w.Write([]byte{':'})
  5113  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  5114  				w.Write([]byte{'}'})
  5115  			})
  5116  		case <-ctx.Done():
  5117  			return nil
  5118  		}
  5119  	}
  5120  }
  5121  
  5122  func (ec *executionContext) fieldContext_Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5123  	fc = &graphql.FieldContext{
  5124  		Object:     "Subscription",
  5125  		Field:      field,
  5126  		IsMethod:   true,
  5127  		IsResolver: true,
  5128  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5129  			return nil, errors.New("field of type String does not have child fields")
  5130  		},
  5131  	}
  5132  	return fc, nil
  5133  }
  5134  
  5135  func (ec *executionContext) _Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  5136  	fc, err := ec.fieldContext_Subscription_issue896b(ctx, field)
  5137  	if err != nil {
  5138  		return nil
  5139  	}
  5140  	ctx = graphql.WithFieldContext(ctx, fc)
  5141  	defer func() {
  5142  		if r := recover(); r != nil {
  5143  			ec.Error(ctx, ec.Recover(ctx, r))
  5144  			ret = nil
  5145  		}
  5146  	}()
  5147  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  5148  		ctx = rctx // use context from middleware stack in children
  5149  		return ec.resolvers.Subscription().Issue896b(rctx)
  5150  	})
  5151  
  5152  	if resTmp == nil {
  5153  		return nil
  5154  	}
  5155  	return func(ctx context.Context) graphql.Marshaler {
  5156  		select {
  5157  		case res, ok := <-resTmp.(<-chan []*CheckIssue896):
  5158  			if !ok {
  5159  				return nil
  5160  			}
  5161  			return graphql.WriterFunc(func(w io.Writer) {
  5162  				w.Write([]byte{'{'})
  5163  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5164  				w.Write([]byte{':'})
  5165  				ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCheckIssue896(ctx, field.Selections, res).MarshalGQL(w)
  5166  				w.Write([]byte{'}'})
  5167  			})
  5168  		case <-ctx.Done():
  5169  			return nil
  5170  		}
  5171  	}
  5172  }
  5173  
  5174  func (ec *executionContext) fieldContext_Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5175  	fc = &graphql.FieldContext{
  5176  		Object:     "Subscription",
  5177  		Field:      field,
  5178  		IsMethod:   true,
  5179  		IsResolver: true,
  5180  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5181  			switch field.Name {
  5182  			case "id":
  5183  				return ec.fieldContext_CheckIssue896_id(ctx, field)
  5184  			}
  5185  			return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name)
  5186  		},
  5187  	}
  5188  	return fc, nil
  5189  }
  5190  
  5191  func (ec *executionContext) _Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  5192  	fc, err := ec.fieldContext_Subscription_errorRequired(ctx, field)
  5193  	if err != nil {
  5194  		return nil
  5195  	}
  5196  	ctx = graphql.WithFieldContext(ctx, fc)
  5197  	defer func() {
  5198  		if r := recover(); r != nil {
  5199  			ec.Error(ctx, ec.Recover(ctx, r))
  5200  			ret = nil
  5201  		}
  5202  	}()
  5203  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  5204  		ctx = rctx // use context from middleware stack in children
  5205  		return ec.resolvers.Subscription().ErrorRequired(rctx)
  5206  	})
  5207  
  5208  	if resTmp == nil {
  5209  		if !graphql.HasFieldError(ctx, fc) {
  5210  			ec.Errorf(ctx, "must not be null")
  5211  		}
  5212  		return nil
  5213  	}
  5214  	return func(ctx context.Context) graphql.Marshaler {
  5215  		select {
  5216  		case res, ok := <-resTmp.(<-chan *Error):
  5217  			if !ok {
  5218  				return nil
  5219  			}
  5220  			return graphql.WriterFunc(func(w io.Writer) {
  5221  				w.Write([]byte{'{'})
  5222  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5223  				w.Write([]byte{':'})
  5224  				ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res).MarshalGQL(w)
  5225  				w.Write([]byte{'}'})
  5226  			})
  5227  		case <-ctx.Done():
  5228  			return nil
  5229  		}
  5230  	}
  5231  }
  5232  
  5233  func (ec *executionContext) fieldContext_Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5234  	fc = &graphql.FieldContext{
  5235  		Object:     "Subscription",
  5236  		Field:      field,
  5237  		IsMethod:   true,
  5238  		IsResolver: true,
  5239  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5240  			switch field.Name {
  5241  			case "id":
  5242  				return ec.fieldContext_Error_id(ctx, field)
  5243  			case "errorOnNonRequiredField":
  5244  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  5245  			case "errorOnRequiredField":
  5246  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  5247  			case "nilOnRequiredField":
  5248  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  5249  			}
  5250  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  5251  		},
  5252  	}
  5253  	return fc, nil
  5254  }
  5255  
  5256  func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5257  	fc, err := ec.fieldContext_User_id(ctx, field)
  5258  	if err != nil {
  5259  		return graphql.Null
  5260  	}
  5261  	ctx = graphql.WithFieldContext(ctx, fc)
  5262  	defer func() {
  5263  		if r := recover(); r != nil {
  5264  			ec.Error(ctx, ec.Recover(ctx, r))
  5265  			ret = graphql.Null
  5266  		}
  5267  	}()
  5268  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5269  		ctx = rctx // use context from middleware stack in children
  5270  		return obj.ID, nil
  5271  	})
  5272  
  5273  	if resTmp == nil {
  5274  		if !graphql.HasFieldError(ctx, fc) {
  5275  			ec.Errorf(ctx, "must not be null")
  5276  		}
  5277  		return graphql.Null
  5278  	}
  5279  	res := resTmp.(int)
  5280  	fc.Result = res
  5281  	return ec.marshalNInt2int(ctx, field.Selections, res)
  5282  }
  5283  
  5284  func (ec *executionContext) fieldContext_User_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5285  	fc = &graphql.FieldContext{
  5286  		Object:     "User",
  5287  		Field:      field,
  5288  		IsMethod:   false,
  5289  		IsResolver: false,
  5290  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5291  			return nil, errors.New("field of type Int does not have child fields")
  5292  		},
  5293  	}
  5294  	return fc, nil
  5295  }
  5296  
  5297  func (ec *executionContext) _User_friends(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5298  	fc, err := ec.fieldContext_User_friends(ctx, field)
  5299  	if err != nil {
  5300  		return graphql.Null
  5301  	}
  5302  	ctx = graphql.WithFieldContext(ctx, fc)
  5303  	defer func() {
  5304  		if r := recover(); r != nil {
  5305  			ec.Error(ctx, ec.Recover(ctx, r))
  5306  			ret = graphql.Null
  5307  		}
  5308  	}()
  5309  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5310  		ctx = rctx // use context from middleware stack in children
  5311  		return ec.resolvers.User().Friends(rctx, obj)
  5312  	})
  5313  
  5314  	if resTmp == nil {
  5315  		if !graphql.HasFieldError(ctx, fc) {
  5316  			ec.Errorf(ctx, "must not be null")
  5317  		}
  5318  		return graphql.Null
  5319  	}
  5320  	res := resTmp.([]*User)
  5321  	fc.Result = res
  5322  	return ec.marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx, field.Selections, res)
  5323  }
  5324  
  5325  func (ec *executionContext) fieldContext_User_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5326  	fc = &graphql.FieldContext{
  5327  		Object:     "User",
  5328  		Field:      field,
  5329  		IsMethod:   true,
  5330  		IsResolver: true,
  5331  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5332  			switch field.Name {
  5333  			case "id":
  5334  				return ec.fieldContext_User_id(ctx, field)
  5335  			case "friends":
  5336  				return ec.fieldContext_User_friends(ctx, field)
  5337  			case "created":
  5338  				return ec.fieldContext_User_created(ctx, field)
  5339  			case "updated":
  5340  				return ec.fieldContext_User_updated(ctx, field)
  5341  			case "pets":
  5342  				return ec.fieldContext_User_pets(ctx, field)
  5343  			}
  5344  			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
  5345  		},
  5346  	}
  5347  	return fc, nil
  5348  }
  5349  
  5350  func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5351  	fc, err := ec.fieldContext_User_created(ctx, field)
  5352  	if err != nil {
  5353  		return graphql.Null
  5354  	}
  5355  	ctx = graphql.WithFieldContext(ctx, fc)
  5356  	defer func() {
  5357  		if r := recover(); r != nil {
  5358  			ec.Error(ctx, ec.Recover(ctx, r))
  5359  			ret = graphql.Null
  5360  		}
  5361  	}()
  5362  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5363  		ctx = rctx // use context from middleware stack in children
  5364  		return obj.Created, nil
  5365  	})
  5366  
  5367  	if resTmp == nil {
  5368  		if !graphql.HasFieldError(ctx, fc) {
  5369  			ec.Errorf(ctx, "must not be null")
  5370  		}
  5371  		return graphql.Null
  5372  	}
  5373  	res := resTmp.(time.Time)
  5374  	fc.Result = res
  5375  	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
  5376  }
  5377  
  5378  func (ec *executionContext) fieldContext_User_created(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5379  	fc = &graphql.FieldContext{
  5380  		Object:     "User",
  5381  		Field:      field,
  5382  		IsMethod:   false,
  5383  		IsResolver: false,
  5384  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5385  			return nil, errors.New("field of type Time does not have child fields")
  5386  		},
  5387  	}
  5388  	return fc, nil
  5389  }
  5390  
  5391  func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5392  	fc, err := ec.fieldContext_User_updated(ctx, field)
  5393  	if err != nil {
  5394  		return graphql.Null
  5395  	}
  5396  	ctx = graphql.WithFieldContext(ctx, fc)
  5397  	defer func() {
  5398  		if r := recover(); r != nil {
  5399  			ec.Error(ctx, ec.Recover(ctx, r))
  5400  			ret = graphql.Null
  5401  		}
  5402  	}()
  5403  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5404  		ctx = rctx // use context from middleware stack in children
  5405  		return obj.Updated, nil
  5406  	})
  5407  
  5408  	if resTmp == nil {
  5409  		return graphql.Null
  5410  	}
  5411  	res := resTmp.(*time.Time)
  5412  	fc.Result = res
  5413  	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
  5414  }
  5415  
  5416  func (ec *executionContext) fieldContext_User_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5417  	fc = &graphql.FieldContext{
  5418  		Object:     "User",
  5419  		Field:      field,
  5420  		IsMethod:   false,
  5421  		IsResolver: false,
  5422  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5423  			return nil, errors.New("field of type Time does not have child fields")
  5424  		},
  5425  	}
  5426  	return fc, nil
  5427  }
  5428  
  5429  func (ec *executionContext) _User_pets(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5430  	fc, err := ec.fieldContext_User_pets(ctx, field)
  5431  	if err != nil {
  5432  		return graphql.Null
  5433  	}
  5434  	ctx = graphql.WithFieldContext(ctx, fc)
  5435  	defer func() {
  5436  		if r := recover(); r != nil {
  5437  			ec.Error(ctx, ec.Recover(ctx, r))
  5438  			ret = graphql.Null
  5439  		}
  5440  	}()
  5441  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5442  		ctx = rctx // use context from middleware stack in children
  5443  		return ec.resolvers.User().Pets(rctx, obj, fc.Args["limit"].(*int))
  5444  	})
  5445  
  5446  	if resTmp == nil {
  5447  		return graphql.Null
  5448  	}
  5449  	res := resTmp.([]*Pet)
  5450  	fc.Result = res
  5451  	return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx, field.Selections, res)
  5452  }
  5453  
  5454  func (ec *executionContext) fieldContext_User_pets(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5455  	fc = &graphql.FieldContext{
  5456  		Object:     "User",
  5457  		Field:      field,
  5458  		IsMethod:   true,
  5459  		IsResolver: true,
  5460  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5461  			switch field.Name {
  5462  			case "id":
  5463  				return ec.fieldContext_Pet_id(ctx, field)
  5464  			case "friends":
  5465  				return ec.fieldContext_Pet_friends(ctx, field)
  5466  			}
  5467  			return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name)
  5468  		},
  5469  	}
  5470  	defer func() {
  5471  		if r := recover(); r != nil {
  5472  			err = ec.Recover(ctx, r)
  5473  			ec.Error(ctx, err)
  5474  		}
  5475  	}()
  5476  	ctx = graphql.WithFieldContext(ctx, fc)
  5477  	if fc.Args, err = ec.field_User_pets_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  5478  		ec.Error(ctx, err)
  5479  		return
  5480  	}
  5481  	return fc, nil
  5482  }
  5483  
  5484  // endregion **************************** field.gotpl *****************************
  5485  
  5486  // region    **************************** input.gotpl *****************************
  5487  
  5488  func (ec *executionContext) unmarshalInputInnerInput(ctx context.Context, obj interface{}) (InnerInput, error) {
  5489  	var it InnerInput
  5490  	asMap := map[string]interface{}{}
  5491  	for k, v := range obj.(map[string]interface{}) {
  5492  		asMap[k] = v
  5493  	}
  5494  
  5495  	fieldsInOrder := [...]string{"id"}
  5496  	for _, k := range fieldsInOrder {
  5497  		v, ok := asMap[k]
  5498  		if !ok {
  5499  			continue
  5500  		}
  5501  		switch k {
  5502  		case "id":
  5503  			var err error
  5504  
  5505  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
  5506  			it.ID, err = ec.unmarshalNInt2int(ctx, v)
  5507  			if err != nil {
  5508  				return it, err
  5509  			}
  5510  		}
  5511  	}
  5512  
  5513  	return it, nil
  5514  }
  5515  
  5516  func (ec *executionContext) unmarshalInputOuterInput(ctx context.Context, obj interface{}) (OuterInput, error) {
  5517  	var it OuterInput
  5518  	asMap := map[string]interface{}{}
  5519  	for k, v := range obj.(map[string]interface{}) {
  5520  		asMap[k] = v
  5521  	}
  5522  
  5523  	fieldsInOrder := [...]string{"inner"}
  5524  	for _, k := range fieldsInOrder {
  5525  		v, ok := asMap[k]
  5526  		if !ok {
  5527  			continue
  5528  		}
  5529  		switch k {
  5530  		case "inner":
  5531  			var err error
  5532  
  5533  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner"))
  5534  			it.Inner, err = ec.unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, v)
  5535  			if err != nil {
  5536  				return it, err
  5537  			}
  5538  		}
  5539  	}
  5540  
  5541  	return it, nil
  5542  }
  5543  
  5544  func (ec *executionContext) unmarshalInputRecursiveInputSlice(ctx context.Context, obj interface{}) (RecursiveInputSlice, error) {
  5545  	var it RecursiveInputSlice
  5546  	asMap := map[string]interface{}{}
  5547  	for k, v := range obj.(map[string]interface{}) {
  5548  		asMap[k] = v
  5549  	}
  5550  
  5551  	fieldsInOrder := [...]string{"self"}
  5552  	for _, k := range fieldsInOrder {
  5553  		v, ok := asMap[k]
  5554  		if !ok {
  5555  			continue
  5556  		}
  5557  		switch k {
  5558  		case "self":
  5559  			var err error
  5560  
  5561  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("self"))
  5562  			it.Self, err = ec.unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx, v)
  5563  			if err != nil {
  5564  				return it, err
  5565  			}
  5566  		}
  5567  	}
  5568  
  5569  	return it, nil
  5570  }
  5571  
  5572  // endregion **************************** input.gotpl *****************************
  5573  
  5574  // region    ************************** interface.gotpl ***************************
  5575  
  5576  // endregion ************************** interface.gotpl ***************************
  5577  
  5578  // region    **************************** object.gotpl ****************************
  5579  
  5580  var autobindImplementors = []string{"Autobind"}
  5581  
  5582  func (ec *executionContext) _Autobind(ctx context.Context, sel ast.SelectionSet, obj *Autobind) graphql.Marshaler {
  5583  	fields := graphql.CollectFields(ec.OperationContext, sel, autobindImplementors)
  5584  	out := graphql.NewFieldSet(fields)
  5585  	var invalids uint32
  5586  	for i, field := range fields {
  5587  		switch field.Name {
  5588  		case "__typename":
  5589  			out.Values[i] = graphql.MarshalString("Autobind")
  5590  		case "int":
  5591  
  5592  			out.Values[i] = ec._Autobind_int(ctx, field, obj)
  5593  
  5594  			if out.Values[i] == graphql.Null {
  5595  				invalids++
  5596  			}
  5597  		case "int32":
  5598  
  5599  			out.Values[i] = ec._Autobind_int32(ctx, field, obj)
  5600  
  5601  			if out.Values[i] == graphql.Null {
  5602  				invalids++
  5603  			}
  5604  		case "int64":
  5605  
  5606  			out.Values[i] = ec._Autobind_int64(ctx, field, obj)
  5607  
  5608  			if out.Values[i] == graphql.Null {
  5609  				invalids++
  5610  			}
  5611  		case "idStr":
  5612  
  5613  			out.Values[i] = ec._Autobind_idStr(ctx, field, obj)
  5614  
  5615  			if out.Values[i] == graphql.Null {
  5616  				invalids++
  5617  			}
  5618  		case "idInt":
  5619  
  5620  			out.Values[i] = ec._Autobind_idInt(ctx, field, obj)
  5621  
  5622  			if out.Values[i] == graphql.Null {
  5623  				invalids++
  5624  			}
  5625  		default:
  5626  			panic("unknown field " + strconv.Quote(field.Name))
  5627  		}
  5628  	}
  5629  	out.Dispatch()
  5630  	if invalids > 0 {
  5631  		return graphql.Null
  5632  	}
  5633  	return out
  5634  }
  5635  
  5636  var embeddedPointerImplementors = []string{"EmbeddedPointer"}
  5637  
  5638  func (ec *executionContext) _EmbeddedPointer(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedPointerModel) graphql.Marshaler {
  5639  	fields := graphql.CollectFields(ec.OperationContext, sel, embeddedPointerImplementors)
  5640  	out := graphql.NewFieldSet(fields)
  5641  	var invalids uint32
  5642  	for i, field := range fields {
  5643  		switch field.Name {
  5644  		case "__typename":
  5645  			out.Values[i] = graphql.MarshalString("EmbeddedPointer")
  5646  		case "ID":
  5647  
  5648  			out.Values[i] = ec._EmbeddedPointer_ID(ctx, field, obj)
  5649  
  5650  		case "Title":
  5651  
  5652  			out.Values[i] = ec._EmbeddedPointer_Title(ctx, field, obj)
  5653  
  5654  		default:
  5655  			panic("unknown field " + strconv.Quote(field.Name))
  5656  		}
  5657  	}
  5658  	out.Dispatch()
  5659  	if invalids > 0 {
  5660  		return graphql.Null
  5661  	}
  5662  	return out
  5663  }
  5664  
  5665  var forcedResolverImplementors = []string{"ForcedResolver"}
  5666  
  5667  func (ec *executionContext) _ForcedResolver(ctx context.Context, sel ast.SelectionSet, obj *ForcedResolver) graphql.Marshaler {
  5668  	fields := graphql.CollectFields(ec.OperationContext, sel, forcedResolverImplementors)
  5669  	out := graphql.NewFieldSet(fields)
  5670  	var invalids uint32
  5671  	for i, field := range fields {
  5672  		switch field.Name {
  5673  		case "__typename":
  5674  			out.Values[i] = graphql.MarshalString("ForcedResolver")
  5675  		case "field":
  5676  			field := field
  5677  
  5678  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5679  				defer func() {
  5680  					if r := recover(); r != nil {
  5681  						ec.Error(ctx, ec.Recover(ctx, r))
  5682  					}
  5683  				}()
  5684  				res = ec._ForcedResolver_field(ctx, field, obj)
  5685  				return res
  5686  			}
  5687  
  5688  			out.Concurrently(i, func() graphql.Marshaler {
  5689  				return innerFunc(ctx)
  5690  
  5691  			})
  5692  		default:
  5693  			panic("unknown field " + strconv.Quote(field.Name))
  5694  		}
  5695  	}
  5696  	out.Dispatch()
  5697  	if invalids > 0 {
  5698  		return graphql.Null
  5699  	}
  5700  	return out
  5701  }
  5702  
  5703  var innerObjectImplementors = []string{"InnerObject"}
  5704  
  5705  func (ec *executionContext) _InnerObject(ctx context.Context, sel ast.SelectionSet, obj *InnerObject) graphql.Marshaler {
  5706  	fields := graphql.CollectFields(ec.OperationContext, sel, innerObjectImplementors)
  5707  	out := graphql.NewFieldSet(fields)
  5708  	var invalids uint32
  5709  	for i, field := range fields {
  5710  		switch field.Name {
  5711  		case "__typename":
  5712  			out.Values[i] = graphql.MarshalString("InnerObject")
  5713  		case "id":
  5714  
  5715  			out.Values[i] = ec._InnerObject_id(ctx, field, obj)
  5716  
  5717  			if out.Values[i] == graphql.Null {
  5718  				invalids++
  5719  			}
  5720  		default:
  5721  			panic("unknown field " + strconv.Quote(field.Name))
  5722  		}
  5723  	}
  5724  	out.Dispatch()
  5725  	if invalids > 0 {
  5726  		return graphql.Null
  5727  	}
  5728  	return out
  5729  }
  5730  
  5731  var invalidIdentifierImplementors = []string{"InvalidIdentifier"}
  5732  
  5733  func (ec *executionContext) _InvalidIdentifier(ctx context.Context, sel ast.SelectionSet, obj *invalid_packagename.InvalidIdentifier) graphql.Marshaler {
  5734  	fields := graphql.CollectFields(ec.OperationContext, sel, invalidIdentifierImplementors)
  5735  	out := graphql.NewFieldSet(fields)
  5736  	var invalids uint32
  5737  	for i, field := range fields {
  5738  		switch field.Name {
  5739  		case "__typename":
  5740  			out.Values[i] = graphql.MarshalString("InvalidIdentifier")
  5741  		case "id":
  5742  
  5743  			out.Values[i] = ec._InvalidIdentifier_id(ctx, field, obj)
  5744  
  5745  			if out.Values[i] == graphql.Null {
  5746  				invalids++
  5747  			}
  5748  		default:
  5749  			panic("unknown field " + strconv.Quote(field.Name))
  5750  		}
  5751  	}
  5752  	out.Dispatch()
  5753  	if invalids > 0 {
  5754  		return graphql.Null
  5755  	}
  5756  	return out
  5757  }
  5758  
  5759  var itImplementors = []string{"It"}
  5760  
  5761  func (ec *executionContext) _It(ctx context.Context, sel ast.SelectionSet, obj *introspection1.It) graphql.Marshaler {
  5762  	fields := graphql.CollectFields(ec.OperationContext, sel, itImplementors)
  5763  	out := graphql.NewFieldSet(fields)
  5764  	var invalids uint32
  5765  	for i, field := range fields {
  5766  		switch field.Name {
  5767  		case "__typename":
  5768  			out.Values[i] = graphql.MarshalString("It")
  5769  		case "id":
  5770  
  5771  			out.Values[i] = ec._It_id(ctx, field, obj)
  5772  
  5773  			if out.Values[i] == graphql.Null {
  5774  				invalids++
  5775  			}
  5776  		default:
  5777  			panic("unknown field " + strconv.Quote(field.Name))
  5778  		}
  5779  	}
  5780  	out.Dispatch()
  5781  	if invalids > 0 {
  5782  		return graphql.Null
  5783  	}
  5784  	return out
  5785  }
  5786  
  5787  var modelMethodsImplementors = []string{"ModelMethods"}
  5788  
  5789  func (ec *executionContext) _ModelMethods(ctx context.Context, sel ast.SelectionSet, obj *ModelMethods) graphql.Marshaler {
  5790  	fields := graphql.CollectFields(ec.OperationContext, sel, modelMethodsImplementors)
  5791  	out := graphql.NewFieldSet(fields)
  5792  	var invalids uint32
  5793  	for i, field := range fields {
  5794  		switch field.Name {
  5795  		case "__typename":
  5796  			out.Values[i] = graphql.MarshalString("ModelMethods")
  5797  		case "resolverField":
  5798  			field := field
  5799  
  5800  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5801  				defer func() {
  5802  					if r := recover(); r != nil {
  5803  						ec.Error(ctx, ec.Recover(ctx, r))
  5804  					}
  5805  				}()
  5806  				res = ec._ModelMethods_resolverField(ctx, field, obj)
  5807  				if res == graphql.Null {
  5808  					atomic.AddUint32(&invalids, 1)
  5809  				}
  5810  				return res
  5811  			}
  5812  
  5813  			out.Concurrently(i, func() graphql.Marshaler {
  5814  				return innerFunc(ctx)
  5815  
  5816  			})
  5817  		case "noContext":
  5818  
  5819  			out.Values[i] = ec._ModelMethods_noContext(ctx, field, obj)
  5820  
  5821  			if out.Values[i] == graphql.Null {
  5822  				atomic.AddUint32(&invalids, 1)
  5823  			}
  5824  		case "withContext":
  5825  			field := field
  5826  
  5827  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5828  				defer func() {
  5829  					if r := recover(); r != nil {
  5830  						ec.Error(ctx, ec.Recover(ctx, r))
  5831  					}
  5832  				}()
  5833  				res = ec._ModelMethods_withContext(ctx, field, obj)
  5834  				if res == graphql.Null {
  5835  					atomic.AddUint32(&invalids, 1)
  5836  				}
  5837  				return res
  5838  			}
  5839  
  5840  			out.Concurrently(i, func() graphql.Marshaler {
  5841  				return innerFunc(ctx)
  5842  
  5843  			})
  5844  		default:
  5845  			panic("unknown field " + strconv.Quote(field.Name))
  5846  		}
  5847  	}
  5848  	out.Dispatch()
  5849  	if invalids > 0 {
  5850  		return graphql.Null
  5851  	}
  5852  	return out
  5853  }
  5854  
  5855  var outerObjectImplementors = []string{"OuterObject"}
  5856  
  5857  func (ec *executionContext) _OuterObject(ctx context.Context, sel ast.SelectionSet, obj *OuterObject) graphql.Marshaler {
  5858  	fields := graphql.CollectFields(ec.OperationContext, sel, outerObjectImplementors)
  5859  	out := graphql.NewFieldSet(fields)
  5860  	var invalids uint32
  5861  	for i, field := range fields {
  5862  		switch field.Name {
  5863  		case "__typename":
  5864  			out.Values[i] = graphql.MarshalString("OuterObject")
  5865  		case "inner":
  5866  
  5867  			out.Values[i] = ec._OuterObject_inner(ctx, field, obj)
  5868  
  5869  			if out.Values[i] == graphql.Null {
  5870  				invalids++
  5871  			}
  5872  		default:
  5873  			panic("unknown field " + strconv.Quote(field.Name))
  5874  		}
  5875  	}
  5876  	out.Dispatch()
  5877  	if invalids > 0 {
  5878  		return graphql.Null
  5879  	}
  5880  	return out
  5881  }
  5882  
  5883  var petImplementors = []string{"Pet"}
  5884  
  5885  func (ec *executionContext) _Pet(ctx context.Context, sel ast.SelectionSet, obj *Pet) graphql.Marshaler {
  5886  	fields := graphql.CollectFields(ec.OperationContext, sel, petImplementors)
  5887  	out := graphql.NewFieldSet(fields)
  5888  	var invalids uint32
  5889  	for i, field := range fields {
  5890  		switch field.Name {
  5891  		case "__typename":
  5892  			out.Values[i] = graphql.MarshalString("Pet")
  5893  		case "id":
  5894  
  5895  			out.Values[i] = ec._Pet_id(ctx, field, obj)
  5896  
  5897  			if out.Values[i] == graphql.Null {
  5898  				atomic.AddUint32(&invalids, 1)
  5899  			}
  5900  		case "friends":
  5901  			field := field
  5902  
  5903  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5904  				defer func() {
  5905  					if r := recover(); r != nil {
  5906  						ec.Error(ctx, ec.Recover(ctx, r))
  5907  					}
  5908  				}()
  5909  				res = ec._Pet_friends(ctx, field, obj)
  5910  				return res
  5911  			}
  5912  
  5913  			out.Concurrently(i, func() graphql.Marshaler {
  5914  				return innerFunc(ctx)
  5915  
  5916  			})
  5917  		default:
  5918  			panic("unknown field " + strconv.Quote(field.Name))
  5919  		}
  5920  	}
  5921  	out.Dispatch()
  5922  	if invalids > 0 {
  5923  		return graphql.Null
  5924  	}
  5925  	return out
  5926  }
  5927  
  5928  var queryImplementors = []string{"Query"}
  5929  
  5930  func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  5931  	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
  5932  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  5933  		Object: "Query",
  5934  	})
  5935  
  5936  	out := graphql.NewFieldSet(fields)
  5937  	var invalids uint32
  5938  	for i, field := range fields {
  5939  		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
  5940  			Object: field.Name,
  5941  			Field:  field,
  5942  		})
  5943  
  5944  		switch field.Name {
  5945  		case "__typename":
  5946  			out.Values[i] = graphql.MarshalString("Query")
  5947  		case "invalidIdentifier":
  5948  			field := field
  5949  
  5950  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5951  				defer func() {
  5952  					if r := recover(); r != nil {
  5953  						ec.Error(ctx, ec.Recover(ctx, r))
  5954  					}
  5955  				}()
  5956  				res = ec._Query_invalidIdentifier(ctx, field)
  5957  				return res
  5958  			}
  5959  
  5960  			rrm := func(ctx context.Context) graphql.Marshaler {
  5961  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5962  			}
  5963  
  5964  			out.Concurrently(i, func() graphql.Marshaler {
  5965  				return rrm(innerCtx)
  5966  			})
  5967  		case "collision":
  5968  			field := field
  5969  
  5970  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5971  				defer func() {
  5972  					if r := recover(); r != nil {
  5973  						ec.Error(ctx, ec.Recover(ctx, r))
  5974  					}
  5975  				}()
  5976  				res = ec._Query_collision(ctx, field)
  5977  				return res
  5978  			}
  5979  
  5980  			rrm := func(ctx context.Context) graphql.Marshaler {
  5981  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5982  			}
  5983  
  5984  			out.Concurrently(i, func() graphql.Marshaler {
  5985  				return rrm(innerCtx)
  5986  			})
  5987  		case "mapInput":
  5988  			field := field
  5989  
  5990  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5991  				defer func() {
  5992  					if r := recover(); r != nil {
  5993  						ec.Error(ctx, ec.Recover(ctx, r))
  5994  					}
  5995  				}()
  5996  				res = ec._Query_mapInput(ctx, field)
  5997  				return res
  5998  			}
  5999  
  6000  			rrm := func(ctx context.Context) graphql.Marshaler {
  6001  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6002  			}
  6003  
  6004  			out.Concurrently(i, func() graphql.Marshaler {
  6005  				return rrm(innerCtx)
  6006  			})
  6007  		case "recursive":
  6008  			field := field
  6009  
  6010  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6011  				defer func() {
  6012  					if r := recover(); r != nil {
  6013  						ec.Error(ctx, ec.Recover(ctx, r))
  6014  					}
  6015  				}()
  6016  				res = ec._Query_recursive(ctx, field)
  6017  				return res
  6018  			}
  6019  
  6020  			rrm := func(ctx context.Context) graphql.Marshaler {
  6021  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6022  			}
  6023  
  6024  			out.Concurrently(i, func() graphql.Marshaler {
  6025  				return rrm(innerCtx)
  6026  			})
  6027  		case "nestedInputs":
  6028  			field := field
  6029  
  6030  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6031  				defer func() {
  6032  					if r := recover(); r != nil {
  6033  						ec.Error(ctx, ec.Recover(ctx, r))
  6034  					}
  6035  				}()
  6036  				res = ec._Query_nestedInputs(ctx, field)
  6037  				return res
  6038  			}
  6039  
  6040  			rrm := func(ctx context.Context) graphql.Marshaler {
  6041  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6042  			}
  6043  
  6044  			out.Concurrently(i, func() graphql.Marshaler {
  6045  				return rrm(innerCtx)
  6046  			})
  6047  		case "nestedOutputs":
  6048  			field := field
  6049  
  6050  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6051  				defer func() {
  6052  					if r := recover(); r != nil {
  6053  						ec.Error(ctx, ec.Recover(ctx, r))
  6054  					}
  6055  				}()
  6056  				res = ec._Query_nestedOutputs(ctx, field)
  6057  				return res
  6058  			}
  6059  
  6060  			rrm := func(ctx context.Context) graphql.Marshaler {
  6061  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6062  			}
  6063  
  6064  			out.Concurrently(i, func() graphql.Marshaler {
  6065  				return rrm(innerCtx)
  6066  			})
  6067  		case "modelMethods":
  6068  			field := field
  6069  
  6070  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6071  				defer func() {
  6072  					if r := recover(); r != nil {
  6073  						ec.Error(ctx, ec.Recover(ctx, r))
  6074  					}
  6075  				}()
  6076  				res = ec._Query_modelMethods(ctx, field)
  6077  				return res
  6078  			}
  6079  
  6080  			rrm := func(ctx context.Context) graphql.Marshaler {
  6081  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6082  			}
  6083  
  6084  			out.Concurrently(i, func() graphql.Marshaler {
  6085  				return rrm(innerCtx)
  6086  			})
  6087  		case "user":
  6088  			field := field
  6089  
  6090  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6091  				defer func() {
  6092  					if r := recover(); r != nil {
  6093  						ec.Error(ctx, ec.Recover(ctx, r))
  6094  					}
  6095  				}()
  6096  				res = ec._Query_user(ctx, field)
  6097  				if res == graphql.Null {
  6098  					atomic.AddUint32(&invalids, 1)
  6099  				}
  6100  				return res
  6101  			}
  6102  
  6103  			rrm := func(ctx context.Context) graphql.Marshaler {
  6104  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6105  			}
  6106  
  6107  			out.Concurrently(i, func() graphql.Marshaler {
  6108  				return rrm(innerCtx)
  6109  			})
  6110  		case "nullableArg":
  6111  			field := field
  6112  
  6113  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6114  				defer func() {
  6115  					if r := recover(); r != nil {
  6116  						ec.Error(ctx, ec.Recover(ctx, r))
  6117  					}
  6118  				}()
  6119  				res = ec._Query_nullableArg(ctx, field)
  6120  				return res
  6121  			}
  6122  
  6123  			rrm := func(ctx context.Context) graphql.Marshaler {
  6124  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6125  			}
  6126  
  6127  			out.Concurrently(i, func() graphql.Marshaler {
  6128  				return rrm(innerCtx)
  6129  			})
  6130  		case "inputSlice":
  6131  			field := field
  6132  
  6133  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6134  				defer func() {
  6135  					if r := recover(); r != nil {
  6136  						ec.Error(ctx, ec.Recover(ctx, r))
  6137  					}
  6138  				}()
  6139  				res = ec._Query_inputSlice(ctx, field)
  6140  				if res == graphql.Null {
  6141  					atomic.AddUint32(&invalids, 1)
  6142  				}
  6143  				return res
  6144  			}
  6145  
  6146  			rrm := func(ctx context.Context) graphql.Marshaler {
  6147  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6148  			}
  6149  
  6150  			out.Concurrently(i, func() graphql.Marshaler {
  6151  				return rrm(innerCtx)
  6152  			})
  6153  		case "inputNullableSlice":
  6154  			field := field
  6155  
  6156  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6157  				defer func() {
  6158  					if r := recover(); r != nil {
  6159  						ec.Error(ctx, ec.Recover(ctx, r))
  6160  					}
  6161  				}()
  6162  				res = ec._Query_inputNullableSlice(ctx, field)
  6163  				if res == graphql.Null {
  6164  					atomic.AddUint32(&invalids, 1)
  6165  				}
  6166  				return res
  6167  			}
  6168  
  6169  			rrm := func(ctx context.Context) graphql.Marshaler {
  6170  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6171  			}
  6172  
  6173  			out.Concurrently(i, func() graphql.Marshaler {
  6174  				return rrm(innerCtx)
  6175  			})
  6176  		case "shapeUnion":
  6177  			field := field
  6178  
  6179  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6180  				defer func() {
  6181  					if r := recover(); r != nil {
  6182  						ec.Error(ctx, ec.Recover(ctx, r))
  6183  					}
  6184  				}()
  6185  				res = ec._Query_shapeUnion(ctx, field)
  6186  				if res == graphql.Null {
  6187  					atomic.AddUint32(&invalids, 1)
  6188  				}
  6189  				return res
  6190  			}
  6191  
  6192  			rrm := func(ctx context.Context) graphql.Marshaler {
  6193  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6194  			}
  6195  
  6196  			out.Concurrently(i, func() graphql.Marshaler {
  6197  				return rrm(innerCtx)
  6198  			})
  6199  		case "autobind":
  6200  			field := field
  6201  
  6202  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6203  				defer func() {
  6204  					if r := recover(); r != nil {
  6205  						ec.Error(ctx, ec.Recover(ctx, r))
  6206  					}
  6207  				}()
  6208  				res = ec._Query_autobind(ctx, field)
  6209  				return res
  6210  			}
  6211  
  6212  			rrm := func(ctx context.Context) graphql.Marshaler {
  6213  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6214  			}
  6215  
  6216  			out.Concurrently(i, func() graphql.Marshaler {
  6217  				return rrm(innerCtx)
  6218  			})
  6219  		case "deprecatedField":
  6220  			field := field
  6221  
  6222  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6223  				defer func() {
  6224  					if r := recover(); r != nil {
  6225  						ec.Error(ctx, ec.Recover(ctx, r))
  6226  					}
  6227  				}()
  6228  				res = ec._Query_deprecatedField(ctx, field)
  6229  				if res == graphql.Null {
  6230  					atomic.AddUint32(&invalids, 1)
  6231  				}
  6232  				return res
  6233  			}
  6234  
  6235  			rrm := func(ctx context.Context) graphql.Marshaler {
  6236  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6237  			}
  6238  
  6239  			out.Concurrently(i, func() graphql.Marshaler {
  6240  				return rrm(innerCtx)
  6241  			})
  6242  		case "overlapping":
  6243  			field := field
  6244  
  6245  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6246  				defer func() {
  6247  					if r := recover(); r != nil {
  6248  						ec.Error(ctx, ec.Recover(ctx, r))
  6249  					}
  6250  				}()
  6251  				res = ec._Query_overlapping(ctx, field)
  6252  				return res
  6253  			}
  6254  
  6255  			rrm := func(ctx context.Context) graphql.Marshaler {
  6256  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6257  			}
  6258  
  6259  			out.Concurrently(i, func() graphql.Marshaler {
  6260  				return rrm(innerCtx)
  6261  			})
  6262  		case "defaultParameters":
  6263  			field := field
  6264  
  6265  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6266  				defer func() {
  6267  					if r := recover(); r != nil {
  6268  						ec.Error(ctx, ec.Recover(ctx, r))
  6269  					}
  6270  				}()
  6271  				res = ec._Query_defaultParameters(ctx, field)
  6272  				if res == graphql.Null {
  6273  					atomic.AddUint32(&invalids, 1)
  6274  				}
  6275  				return res
  6276  			}
  6277  
  6278  			rrm := func(ctx context.Context) graphql.Marshaler {
  6279  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6280  			}
  6281  
  6282  			out.Concurrently(i, func() graphql.Marshaler {
  6283  				return rrm(innerCtx)
  6284  			})
  6285  		case "directiveArg":
  6286  			field := field
  6287  
  6288  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6289  				defer func() {
  6290  					if r := recover(); r != nil {
  6291  						ec.Error(ctx, ec.Recover(ctx, r))
  6292  					}
  6293  				}()
  6294  				res = ec._Query_directiveArg(ctx, field)
  6295  				return res
  6296  			}
  6297  
  6298  			rrm := func(ctx context.Context) graphql.Marshaler {
  6299  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6300  			}
  6301  
  6302  			out.Concurrently(i, func() graphql.Marshaler {
  6303  				return rrm(innerCtx)
  6304  			})
  6305  		case "directiveNullableArg":
  6306  			field := field
  6307  
  6308  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6309  				defer func() {
  6310  					if r := recover(); r != nil {
  6311  						ec.Error(ctx, ec.Recover(ctx, r))
  6312  					}
  6313  				}()
  6314  				res = ec._Query_directiveNullableArg(ctx, field)
  6315  				return res
  6316  			}
  6317  
  6318  			rrm := func(ctx context.Context) graphql.Marshaler {
  6319  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6320  			}
  6321  
  6322  			out.Concurrently(i, func() graphql.Marshaler {
  6323  				return rrm(innerCtx)
  6324  			})
  6325  		case "directiveInputNullable":
  6326  			field := field
  6327  
  6328  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6329  				defer func() {
  6330  					if r := recover(); r != nil {
  6331  						ec.Error(ctx, ec.Recover(ctx, r))
  6332  					}
  6333  				}()
  6334  				res = ec._Query_directiveInputNullable(ctx, field)
  6335  				return res
  6336  			}
  6337  
  6338  			rrm := func(ctx context.Context) graphql.Marshaler {
  6339  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6340  			}
  6341  
  6342  			out.Concurrently(i, func() graphql.Marshaler {
  6343  				return rrm(innerCtx)
  6344  			})
  6345  		case "directiveInput":
  6346  			field := field
  6347  
  6348  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6349  				defer func() {
  6350  					if r := recover(); r != nil {
  6351  						ec.Error(ctx, ec.Recover(ctx, r))
  6352  					}
  6353  				}()
  6354  				res = ec._Query_directiveInput(ctx, field)
  6355  				return res
  6356  			}
  6357  
  6358  			rrm := func(ctx context.Context) graphql.Marshaler {
  6359  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6360  			}
  6361  
  6362  			out.Concurrently(i, func() graphql.Marshaler {
  6363  				return rrm(innerCtx)
  6364  			})
  6365  		case "directiveInputType":
  6366  			field := field
  6367  
  6368  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6369  				defer func() {
  6370  					if r := recover(); r != nil {
  6371  						ec.Error(ctx, ec.Recover(ctx, r))
  6372  					}
  6373  				}()
  6374  				res = ec._Query_directiveInputType(ctx, field)
  6375  				return res
  6376  			}
  6377  
  6378  			rrm := func(ctx context.Context) graphql.Marshaler {
  6379  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6380  			}
  6381  
  6382  			out.Concurrently(i, func() graphql.Marshaler {
  6383  				return rrm(innerCtx)
  6384  			})
  6385  		case "directiveObject":
  6386  			field := field
  6387  
  6388  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6389  				defer func() {
  6390  					if r := recover(); r != nil {
  6391  						ec.Error(ctx, ec.Recover(ctx, r))
  6392  					}
  6393  				}()
  6394  				res = ec._Query_directiveObject(ctx, field)
  6395  				return res
  6396  			}
  6397  
  6398  			rrm := func(ctx context.Context) graphql.Marshaler {
  6399  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6400  			}
  6401  
  6402  			out.Concurrently(i, func() graphql.Marshaler {
  6403  				return rrm(innerCtx)
  6404  			})
  6405  		case "directiveObjectWithCustomGoModel":
  6406  			field := field
  6407  
  6408  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6409  				defer func() {
  6410  					if r := recover(); r != nil {
  6411  						ec.Error(ctx, ec.Recover(ctx, r))
  6412  					}
  6413  				}()
  6414  				res = ec._Query_directiveObjectWithCustomGoModel(ctx, field)
  6415  				return res
  6416  			}
  6417  
  6418  			rrm := func(ctx context.Context) graphql.Marshaler {
  6419  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6420  			}
  6421  
  6422  			out.Concurrently(i, func() graphql.Marshaler {
  6423  				return rrm(innerCtx)
  6424  			})
  6425  		case "directiveFieldDef":
  6426  			field := field
  6427  
  6428  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6429  				defer func() {
  6430  					if r := recover(); r != nil {
  6431  						ec.Error(ctx, ec.Recover(ctx, r))
  6432  					}
  6433  				}()
  6434  				res = ec._Query_directiveFieldDef(ctx, field)
  6435  				if res == graphql.Null {
  6436  					atomic.AddUint32(&invalids, 1)
  6437  				}
  6438  				return res
  6439  			}
  6440  
  6441  			rrm := func(ctx context.Context) graphql.Marshaler {
  6442  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6443  			}
  6444  
  6445  			out.Concurrently(i, func() graphql.Marshaler {
  6446  				return rrm(innerCtx)
  6447  			})
  6448  		case "directiveField":
  6449  			field := field
  6450  
  6451  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6452  				defer func() {
  6453  					if r := recover(); r != nil {
  6454  						ec.Error(ctx, ec.Recover(ctx, r))
  6455  					}
  6456  				}()
  6457  				res = ec._Query_directiveField(ctx, field)
  6458  				return res
  6459  			}
  6460  
  6461  			rrm := func(ctx context.Context) graphql.Marshaler {
  6462  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6463  			}
  6464  
  6465  			out.Concurrently(i, func() graphql.Marshaler {
  6466  				return rrm(innerCtx)
  6467  			})
  6468  		case "directiveDouble":
  6469  			field := field
  6470  
  6471  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6472  				defer func() {
  6473  					if r := recover(); r != nil {
  6474  						ec.Error(ctx, ec.Recover(ctx, r))
  6475  					}
  6476  				}()
  6477  				res = ec._Query_directiveDouble(ctx, field)
  6478  				return res
  6479  			}
  6480  
  6481  			rrm := func(ctx context.Context) graphql.Marshaler {
  6482  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6483  			}
  6484  
  6485  			out.Concurrently(i, func() graphql.Marshaler {
  6486  				return rrm(innerCtx)
  6487  			})
  6488  		case "directiveUnimplemented":
  6489  			field := field
  6490  
  6491  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6492  				defer func() {
  6493  					if r := recover(); r != nil {
  6494  						ec.Error(ctx, ec.Recover(ctx, r))
  6495  					}
  6496  				}()
  6497  				res = ec._Query_directiveUnimplemented(ctx, field)
  6498  				return res
  6499  			}
  6500  
  6501  			rrm := func(ctx context.Context) graphql.Marshaler {
  6502  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6503  			}
  6504  
  6505  			out.Concurrently(i, func() graphql.Marshaler {
  6506  				return rrm(innerCtx)
  6507  			})
  6508  		case "embeddedCase1":
  6509  			field := field
  6510  
  6511  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6512  				defer func() {
  6513  					if r := recover(); r != nil {
  6514  						ec.Error(ctx, ec.Recover(ctx, r))
  6515  					}
  6516  				}()
  6517  				res = ec._Query_embeddedCase1(ctx, field)
  6518  				return res
  6519  			}
  6520  
  6521  			rrm := func(ctx context.Context) graphql.Marshaler {
  6522  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6523  			}
  6524  
  6525  			out.Concurrently(i, func() graphql.Marshaler {
  6526  				return rrm(innerCtx)
  6527  			})
  6528  		case "embeddedCase2":
  6529  			field := field
  6530  
  6531  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6532  				defer func() {
  6533  					if r := recover(); r != nil {
  6534  						ec.Error(ctx, ec.Recover(ctx, r))
  6535  					}
  6536  				}()
  6537  				res = ec._Query_embeddedCase2(ctx, field)
  6538  				return res
  6539  			}
  6540  
  6541  			rrm := func(ctx context.Context) graphql.Marshaler {
  6542  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6543  			}
  6544  
  6545  			out.Concurrently(i, func() graphql.Marshaler {
  6546  				return rrm(innerCtx)
  6547  			})
  6548  		case "embeddedCase3":
  6549  			field := field
  6550  
  6551  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6552  				defer func() {
  6553  					if r := recover(); r != nil {
  6554  						ec.Error(ctx, ec.Recover(ctx, r))
  6555  					}
  6556  				}()
  6557  				res = ec._Query_embeddedCase3(ctx, field)
  6558  				return res
  6559  			}
  6560  
  6561  			rrm := func(ctx context.Context) graphql.Marshaler {
  6562  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6563  			}
  6564  
  6565  			out.Concurrently(i, func() graphql.Marshaler {
  6566  				return rrm(innerCtx)
  6567  			})
  6568  		case "enumInInput":
  6569  			field := field
  6570  
  6571  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6572  				defer func() {
  6573  					if r := recover(); r != nil {
  6574  						ec.Error(ctx, ec.Recover(ctx, r))
  6575  					}
  6576  				}()
  6577  				res = ec._Query_enumInInput(ctx, field)
  6578  				if res == graphql.Null {
  6579  					atomic.AddUint32(&invalids, 1)
  6580  				}
  6581  				return res
  6582  			}
  6583  
  6584  			rrm := func(ctx context.Context) graphql.Marshaler {
  6585  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6586  			}
  6587  
  6588  			out.Concurrently(i, func() graphql.Marshaler {
  6589  				return rrm(innerCtx)
  6590  			})
  6591  		case "shapes":
  6592  			field := field
  6593  
  6594  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6595  				defer func() {
  6596  					if r := recover(); r != nil {
  6597  						ec.Error(ctx, ec.Recover(ctx, r))
  6598  					}
  6599  				}()
  6600  				res = ec._Query_shapes(ctx, field)
  6601  				return res
  6602  			}
  6603  
  6604  			rrm := func(ctx context.Context) graphql.Marshaler {
  6605  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6606  			}
  6607  
  6608  			out.Concurrently(i, func() graphql.Marshaler {
  6609  				return rrm(innerCtx)
  6610  			})
  6611  		case "noShape":
  6612  			field := field
  6613  
  6614  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6615  				defer func() {
  6616  					if r := recover(); r != nil {
  6617  						ec.Error(ctx, ec.Recover(ctx, r))
  6618  					}
  6619  				}()
  6620  				res = ec._Query_noShape(ctx, field)
  6621  				return res
  6622  			}
  6623  
  6624  			rrm := func(ctx context.Context) graphql.Marshaler {
  6625  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6626  			}
  6627  
  6628  			out.Concurrently(i, func() graphql.Marshaler {
  6629  				return rrm(innerCtx)
  6630  			})
  6631  		case "node":
  6632  			field := field
  6633  
  6634  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6635  				defer func() {
  6636  					if r := recover(); r != nil {
  6637  						ec.Error(ctx, ec.Recover(ctx, r))
  6638  					}
  6639  				}()
  6640  				res = ec._Query_node(ctx, field)
  6641  				if res == graphql.Null {
  6642  					atomic.AddUint32(&invalids, 1)
  6643  				}
  6644  				return res
  6645  			}
  6646  
  6647  			rrm := func(ctx context.Context) graphql.Marshaler {
  6648  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6649  			}
  6650  
  6651  			out.Concurrently(i, func() graphql.Marshaler {
  6652  				return rrm(innerCtx)
  6653  			})
  6654  		case "noShapeTypedNil":
  6655  			field := field
  6656  
  6657  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6658  				defer func() {
  6659  					if r := recover(); r != nil {
  6660  						ec.Error(ctx, ec.Recover(ctx, r))
  6661  					}
  6662  				}()
  6663  				res = ec._Query_noShapeTypedNil(ctx, field)
  6664  				return res
  6665  			}
  6666  
  6667  			rrm := func(ctx context.Context) graphql.Marshaler {
  6668  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6669  			}
  6670  
  6671  			out.Concurrently(i, func() graphql.Marshaler {
  6672  				return rrm(innerCtx)
  6673  			})
  6674  		case "animal":
  6675  			field := field
  6676  
  6677  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6678  				defer func() {
  6679  					if r := recover(); r != nil {
  6680  						ec.Error(ctx, ec.Recover(ctx, r))
  6681  					}
  6682  				}()
  6683  				res = ec._Query_animal(ctx, field)
  6684  				return res
  6685  			}
  6686  
  6687  			rrm := func(ctx context.Context) graphql.Marshaler {
  6688  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6689  			}
  6690  
  6691  			out.Concurrently(i, func() graphql.Marshaler {
  6692  				return rrm(innerCtx)
  6693  			})
  6694  		case "notAnInterface":
  6695  			field := field
  6696  
  6697  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6698  				defer func() {
  6699  					if r := recover(); r != nil {
  6700  						ec.Error(ctx, ec.Recover(ctx, r))
  6701  					}
  6702  				}()
  6703  				res = ec._Query_notAnInterface(ctx, field)
  6704  				return res
  6705  			}
  6706  
  6707  			rrm := func(ctx context.Context) graphql.Marshaler {
  6708  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6709  			}
  6710  
  6711  			out.Concurrently(i, func() graphql.Marshaler {
  6712  				return rrm(innerCtx)
  6713  			})
  6714  		case "dog":
  6715  			field := field
  6716  
  6717  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6718  				defer func() {
  6719  					if r := recover(); r != nil {
  6720  						ec.Error(ctx, ec.Recover(ctx, r))
  6721  					}
  6722  				}()
  6723  				res = ec._Query_dog(ctx, field)
  6724  				return res
  6725  			}
  6726  
  6727  			rrm := func(ctx context.Context) graphql.Marshaler {
  6728  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6729  			}
  6730  
  6731  			out.Concurrently(i, func() graphql.Marshaler {
  6732  				return rrm(innerCtx)
  6733  			})
  6734  		case "issue896a":
  6735  			field := field
  6736  
  6737  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6738  				defer func() {
  6739  					if r := recover(); r != nil {
  6740  						ec.Error(ctx, ec.Recover(ctx, r))
  6741  					}
  6742  				}()
  6743  				res = ec._Query_issue896a(ctx, field)
  6744  				return res
  6745  			}
  6746  
  6747  			rrm := func(ctx context.Context) graphql.Marshaler {
  6748  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6749  			}
  6750  
  6751  			out.Concurrently(i, func() graphql.Marshaler {
  6752  				return rrm(innerCtx)
  6753  			})
  6754  		case "mapStringInterface":
  6755  			field := field
  6756  
  6757  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6758  				defer func() {
  6759  					if r := recover(); r != nil {
  6760  						ec.Error(ctx, ec.Recover(ctx, r))
  6761  					}
  6762  				}()
  6763  				res = ec._Query_mapStringInterface(ctx, field)
  6764  				return res
  6765  			}
  6766  
  6767  			rrm := func(ctx context.Context) graphql.Marshaler {
  6768  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6769  			}
  6770  
  6771  			out.Concurrently(i, func() graphql.Marshaler {
  6772  				return rrm(innerCtx)
  6773  			})
  6774  		case "mapNestedStringInterface":
  6775  			field := field
  6776  
  6777  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6778  				defer func() {
  6779  					if r := recover(); r != nil {
  6780  						ec.Error(ctx, ec.Recover(ctx, r))
  6781  					}
  6782  				}()
  6783  				res = ec._Query_mapNestedStringInterface(ctx, field)
  6784  				return res
  6785  			}
  6786  
  6787  			rrm := func(ctx context.Context) graphql.Marshaler {
  6788  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6789  			}
  6790  
  6791  			out.Concurrently(i, func() graphql.Marshaler {
  6792  				return rrm(innerCtx)
  6793  			})
  6794  		case "errorBubble":
  6795  			field := field
  6796  
  6797  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6798  				defer func() {
  6799  					if r := recover(); r != nil {
  6800  						ec.Error(ctx, ec.Recover(ctx, r))
  6801  					}
  6802  				}()
  6803  				res = ec._Query_errorBubble(ctx, field)
  6804  				return res
  6805  			}
  6806  
  6807  			rrm := func(ctx context.Context) graphql.Marshaler {
  6808  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6809  			}
  6810  
  6811  			out.Concurrently(i, func() graphql.Marshaler {
  6812  				return rrm(innerCtx)
  6813  			})
  6814  		case "errorBubbleList":
  6815  			field := field
  6816  
  6817  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6818  				defer func() {
  6819  					if r := recover(); r != nil {
  6820  						ec.Error(ctx, ec.Recover(ctx, r))
  6821  					}
  6822  				}()
  6823  				res = ec._Query_errorBubbleList(ctx, field)
  6824  				return res
  6825  			}
  6826  
  6827  			rrm := func(ctx context.Context) graphql.Marshaler {
  6828  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6829  			}
  6830  
  6831  			out.Concurrently(i, func() graphql.Marshaler {
  6832  				return rrm(innerCtx)
  6833  			})
  6834  		case "errorList":
  6835  			field := field
  6836  
  6837  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6838  				defer func() {
  6839  					if r := recover(); r != nil {
  6840  						ec.Error(ctx, ec.Recover(ctx, r))
  6841  					}
  6842  				}()
  6843  				res = ec._Query_errorList(ctx, field)
  6844  				return res
  6845  			}
  6846  
  6847  			rrm := func(ctx context.Context) graphql.Marshaler {
  6848  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6849  			}
  6850  
  6851  			out.Concurrently(i, func() graphql.Marshaler {
  6852  				return rrm(innerCtx)
  6853  			})
  6854  		case "errors":
  6855  			field := field
  6856  
  6857  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6858  				defer func() {
  6859  					if r := recover(); r != nil {
  6860  						ec.Error(ctx, ec.Recover(ctx, r))
  6861  					}
  6862  				}()
  6863  				res = ec._Query_errors(ctx, field)
  6864  				return res
  6865  			}
  6866  
  6867  			rrm := func(ctx context.Context) graphql.Marshaler {
  6868  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6869  			}
  6870  
  6871  			out.Concurrently(i, func() graphql.Marshaler {
  6872  				return rrm(innerCtx)
  6873  			})
  6874  		case "valid":
  6875  			field := field
  6876  
  6877  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6878  				defer func() {
  6879  					if r := recover(); r != nil {
  6880  						ec.Error(ctx, ec.Recover(ctx, r))
  6881  					}
  6882  				}()
  6883  				res = ec._Query_valid(ctx, field)
  6884  				if res == graphql.Null {
  6885  					atomic.AddUint32(&invalids, 1)
  6886  				}
  6887  				return res
  6888  			}
  6889  
  6890  			rrm := func(ctx context.Context) graphql.Marshaler {
  6891  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6892  			}
  6893  
  6894  			out.Concurrently(i, func() graphql.Marshaler {
  6895  				return rrm(innerCtx)
  6896  			})
  6897  		case "panics":
  6898  			field := field
  6899  
  6900  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6901  				defer func() {
  6902  					if r := recover(); r != nil {
  6903  						ec.Error(ctx, ec.Recover(ctx, r))
  6904  					}
  6905  				}()
  6906  				res = ec._Query_panics(ctx, field)
  6907  				return res
  6908  			}
  6909  
  6910  			rrm := func(ctx context.Context) graphql.Marshaler {
  6911  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6912  			}
  6913  
  6914  			out.Concurrently(i, func() graphql.Marshaler {
  6915  				return rrm(innerCtx)
  6916  			})
  6917  		case "primitiveObject":
  6918  			field := field
  6919  
  6920  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6921  				defer func() {
  6922  					if r := recover(); r != nil {
  6923  						ec.Error(ctx, ec.Recover(ctx, r))
  6924  					}
  6925  				}()
  6926  				res = ec._Query_primitiveObject(ctx, field)
  6927  				if res == graphql.Null {
  6928  					atomic.AddUint32(&invalids, 1)
  6929  				}
  6930  				return res
  6931  			}
  6932  
  6933  			rrm := func(ctx context.Context) graphql.Marshaler {
  6934  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6935  			}
  6936  
  6937  			out.Concurrently(i, func() graphql.Marshaler {
  6938  				return rrm(innerCtx)
  6939  			})
  6940  		case "primitiveStringObject":
  6941  			field := field
  6942  
  6943  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6944  				defer func() {
  6945  					if r := recover(); r != nil {
  6946  						ec.Error(ctx, ec.Recover(ctx, r))
  6947  					}
  6948  				}()
  6949  				res = ec._Query_primitiveStringObject(ctx, field)
  6950  				if res == graphql.Null {
  6951  					atomic.AddUint32(&invalids, 1)
  6952  				}
  6953  				return res
  6954  			}
  6955  
  6956  			rrm := func(ctx context.Context) graphql.Marshaler {
  6957  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6958  			}
  6959  
  6960  			out.Concurrently(i, func() graphql.Marshaler {
  6961  				return rrm(innerCtx)
  6962  			})
  6963  		case "ptrToSliceContainer":
  6964  			field := field
  6965  
  6966  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6967  				defer func() {
  6968  					if r := recover(); r != nil {
  6969  						ec.Error(ctx, ec.Recover(ctx, r))
  6970  					}
  6971  				}()
  6972  				res = ec._Query_ptrToSliceContainer(ctx, field)
  6973  				if res == graphql.Null {
  6974  					atomic.AddUint32(&invalids, 1)
  6975  				}
  6976  				return res
  6977  			}
  6978  
  6979  			rrm := func(ctx context.Context) graphql.Marshaler {
  6980  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6981  			}
  6982  
  6983  			out.Concurrently(i, func() graphql.Marshaler {
  6984  				return rrm(innerCtx)
  6985  			})
  6986  		case "infinity":
  6987  			field := field
  6988  
  6989  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6990  				defer func() {
  6991  					if r := recover(); r != nil {
  6992  						ec.Error(ctx, ec.Recover(ctx, r))
  6993  					}
  6994  				}()
  6995  				res = ec._Query_infinity(ctx, field)
  6996  				if res == graphql.Null {
  6997  					atomic.AddUint32(&invalids, 1)
  6998  				}
  6999  				return res
  7000  			}
  7001  
  7002  			rrm := func(ctx context.Context) graphql.Marshaler {
  7003  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7004  			}
  7005  
  7006  			out.Concurrently(i, func() graphql.Marshaler {
  7007  				return rrm(innerCtx)
  7008  			})
  7009  		case "stringFromContextInterface":
  7010  			field := field
  7011  
  7012  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7013  				defer func() {
  7014  					if r := recover(); r != nil {
  7015  						ec.Error(ctx, ec.Recover(ctx, r))
  7016  					}
  7017  				}()
  7018  				res = ec._Query_stringFromContextInterface(ctx, field)
  7019  				if res == graphql.Null {
  7020  					atomic.AddUint32(&invalids, 1)
  7021  				}
  7022  				return res
  7023  			}
  7024  
  7025  			rrm := func(ctx context.Context) graphql.Marshaler {
  7026  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7027  			}
  7028  
  7029  			out.Concurrently(i, func() graphql.Marshaler {
  7030  				return rrm(innerCtx)
  7031  			})
  7032  		case "stringFromContextFunction":
  7033  			field := field
  7034  
  7035  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7036  				defer func() {
  7037  					if r := recover(); r != nil {
  7038  						ec.Error(ctx, ec.Recover(ctx, r))
  7039  					}
  7040  				}()
  7041  				res = ec._Query_stringFromContextFunction(ctx, field)
  7042  				if res == graphql.Null {
  7043  					atomic.AddUint32(&invalids, 1)
  7044  				}
  7045  				return res
  7046  			}
  7047  
  7048  			rrm := func(ctx context.Context) graphql.Marshaler {
  7049  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7050  			}
  7051  
  7052  			out.Concurrently(i, func() graphql.Marshaler {
  7053  				return rrm(innerCtx)
  7054  			})
  7055  		case "defaultScalar":
  7056  			field := field
  7057  
  7058  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7059  				defer func() {
  7060  					if r := recover(); r != nil {
  7061  						ec.Error(ctx, ec.Recover(ctx, r))
  7062  					}
  7063  				}()
  7064  				res = ec._Query_defaultScalar(ctx, field)
  7065  				if res == graphql.Null {
  7066  					atomic.AddUint32(&invalids, 1)
  7067  				}
  7068  				return res
  7069  			}
  7070  
  7071  			rrm := func(ctx context.Context) graphql.Marshaler {
  7072  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7073  			}
  7074  
  7075  			out.Concurrently(i, func() graphql.Marshaler {
  7076  				return rrm(innerCtx)
  7077  			})
  7078  		case "slices":
  7079  			field := field
  7080  
  7081  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7082  				defer func() {
  7083  					if r := recover(); r != nil {
  7084  						ec.Error(ctx, ec.Recover(ctx, r))
  7085  					}
  7086  				}()
  7087  				res = ec._Query_slices(ctx, field)
  7088  				return res
  7089  			}
  7090  
  7091  			rrm := func(ctx context.Context) graphql.Marshaler {
  7092  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7093  			}
  7094  
  7095  			out.Concurrently(i, func() graphql.Marshaler {
  7096  				return rrm(innerCtx)
  7097  			})
  7098  		case "scalarSlice":
  7099  			field := field
  7100  
  7101  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7102  				defer func() {
  7103  					if r := recover(); r != nil {
  7104  						ec.Error(ctx, ec.Recover(ctx, r))
  7105  					}
  7106  				}()
  7107  				res = ec._Query_scalarSlice(ctx, field)
  7108  				if res == graphql.Null {
  7109  					atomic.AddUint32(&invalids, 1)
  7110  				}
  7111  				return res
  7112  			}
  7113  
  7114  			rrm := func(ctx context.Context) graphql.Marshaler {
  7115  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7116  			}
  7117  
  7118  			out.Concurrently(i, func() graphql.Marshaler {
  7119  				return rrm(innerCtx)
  7120  			})
  7121  		case "fallback":
  7122  			field := field
  7123  
  7124  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7125  				defer func() {
  7126  					if r := recover(); r != nil {
  7127  						ec.Error(ctx, ec.Recover(ctx, r))
  7128  					}
  7129  				}()
  7130  				res = ec._Query_fallback(ctx, field)
  7131  				if res == graphql.Null {
  7132  					atomic.AddUint32(&invalids, 1)
  7133  				}
  7134  				return res
  7135  			}
  7136  
  7137  			rrm := func(ctx context.Context) graphql.Marshaler {
  7138  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7139  			}
  7140  
  7141  			out.Concurrently(i, func() graphql.Marshaler {
  7142  				return rrm(innerCtx)
  7143  			})
  7144  		case "optionalUnion":
  7145  			field := field
  7146  
  7147  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7148  				defer func() {
  7149  					if r := recover(); r != nil {
  7150  						ec.Error(ctx, ec.Recover(ctx, r))
  7151  					}
  7152  				}()
  7153  				res = ec._Query_optionalUnion(ctx, field)
  7154  				return res
  7155  			}
  7156  
  7157  			rrm := func(ctx context.Context) graphql.Marshaler {
  7158  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7159  			}
  7160  
  7161  			out.Concurrently(i, func() graphql.Marshaler {
  7162  				return rrm(innerCtx)
  7163  			})
  7164  		case "vOkCaseValue":
  7165  			field := field
  7166  
  7167  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7168  				defer func() {
  7169  					if r := recover(); r != nil {
  7170  						ec.Error(ctx, ec.Recover(ctx, r))
  7171  					}
  7172  				}()
  7173  				res = ec._Query_vOkCaseValue(ctx, field)
  7174  				return res
  7175  			}
  7176  
  7177  			rrm := func(ctx context.Context) graphql.Marshaler {
  7178  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7179  			}
  7180  
  7181  			out.Concurrently(i, func() graphql.Marshaler {
  7182  				return rrm(innerCtx)
  7183  			})
  7184  		case "vOkCaseNil":
  7185  			field := field
  7186  
  7187  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7188  				defer func() {
  7189  					if r := recover(); r != nil {
  7190  						ec.Error(ctx, ec.Recover(ctx, r))
  7191  					}
  7192  				}()
  7193  				res = ec._Query_vOkCaseNil(ctx, field)
  7194  				return res
  7195  			}
  7196  
  7197  			rrm := func(ctx context.Context) graphql.Marshaler {
  7198  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7199  			}
  7200  
  7201  			out.Concurrently(i, func() graphql.Marshaler {
  7202  				return rrm(innerCtx)
  7203  			})
  7204  		case "validType":
  7205  			field := field
  7206  
  7207  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7208  				defer func() {
  7209  					if r := recover(); r != nil {
  7210  						ec.Error(ctx, ec.Recover(ctx, r))
  7211  					}
  7212  				}()
  7213  				res = ec._Query_validType(ctx, field)
  7214  				return res
  7215  			}
  7216  
  7217  			rrm := func(ctx context.Context) graphql.Marshaler {
  7218  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7219  			}
  7220  
  7221  			out.Concurrently(i, func() graphql.Marshaler {
  7222  				return rrm(innerCtx)
  7223  			})
  7224  		case "variadicModel":
  7225  			field := field
  7226  
  7227  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7228  				defer func() {
  7229  					if r := recover(); r != nil {
  7230  						ec.Error(ctx, ec.Recover(ctx, r))
  7231  					}
  7232  				}()
  7233  				res = ec._Query_variadicModel(ctx, field)
  7234  				return res
  7235  			}
  7236  
  7237  			rrm := func(ctx context.Context) graphql.Marshaler {
  7238  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7239  			}
  7240  
  7241  			out.Concurrently(i, func() graphql.Marshaler {
  7242  				return rrm(innerCtx)
  7243  			})
  7244  		case "wrappedStruct":
  7245  			field := field
  7246  
  7247  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7248  				defer func() {
  7249  					if r := recover(); r != nil {
  7250  						ec.Error(ctx, ec.Recover(ctx, r))
  7251  					}
  7252  				}()
  7253  				res = ec._Query_wrappedStruct(ctx, field)
  7254  				if res == graphql.Null {
  7255  					atomic.AddUint32(&invalids, 1)
  7256  				}
  7257  				return res
  7258  			}
  7259  
  7260  			rrm := func(ctx context.Context) graphql.Marshaler {
  7261  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7262  			}
  7263  
  7264  			out.Concurrently(i, func() graphql.Marshaler {
  7265  				return rrm(innerCtx)
  7266  			})
  7267  		case "wrappedScalar":
  7268  			field := field
  7269  
  7270  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7271  				defer func() {
  7272  					if r := recover(); r != nil {
  7273  						ec.Error(ctx, ec.Recover(ctx, r))
  7274  					}
  7275  				}()
  7276  				res = ec._Query_wrappedScalar(ctx, field)
  7277  				if res == graphql.Null {
  7278  					atomic.AddUint32(&invalids, 1)
  7279  				}
  7280  				return res
  7281  			}
  7282  
  7283  			rrm := func(ctx context.Context) graphql.Marshaler {
  7284  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7285  			}
  7286  
  7287  			out.Concurrently(i, func() graphql.Marshaler {
  7288  				return rrm(innerCtx)
  7289  			})
  7290  		case "wrappedMap":
  7291  			field := field
  7292  
  7293  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7294  				defer func() {
  7295  					if r := recover(); r != nil {
  7296  						ec.Error(ctx, ec.Recover(ctx, r))
  7297  					}
  7298  				}()
  7299  				res = ec._Query_wrappedMap(ctx, field)
  7300  				if res == graphql.Null {
  7301  					atomic.AddUint32(&invalids, 1)
  7302  				}
  7303  				return res
  7304  			}
  7305  
  7306  			rrm := func(ctx context.Context) graphql.Marshaler {
  7307  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7308  			}
  7309  
  7310  			out.Concurrently(i, func() graphql.Marshaler {
  7311  				return rrm(innerCtx)
  7312  			})
  7313  		case "wrappedSlice":
  7314  			field := field
  7315  
  7316  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7317  				defer func() {
  7318  					if r := recover(); r != nil {
  7319  						ec.Error(ctx, ec.Recover(ctx, r))
  7320  					}
  7321  				}()
  7322  				res = ec._Query_wrappedSlice(ctx, field)
  7323  				if res == graphql.Null {
  7324  					atomic.AddUint32(&invalids, 1)
  7325  				}
  7326  				return res
  7327  			}
  7328  
  7329  			rrm := func(ctx context.Context) graphql.Marshaler {
  7330  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7331  			}
  7332  
  7333  			out.Concurrently(i, func() graphql.Marshaler {
  7334  				return rrm(innerCtx)
  7335  			})
  7336  		case "__type":
  7337  
  7338  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  7339  				return ec._Query___type(ctx, field)
  7340  			})
  7341  
  7342  		case "__schema":
  7343  
  7344  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  7345  				return ec._Query___schema(ctx, field)
  7346  			})
  7347  
  7348  		default:
  7349  			panic("unknown field " + strconv.Quote(field.Name))
  7350  		}
  7351  	}
  7352  	out.Dispatch()
  7353  	if invalids > 0 {
  7354  		return graphql.Null
  7355  	}
  7356  	return out
  7357  }
  7358  
  7359  var subscriptionImplementors = []string{"Subscription"}
  7360  
  7361  func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func(ctx context.Context) graphql.Marshaler {
  7362  	fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors)
  7363  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  7364  		Object: "Subscription",
  7365  	})
  7366  	if len(fields) != 1 {
  7367  		ec.Errorf(ctx, "must subscribe to exactly one stream")
  7368  		return nil
  7369  	}
  7370  
  7371  	switch fields[0].Name {
  7372  	case "updated":
  7373  		return ec._Subscription_updated(ctx, fields[0])
  7374  	case "initPayload":
  7375  		return ec._Subscription_initPayload(ctx, fields[0])
  7376  	case "directiveArg":
  7377  		return ec._Subscription_directiveArg(ctx, fields[0])
  7378  	case "directiveNullableArg":
  7379  		return ec._Subscription_directiveNullableArg(ctx, fields[0])
  7380  	case "directiveDouble":
  7381  		return ec._Subscription_directiveDouble(ctx, fields[0])
  7382  	case "directiveUnimplemented":
  7383  		return ec._Subscription_directiveUnimplemented(ctx, fields[0])
  7384  	case "issue896b":
  7385  		return ec._Subscription_issue896b(ctx, fields[0])
  7386  	case "errorRequired":
  7387  		return ec._Subscription_errorRequired(ctx, fields[0])
  7388  	default:
  7389  		panic("unknown field " + strconv.Quote(fields[0].Name))
  7390  	}
  7391  }
  7392  
  7393  var userImplementors = []string{"User"}
  7394  
  7395  func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler {
  7396  	fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)
  7397  	out := graphql.NewFieldSet(fields)
  7398  	var invalids uint32
  7399  	for i, field := range fields {
  7400  		switch field.Name {
  7401  		case "__typename":
  7402  			out.Values[i] = graphql.MarshalString("User")
  7403  		case "id":
  7404  
  7405  			out.Values[i] = ec._User_id(ctx, field, obj)
  7406  
  7407  			if out.Values[i] == graphql.Null {
  7408  				atomic.AddUint32(&invalids, 1)
  7409  			}
  7410  		case "friends":
  7411  			field := field
  7412  
  7413  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7414  				defer func() {
  7415  					if r := recover(); r != nil {
  7416  						ec.Error(ctx, ec.Recover(ctx, r))
  7417  					}
  7418  				}()
  7419  				res = ec._User_friends(ctx, field, obj)
  7420  				if res == graphql.Null {
  7421  					atomic.AddUint32(&invalids, 1)
  7422  				}
  7423  				return res
  7424  			}
  7425  
  7426  			out.Concurrently(i, func() graphql.Marshaler {
  7427  				return innerFunc(ctx)
  7428  
  7429  			})
  7430  		case "created":
  7431  
  7432  			out.Values[i] = ec._User_created(ctx, field, obj)
  7433  
  7434  			if out.Values[i] == graphql.Null {
  7435  				atomic.AddUint32(&invalids, 1)
  7436  			}
  7437  		case "updated":
  7438  
  7439  			out.Values[i] = ec._User_updated(ctx, field, obj)
  7440  
  7441  		case "pets":
  7442  			field := field
  7443  
  7444  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7445  				defer func() {
  7446  					if r := recover(); r != nil {
  7447  						ec.Error(ctx, ec.Recover(ctx, r))
  7448  					}
  7449  				}()
  7450  				res = ec._User_pets(ctx, field, obj)
  7451  				return res
  7452  			}
  7453  
  7454  			out.Concurrently(i, func() graphql.Marshaler {
  7455  				return innerFunc(ctx)
  7456  
  7457  			})
  7458  		default:
  7459  			panic("unknown field " + strconv.Quote(field.Name))
  7460  		}
  7461  	}
  7462  	out.Dispatch()
  7463  	if invalids > 0 {
  7464  		return graphql.Null
  7465  	}
  7466  	return out
  7467  }
  7468  
  7469  // endregion **************************** object.gotpl ****************************
  7470  
  7471  // region    ***************************** type.gotpl *****************************
  7472  
  7473  func (ec *executionContext) unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (InnerInput, error) {
  7474  	res, err := ec.unmarshalInputInnerInput(ctx, v)
  7475  	return res, graphql.ErrorOnPath(ctx, err)
  7476  }
  7477  
  7478  func (ec *executionContext) unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (*InnerInput, error) {
  7479  	res, err := ec.unmarshalInputInnerInput(ctx, v)
  7480  	return &res, graphql.ErrorOnPath(ctx, err)
  7481  }
  7482  
  7483  func (ec *executionContext) marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx context.Context, sel ast.SelectionSet, v *InnerObject) graphql.Marshaler {
  7484  	if v == nil {
  7485  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7486  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7487  		}
  7488  		return graphql.Null
  7489  	}
  7490  	return ec._InnerObject(ctx, sel, v)
  7491  }
  7492  
  7493  func (ec *executionContext) marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx context.Context, sel ast.SelectionSet, v *Pet) graphql.Marshaler {
  7494  	if v == nil {
  7495  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7496  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7497  		}
  7498  		return graphql.Null
  7499  	}
  7500  	return ec._Pet(ctx, sel, v)
  7501  }
  7502  
  7503  func (ec *executionContext) unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (RecursiveInputSlice, error) {
  7504  	res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v)
  7505  	return res, graphql.ErrorOnPath(ctx, err)
  7506  }
  7507  
  7508  func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
  7509  	res, err := graphql.UnmarshalTime(v)
  7510  	return res, graphql.ErrorOnPath(ctx, err)
  7511  }
  7512  
  7513  func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
  7514  	res := graphql.MarshalTime(v)
  7515  	if res == graphql.Null {
  7516  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7517  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7518  		}
  7519  	}
  7520  	return res
  7521  }
  7522  
  7523  func (ec *executionContext) unmarshalNUUID2string(ctx context.Context, v interface{}) (string, error) {
  7524  	res, err := graphql.UnmarshalString(v)
  7525  	return res, graphql.ErrorOnPath(ctx, err)
  7526  }
  7527  
  7528  func (ec *executionContext) marshalNUUID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  7529  	res := graphql.MarshalString(v)
  7530  	if res == graphql.Null {
  7531  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7532  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7533  		}
  7534  	}
  7535  	return res
  7536  }
  7537  
  7538  func (ec *executionContext) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler {
  7539  	return ec._User(ctx, sel, &v)
  7540  }
  7541  
  7542  func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*User) graphql.Marshaler {
  7543  	ret := make(graphql.Array, len(v))
  7544  	var wg sync.WaitGroup
  7545  	isLen1 := len(v) == 1
  7546  	if !isLen1 {
  7547  		wg.Add(len(v))
  7548  	}
  7549  	for i := range v {
  7550  		i := i
  7551  		fc := &graphql.FieldContext{
  7552  			Index:  &i,
  7553  			Result: &v[i],
  7554  		}
  7555  		ctx := graphql.WithFieldContext(ctx, fc)
  7556  		f := func(i int) {
  7557  			defer func() {
  7558  				if r := recover(); r != nil {
  7559  					ec.Error(ctx, ec.Recover(ctx, r))
  7560  					ret = nil
  7561  				}
  7562  			}()
  7563  			if !isLen1 {
  7564  				defer wg.Done()
  7565  			}
  7566  			ret[i] = ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, sel, v[i])
  7567  		}
  7568  		if isLen1 {
  7569  			f(i)
  7570  		} else {
  7571  			go f(i)
  7572  		}
  7573  
  7574  	}
  7575  	wg.Wait()
  7576  
  7577  	for _, e := range ret {
  7578  		if e == graphql.Null {
  7579  			return graphql.Null
  7580  		}
  7581  	}
  7582  
  7583  	return ret
  7584  }
  7585  
  7586  func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
  7587  	if v == nil {
  7588  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7589  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7590  		}
  7591  		return graphql.Null
  7592  	}
  7593  	return ec._User(ctx, sel, v)
  7594  }
  7595  
  7596  func (ec *executionContext) marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx context.Context, sel ast.SelectionSet, v *Autobind) graphql.Marshaler {
  7597  	if v == nil {
  7598  		return graphql.Null
  7599  	}
  7600  	return ec._Autobind(ctx, sel, v)
  7601  }
  7602  
  7603  func (ec *executionContext) unmarshalOChanges2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
  7604  	if v == nil {
  7605  		return nil, nil
  7606  	}
  7607  	return v.(map[string]interface{}), nil
  7608  }
  7609  
  7610  func (ec *executionContext) marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx context.Context, sel ast.SelectionSet, v *invalid_packagename.InvalidIdentifier) graphql.Marshaler {
  7611  	if v == nil {
  7612  		return graphql.Null
  7613  	}
  7614  	return ec._InvalidIdentifier(ctx, sel, v)
  7615  }
  7616  
  7617  func (ec *executionContext) marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx context.Context, sel ast.SelectionSet, v *introspection1.It) graphql.Marshaler {
  7618  	if v == nil {
  7619  		return graphql.Null
  7620  	}
  7621  	return ec._It(ctx, sel, v)
  7622  }
  7623  
  7624  func (ec *executionContext) marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx context.Context, sel ast.SelectionSet, v *ModelMethods) graphql.Marshaler {
  7625  	if v == nil {
  7626  		return graphql.Null
  7627  	}
  7628  	return ec._ModelMethods(ctx, sel, v)
  7629  }
  7630  
  7631  func (ec *executionContext) unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([][]*OuterInput, error) {
  7632  	if v == nil {
  7633  		return nil, nil
  7634  	}
  7635  	var vSlice []interface{}
  7636  	if v != nil {
  7637  		vSlice = graphql.CoerceList(v)
  7638  	}
  7639  	var err error
  7640  	res := make([][]*OuterInput, len(vSlice))
  7641  	for i := range vSlice {
  7642  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7643  		res[i], err = ec.unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i])
  7644  		if err != nil {
  7645  			return nil, err
  7646  		}
  7647  	}
  7648  	return res, nil
  7649  }
  7650  
  7651  func (ec *executionContext) unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([]*OuterInput, error) {
  7652  	if v == nil {
  7653  		return nil, nil
  7654  	}
  7655  	var vSlice []interface{}
  7656  	if v != nil {
  7657  		vSlice = graphql.CoerceList(v)
  7658  	}
  7659  	var err error
  7660  	res := make([]*OuterInput, len(vSlice))
  7661  	for i := range vSlice {
  7662  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7663  		res[i], err = ec.unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i])
  7664  		if err != nil {
  7665  			return nil, err
  7666  		}
  7667  	}
  7668  	return res, nil
  7669  }
  7670  
  7671  func (ec *executionContext) unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) (*OuterInput, error) {
  7672  	if v == nil {
  7673  		return nil, nil
  7674  	}
  7675  	res, err := ec.unmarshalInputOuterInput(ctx, v)
  7676  	return &res, graphql.ErrorOnPath(ctx, err)
  7677  }
  7678  
  7679  func (ec *executionContext) marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v [][]*OuterObject) graphql.Marshaler {
  7680  	if v == nil {
  7681  		return graphql.Null
  7682  	}
  7683  	ret := make(graphql.Array, len(v))
  7684  	var wg sync.WaitGroup
  7685  	isLen1 := len(v) == 1
  7686  	if !isLen1 {
  7687  		wg.Add(len(v))
  7688  	}
  7689  	for i := range v {
  7690  		i := i
  7691  		fc := &graphql.FieldContext{
  7692  			Index:  &i,
  7693  			Result: &v[i],
  7694  		}
  7695  		ctx := graphql.WithFieldContext(ctx, fc)
  7696  		f := func(i int) {
  7697  			defer func() {
  7698  				if r := recover(); r != nil {
  7699  					ec.Error(ctx, ec.Recover(ctx, r))
  7700  					ret = nil
  7701  				}
  7702  			}()
  7703  			if !isLen1 {
  7704  				defer wg.Done()
  7705  			}
  7706  			ret[i] = ec.marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i])
  7707  		}
  7708  		if isLen1 {
  7709  			f(i)
  7710  		} else {
  7711  			go f(i)
  7712  		}
  7713  
  7714  	}
  7715  	wg.Wait()
  7716  
  7717  	return ret
  7718  }
  7719  
  7720  func (ec *executionContext) marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v []*OuterObject) graphql.Marshaler {
  7721  	if v == nil {
  7722  		return graphql.Null
  7723  	}
  7724  	ret := make(graphql.Array, len(v))
  7725  	var wg sync.WaitGroup
  7726  	isLen1 := len(v) == 1
  7727  	if !isLen1 {
  7728  		wg.Add(len(v))
  7729  	}
  7730  	for i := range v {
  7731  		i := i
  7732  		fc := &graphql.FieldContext{
  7733  			Index:  &i,
  7734  			Result: &v[i],
  7735  		}
  7736  		ctx := graphql.WithFieldContext(ctx, fc)
  7737  		f := func(i int) {
  7738  			defer func() {
  7739  				if r := recover(); r != nil {
  7740  					ec.Error(ctx, ec.Recover(ctx, r))
  7741  					ret = nil
  7742  				}
  7743  			}()
  7744  			if !isLen1 {
  7745  				defer wg.Done()
  7746  			}
  7747  			ret[i] = ec.marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i])
  7748  		}
  7749  		if isLen1 {
  7750  			f(i)
  7751  		} else {
  7752  			go f(i)
  7753  		}
  7754  
  7755  	}
  7756  	wg.Wait()
  7757  
  7758  	return ret
  7759  }
  7760  
  7761  func (ec *executionContext) marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v *OuterObject) graphql.Marshaler {
  7762  	if v == nil {
  7763  		return graphql.Null
  7764  	}
  7765  	return ec._OuterObject(ctx, sel, v)
  7766  }
  7767  
  7768  func (ec *executionContext) marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx context.Context, sel ast.SelectionSet, v []*Pet) graphql.Marshaler {
  7769  	if v == nil {
  7770  		return graphql.Null
  7771  	}
  7772  	ret := make(graphql.Array, len(v))
  7773  	var wg sync.WaitGroup
  7774  	isLen1 := len(v) == 1
  7775  	if !isLen1 {
  7776  		wg.Add(len(v))
  7777  	}
  7778  	for i := range v {
  7779  		i := i
  7780  		fc := &graphql.FieldContext{
  7781  			Index:  &i,
  7782  			Result: &v[i],
  7783  		}
  7784  		ctx := graphql.WithFieldContext(ctx, fc)
  7785  		f := func(i int) {
  7786  			defer func() {
  7787  				if r := recover(); r != nil {
  7788  					ec.Error(ctx, ec.Recover(ctx, r))
  7789  					ret = nil
  7790  				}
  7791  			}()
  7792  			if !isLen1 {
  7793  				defer wg.Done()
  7794  			}
  7795  			ret[i] = ec.marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx, sel, v[i])
  7796  		}
  7797  		if isLen1 {
  7798  			f(i)
  7799  		} else {
  7800  			go f(i)
  7801  		}
  7802  
  7803  	}
  7804  	wg.Wait()
  7805  
  7806  	for _, e := range ret {
  7807  		if e == graphql.Null {
  7808  			return graphql.Null
  7809  		}
  7810  	}
  7811  
  7812  	return ret
  7813  }
  7814  
  7815  func (ec *executionContext) unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx context.Context, v interface{}) ([]RecursiveInputSlice, error) {
  7816  	if v == nil {
  7817  		return nil, nil
  7818  	}
  7819  	var vSlice []interface{}
  7820  	if v != nil {
  7821  		vSlice = graphql.CoerceList(v)
  7822  	}
  7823  	var err error
  7824  	res := make([]RecursiveInputSlice, len(vSlice))
  7825  	for i := range vSlice {
  7826  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7827  		res[i], err = ec.unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, vSlice[i])
  7828  		if err != nil {
  7829  			return nil, err
  7830  		}
  7831  	}
  7832  	return res, nil
  7833  }
  7834  
  7835  func (ec *executionContext) unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (*RecursiveInputSlice, error) {
  7836  	if v == nil {
  7837  		return nil, nil
  7838  	}
  7839  	res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v)
  7840  	return &res, graphql.ErrorOnPath(ctx, err)
  7841  }
  7842  
  7843  func (ec *executionContext) unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, v interface{}) (*ThirdParty, error) {
  7844  	if v == nil {
  7845  		return nil, nil
  7846  	}
  7847  	res, err := UnmarshalThirdParty(v)
  7848  	return &res, graphql.ErrorOnPath(ctx, err)
  7849  }
  7850  
  7851  func (ec *executionContext) marshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, sel ast.SelectionSet, v *ThirdParty) graphql.Marshaler {
  7852  	if v == nil {
  7853  		return graphql.Null
  7854  	}
  7855  	res := MarshalThirdParty(*v)
  7856  	return res
  7857  }
  7858  
  7859  func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
  7860  	if v == nil {
  7861  		return nil, nil
  7862  	}
  7863  	res, err := graphql.UnmarshalTime(v)
  7864  	return &res, graphql.ErrorOnPath(ctx, err)
  7865  }
  7866  
  7867  func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
  7868  	if v == nil {
  7869  		return graphql.Null
  7870  	}
  7871  	res := graphql.MarshalTime(*v)
  7872  	return res
  7873  }
  7874  
  7875  // endregion ***************************** type.gotpl *****************************