diff --git a/codegen/field.gotpl b/codegen/field.gotpl index 431028e097d..993625b7419 100644 --- a/codegen/field.gotpl +++ b/codegen/field.gotpl @@ -5,20 +5,19 @@ func (ec *executionContext) _{{$object.Name}}_{{$field.Name}}(ctx context.Contex {{- if $object.Stream }} {{- $null = "nil" }} {{- end }} - fc := &graphql.FieldContext{ - Object: {{$object.Name|quote}}, - Field: field, - Args: nil, - IsMethod: {{or $field.IsMethod $field.IsResolver}}, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func () { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = {{ $null }} } }() + fc := &graphql.FieldContext{ + Object: {{$object.Name|quote}}, + Field: field, + Args: nil, + IsMethod: {{or $field.IsMethod $field.IsResolver}}, + } + ctx = graphql.WithFieldContext(ctx, fc) {{- if $field.Args }} rawArgs := field.ArgumentMap(ec.Variables) @@ -29,7 +28,6 @@ func (ec *executionContext) _{{$object.Name}}_{{$field.Name}}(ctx context.Contex } fc.Args = args {{- end }} - fc.Stats.ArgumentsCompleted = graphql.Now() {{- if $.Directives.LocationDirectives "FIELD" }} resTmp := ec._fieldMiddleware(ctx, {{if $object.Root}}nil{{else}}obj{{end}}, func(rctx context.Context) (interface{}, error) { {{ template "field" $field }} diff --git a/codegen/object.gotpl b/codegen/object.gotpl index 8dfef7c6fa7..33775a0b4c3 100644 --- a/codegen/object.gotpl +++ b/codegen/object.gotpl @@ -7,7 +7,6 @@ func (ec *executionContext) _{{$object.Name}}(ctx context.Context, sel ast.Selec fields := graphql.CollectFields(ec.OperationContext, sel, {{$object.Name|lcFirst}}Implementors) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: {{$object.Name|quote}}, - Stats: graphql.FieldStats{Started: graphql.Now()}, }) if len(fields) != 1 { ec.Errorf(ctx, "must subscribe to exactly one stream") @@ -29,7 +28,6 @@ func (ec *executionContext) _{{$object.Name}}(ctx context.Context, sel ast.Selec {{if $object.Root}} ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: {{$object.Name|quote}}, - Stats: graphql.FieldStats{Started: graphql.Now()}, }) {{end}} diff --git a/codegen/testserver/generated.go b/codegen/testserver/generated.go index 1fdb4601fc8..932f2ad61d7 100644 --- a/codegen/testserver/generated.go +++ b/codegen/testserver/generated.go @@ -2714,22 +2714,20 @@ func (ec *executionContext) _fieldMiddleware(ctx context.Context, obj interface{ // region **************************** field.gotpl ***************************** func (ec *executionContext) _A_id(ctx context.Context, field graphql.CollectedField, obj *A) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "A", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "A", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -2747,22 +2745,20 @@ func (ec *executionContext) _A_id(ctx context.Context, field graphql.CollectedFi } func (ec *executionContext) _AIt_id(ctx context.Context, field graphql.CollectedField, obj *AIt) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "AIt", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "AIt", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -2780,22 +2776,20 @@ func (ec *executionContext) _AIt_id(ctx context.Context, field graphql.Collected } func (ec *executionContext) _AbIt_id(ctx context.Context, field graphql.CollectedField, obj *AbIt) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "AbIt", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "AbIt", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -2813,22 +2807,20 @@ func (ec *executionContext) _AbIt_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _Autobind_int(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Autobind", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Autobind", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Int, nil @@ -2846,22 +2838,20 @@ func (ec *executionContext) _Autobind_int(ctx context.Context, field graphql.Col } func (ec *executionContext) _Autobind_int32(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Autobind", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Autobind", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Int32, nil @@ -2879,22 +2869,20 @@ func (ec *executionContext) _Autobind_int32(ctx context.Context, field graphql.C } func (ec *executionContext) _Autobind_int64(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Autobind", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Autobind", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Int64, nil @@ -2912,22 +2900,20 @@ func (ec *executionContext) _Autobind_int64(ctx context.Context, field graphql.C } func (ec *executionContext) _Autobind_idStr(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Autobind", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Autobind", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IdStr, nil @@ -2945,22 +2931,20 @@ func (ec *executionContext) _Autobind_idStr(ctx context.Context, field graphql.C } func (ec *executionContext) _Autobind_idInt(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Autobind", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Autobind", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IdInt, nil @@ -2978,22 +2962,20 @@ func (ec *executionContext) _Autobind_idInt(ctx context.Context, field graphql.C } func (ec *executionContext) _B_id(ctx context.Context, field graphql.CollectedField, obj *B) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "B", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "B", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3011,22 +2993,20 @@ func (ec *executionContext) _B_id(ctx context.Context, field graphql.CollectedFi } func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Circle", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Circle", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Radius, nil @@ -3041,22 +3021,20 @@ func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.Co } func (ec *executionContext) _Circle_area(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Circle", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Circle", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Area(), nil @@ -3071,22 +3049,20 @@ func (ec *executionContext) _Circle_area(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Content_Post_foo(ctx context.Context, field graphql.CollectedField, obj *ContentPost) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Content_Post", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Content_Post", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Foo, nil @@ -3101,22 +3077,20 @@ func (ec *executionContext) _Content_Post_foo(ctx context.Context, field graphql } func (ec *executionContext) _Content_User_foo(ctx context.Context, field graphql.CollectedField, obj *ContentUser) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Content_User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Content_User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Foo, nil @@ -3131,22 +3105,20 @@ func (ec *executionContext) _Content_User_foo(ctx context.Context, field graphql } func (ec *executionContext) _EmbeddedDefaultScalar_value(ctx context.Context, field graphql.CollectedField, obj *EmbeddedDefaultScalar) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "EmbeddedDefaultScalar", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "EmbeddedDefaultScalar", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Value, nil @@ -3161,22 +3133,20 @@ func (ec *executionContext) _EmbeddedDefaultScalar_value(ctx context.Context, fi } func (ec *executionContext) _EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "EmbeddedPointer", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "EmbeddedPointer", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3191,22 +3161,20 @@ func (ec *executionContext) _EmbeddedPointer_ID(ctx context.Context, field graph } func (ec *executionContext) _EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "EmbeddedPointer", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "EmbeddedPointer", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Title, nil @@ -3221,22 +3189,20 @@ func (ec *executionContext) _EmbeddedPointer_Title(ctx context.Context, field gr } func (ec *executionContext) _Error_id(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Error", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Error", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3254,22 +3220,20 @@ func (ec *executionContext) _Error_id(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Error_errorOnNonRequiredField(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Error", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Error", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ErrorOnNonRequiredField() @@ -3284,22 +3248,20 @@ func (ec *executionContext) _Error_errorOnNonRequiredField(ctx context.Context, } func (ec *executionContext) _Error_errorOnRequiredField(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Error", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Error", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ErrorOnRequiredField() @@ -3317,22 +3279,20 @@ func (ec *executionContext) _Error_errorOnRequiredField(ctx context.Context, fie } func (ec *executionContext) _Error_nilOnRequiredField(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Error", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Error", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.NilOnRequiredField(), nil @@ -3347,25 +3307,23 @@ func (ec *executionContext) _Error_nilOnRequiredField(ctx context.Context, field res := resTmp.(*string) fc.Result = res return ec.marshalNString2ᚖstring(ctx, field.Selections, res) -} - -func (ec *executionContext) _Errors_a(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Errors", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } +} + +func (ec *executionContext) _Errors_a(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) { defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Errors", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Errors().A(rctx, obj) @@ -3383,22 +3341,20 @@ func (ec *executionContext) _Errors_a(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Errors_b(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Errors", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Errors", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Errors().B(rctx, obj) @@ -3416,22 +3372,20 @@ func (ec *executionContext) _Errors_b(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Errors_c(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Errors", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Errors", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Errors().C(rctx, obj) @@ -3449,22 +3403,20 @@ func (ec *executionContext) _Errors_c(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Errors_d(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Errors", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Errors", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Errors().D(rctx, obj) @@ -3482,22 +3434,20 @@ func (ec *executionContext) _Errors_d(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Errors_e(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Errors", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Errors", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Errors().E(rctx, obj) @@ -3515,22 +3465,20 @@ func (ec *executionContext) _Errors_e(ctx context.Context, field graphql.Collect } func (ec *executionContext) _ForcedResolver_field(ctx context.Context, field graphql.CollectedField, obj *ForcedResolver) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ForcedResolver", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ForcedResolver", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.ForcedResolver().Field(rctx, obj) @@ -3545,22 +3493,20 @@ func (ec *executionContext) _ForcedResolver_field(ctx context.Context, field gra } func (ec *executionContext) _InnerObject_id(ctx context.Context, field graphql.CollectedField, obj *InnerObject) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "InnerObject", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "InnerObject", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3578,22 +3524,20 @@ func (ec *executionContext) _InnerObject_id(ctx context.Context, field graphql.C } func (ec *executionContext) _InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField, obj *invalid_packagename.InvalidIdentifier) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "InvalidIdentifier", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "InvalidIdentifier", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3611,22 +3555,20 @@ func (ec *executionContext) _InvalidIdentifier_id(ctx context.Context, field gra } func (ec *executionContext) _It_id(ctx context.Context, field graphql.CollectedField, obj *introspection1.It) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "It", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "It", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3644,22 +3586,20 @@ func (ec *executionContext) _It_id(ctx context.Context, field graphql.CollectedF } func (ec *executionContext) _LoopA_b(ctx context.Context, field graphql.CollectedField, obj *LoopA) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "LoopA", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "LoopA", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.B, nil @@ -3677,22 +3617,20 @@ func (ec *executionContext) _LoopA_b(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _LoopB_a(ctx context.Context, field graphql.CollectedField, obj *LoopB) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "LoopB", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "LoopB", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.A, nil @@ -3710,22 +3648,20 @@ func (ec *executionContext) _LoopB_a(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _Map_id(ctx context.Context, field graphql.CollectedField, obj *Map) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Map", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Map", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -3743,22 +3679,20 @@ func (ec *executionContext) _Map_id(ctx context.Context, field graphql.Collected } func (ec *executionContext) _MapStringInterfaceType_a(ctx context.Context, field graphql.CollectedField, obj map[string]interface{}) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MapStringInterfaceType", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MapStringInterfaceType", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children switch v := obj["a"].(type) { @@ -3782,22 +3716,20 @@ func (ec *executionContext) _MapStringInterfaceType_a(ctx context.Context, field } func (ec *executionContext) _MapStringInterfaceType_b(ctx context.Context, field graphql.CollectedField, obj map[string]interface{}) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MapStringInterfaceType", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MapStringInterfaceType", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children switch v := obj["b"].(type) { @@ -3821,22 +3753,20 @@ func (ec *executionContext) _MapStringInterfaceType_b(ctx context.Context, field } func (ec *executionContext) _ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ModelMethods", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ModelMethods", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.ModelMethods().ResolverField(rctx, obj) @@ -3854,22 +3784,20 @@ func (ec *executionContext) _ModelMethods_resolverField(ctx context.Context, fie } func (ec *executionContext) _ModelMethods_noContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ModelMethods", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ModelMethods", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.NoContext(), nil @@ -3887,22 +3815,20 @@ func (ec *executionContext) _ModelMethods_noContext(ctx context.Context, field g } func (ec *executionContext) _ModelMethods_withContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ModelMethods", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ModelMethods", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.WithContext(ctx), nil @@ -3920,22 +3846,20 @@ func (ec *executionContext) _ModelMethods_withContext(ctx context.Context, field } func (ec *executionContext) _ObjectDirectives_text(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectives) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ObjectDirectives", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ObjectDirectives", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -3985,22 +3909,20 @@ func (ec *executionContext) _ObjectDirectives_text(ctx context.Context, field gr } func (ec *executionContext) _ObjectDirectives_nullableText(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectives) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ObjectDirectives", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ObjectDirectives", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -4035,22 +3957,20 @@ func (ec *executionContext) _ObjectDirectives_nullableText(ctx context.Context, } func (ec *executionContext) _ObjectDirectivesWithCustomGoModel_nullableText(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectivesWithCustomGoModel) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ObjectDirectivesWithCustomGoModel", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ObjectDirectivesWithCustomGoModel", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -4085,22 +4005,20 @@ func (ec *executionContext) _ObjectDirectivesWithCustomGoModel_nullableText(ctx } func (ec *executionContext) _OuterObject_inner(ctx context.Context, field graphql.CollectedField, obj *OuterObject) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "OuterObject", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "OuterObject", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Inner, nil @@ -4118,22 +4036,20 @@ func (ec *executionContext) _OuterObject_inner(ctx context.Context, field graphq } func (ec *executionContext) _OverlappingFields_oneFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "OverlappingFields", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "OverlappingFields", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Foo, nil @@ -4151,22 +4067,20 @@ func (ec *executionContext) _OverlappingFields_oneFoo(ctx context.Context, field } func (ec *executionContext) _OverlappingFields_twoFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "OverlappingFields", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "OverlappingFields", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Foo, nil @@ -4184,22 +4098,20 @@ func (ec *executionContext) _OverlappingFields_twoFoo(ctx context.Context, field } func (ec *executionContext) _OverlappingFields_oldFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "OverlappingFields", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "OverlappingFields", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.OverlappingFields().OldFoo(rctx, obj) @@ -4217,22 +4129,20 @@ func (ec *executionContext) _OverlappingFields_oldFoo(ctx context.Context, field } func (ec *executionContext) _OverlappingFields_newFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "OverlappingFields", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "OverlappingFields", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.NewFoo, nil @@ -4250,22 +4160,20 @@ func (ec *executionContext) _OverlappingFields_newFoo(ctx context.Context, field } func (ec *executionContext) _OverlappingFields_new_foo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "OverlappingFields", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "OverlappingFields", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.NewFoo, nil @@ -4283,22 +4191,20 @@ func (ec *executionContext) _OverlappingFields_new_foo(ctx context.Context, fiel } func (ec *executionContext) _Panics_fieldScalarMarshal(ctx context.Context, field graphql.CollectedField, obj *Panics) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Panics", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Panics", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Panics().FieldScalarMarshal(rctx, obj) @@ -4316,20 +4222,19 @@ func (ec *executionContext) _Panics_fieldScalarMarshal(ctx context.Context, fiel } func (ec *executionContext) _Panics_fieldFuncMarshal(ctx context.Context, field graphql.CollectedField, obj *Panics) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Panics", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Panics", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Panics_fieldFuncMarshal_args(ctx, rawArgs) @@ -4338,7 +4243,6 @@ func (ec *executionContext) _Panics_fieldFuncMarshal(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.FieldFuncMarshal(ctx, args["u"].([]MarshalPanic)), nil @@ -4356,20 +4260,19 @@ func (ec *executionContext) _Panics_fieldFuncMarshal(ctx context.Context, field } func (ec *executionContext) _Panics_argUnmarshal(ctx context.Context, field graphql.CollectedField, obj *Panics) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Panics", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Panics", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Panics_argUnmarshal_args(ctx, rawArgs) @@ -4378,7 +4281,6 @@ func (ec *executionContext) _Panics_argUnmarshal(ctx context.Context, field grap return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Panics().ArgUnmarshal(rctx, obj, args["u"].([]MarshalPanic)) @@ -4396,22 +4298,20 @@ func (ec *executionContext) _Panics_argUnmarshal(ctx context.Context, field grap } func (ec *executionContext) _Primitive_value(ctx context.Context, field graphql.CollectedField, obj *Primitive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Primitive", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Primitive", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Primitive().Value(rctx, obj) @@ -4429,22 +4329,20 @@ func (ec *executionContext) _Primitive_value(ctx context.Context, field graphql. } func (ec *executionContext) _Primitive_squared(ctx context.Context, field graphql.CollectedField, obj *Primitive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Primitive", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Primitive", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Squared(), nil @@ -4462,22 +4360,20 @@ func (ec *executionContext) _Primitive_squared(ctx context.Context, field graphq } func (ec *executionContext) _PrimitiveString_value(ctx context.Context, field graphql.CollectedField, obj *PrimitiveString) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "PrimitiveString", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "PrimitiveString", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.PrimitiveString().Value(rctx, obj) @@ -4495,22 +4391,20 @@ func (ec *executionContext) _PrimitiveString_value(ctx context.Context, field gr } func (ec *executionContext) _PrimitiveString_doubled(ctx context.Context, field graphql.CollectedField, obj *PrimitiveString) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "PrimitiveString", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "PrimitiveString", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Doubled(), nil @@ -4528,22 +4422,20 @@ func (ec *executionContext) _PrimitiveString_doubled(ctx context.Context, field } func (ec *executionContext) _PrimitiveString_len(ctx context.Context, field graphql.CollectedField, obj *PrimitiveString) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "PrimitiveString", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "PrimitiveString", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.PrimitiveString().Len(rctx, obj) @@ -4561,22 +4453,20 @@ func (ec *executionContext) _PrimitiveString_len(ctx context.Context, field grap } func (ec *executionContext) _Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().InvalidIdentifier(rctx) @@ -4591,22 +4481,20 @@ func (ec *executionContext) _Query_invalidIdentifier(ctx context.Context, field } func (ec *executionContext) _Query_collision(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Collision(rctx) @@ -4621,20 +4509,19 @@ func (ec *executionContext) _Query_collision(ctx context.Context, field graphql. } func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_mapInput_args(ctx, rawArgs) @@ -4643,7 +4530,6 @@ func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.C return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().MapInput(rctx, args["input"].(map[string]interface{})) @@ -4658,20 +4544,19 @@ func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.C } func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_recursive_args(ctx, rawArgs) @@ -4680,7 +4565,6 @@ func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql. return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Recursive(rctx, args["input"].(*RecursiveInputSlice)) @@ -4695,20 +4579,19 @@ func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql. } func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_nestedInputs_args(ctx, rawArgs) @@ -4717,7 +4600,6 @@ func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graph return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().NestedInputs(rctx, args["input"].([][]*OuterInput)) @@ -4730,24 +4612,22 @@ func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graph fc.Result = res return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res) } - -func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } + +func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().NestedOutputs(rctx) @@ -4762,22 +4642,20 @@ func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field grap } func (ec *executionContext) _Query_modelMethods(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().ModelMethods(rctx) @@ -4792,20 +4670,19 @@ func (ec *executionContext) _Query_modelMethods(ctx context.Context, field graph } func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_user_args(ctx, rawArgs) @@ -4814,7 +4691,6 @@ func (ec *executionContext) _Query_user(ctx context.Context, field graphql.Colle return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().User(rctx, args["id"].(int)) @@ -4832,20 +4708,19 @@ func (ec *executionContext) _Query_user(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_nullableArg_args(ctx, rawArgs) @@ -4854,7 +4729,6 @@ func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().NullableArg(rctx, args["arg"].(*int)) @@ -4869,20 +4743,19 @@ func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphq } func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_inputSlice_args(ctx, rawArgs) @@ -4891,7 +4764,6 @@ func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().InputSlice(rctx, args["arg"].([]string)) @@ -4909,22 +4781,20 @@ func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql } func (ec *executionContext) _Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().ShapeUnion(rctx) @@ -4942,22 +4812,20 @@ func (ec *executionContext) _Query_shapeUnion(ctx context.Context, field graphql } func (ec *executionContext) _Query_autobind(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Autobind(rctx) @@ -4972,22 +4840,20 @@ func (ec *executionContext) _Query_autobind(ctx context.Context, field graphql.C } func (ec *executionContext) _Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DeprecatedField(rctx) @@ -5005,22 +4871,20 @@ func (ec *executionContext) _Query_deprecatedField(ctx context.Context, field gr } func (ec *executionContext) _Query_overlapping(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Overlapping(rctx) @@ -5035,20 +4899,19 @@ func (ec *executionContext) _Query_overlapping(ctx context.Context, field graphq } func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_directiveArg_args(ctx, rawArgs) @@ -5057,7 +4920,6 @@ func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graph return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveArg(rctx, args["arg"].(string)) @@ -5072,20 +4934,19 @@ func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graph } func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_directiveNullableArg_args(ctx, rawArgs) @@ -5094,7 +4955,6 @@ func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, fie return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveNullableArg(rctx, args["arg"].(*int), args["arg2"].(*int), args["arg3"].(*string)) @@ -5109,20 +4969,19 @@ func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, fie } func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_directiveInputNullable_args(ctx, rawArgs) @@ -5131,7 +4990,6 @@ func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, f return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveInputNullable(rctx, args["arg"].(*InputDirectives)) @@ -5146,20 +5004,19 @@ func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, f } func (ec *executionContext) _Query_directiveInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_directiveInput_args(ctx, rawArgs) @@ -5168,7 +5025,6 @@ func (ec *executionContext) _Query_directiveInput(ctx context.Context, field gra return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveInput(rctx, args["arg"].(InputDirectives)) @@ -5183,20 +5039,19 @@ func (ec *executionContext) _Query_directiveInput(ctx context.Context, field gra } func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_directiveInputType_args(ctx, rawArgs) @@ -5205,7 +5060,6 @@ func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveInputType(rctx, args["arg"].(InnerInput)) @@ -5220,22 +5074,20 @@ func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field } func (ec *executionContext) _Query_directiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveObject(rctx) @@ -5250,22 +5102,20 @@ func (ec *executionContext) _Query_directiveObject(ctx context.Context, field gr } func (ec *executionContext) _Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveObjectWithCustomGoModel(rctx) @@ -5280,20 +5130,19 @@ func (ec *executionContext) _Query_directiveObjectWithCustomGoModel(ctx context. } func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_directiveFieldDef_args(ctx, rawArgs) @@ -5302,7 +5151,6 @@ func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -5348,22 +5196,20 @@ func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field } func (ec *executionContext) _Query_directiveField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DirectiveField(rctx) @@ -5378,22 +5224,20 @@ func (ec *executionContext) _Query_directiveField(ctx context.Context, field gra } func (ec *executionContext) _Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -5434,22 +5278,20 @@ func (ec *executionContext) _Query_directiveDouble(ctx context.Context, field gr } func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -5484,22 +5326,20 @@ func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, f } func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Shapes(rctx) @@ -5514,22 +5354,20 @@ func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query_noShape(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -5564,20 +5402,19 @@ func (ec *executionContext) _Query_noShape(ctx context.Context, field graphql.Co } func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_mapStringInterface_args(ctx, rawArgs) @@ -5586,7 +5423,6 @@ func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().MapStringInterface(rctx, args["in"].(map[string]interface{})) @@ -5601,20 +5437,19 @@ func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field } func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_mapNestedStringInterface_args(ctx, rawArgs) @@ -5623,7 +5458,6 @@ func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().MapNestedStringInterface(rctx, args["in"].(*NestedMapInput)) @@ -5638,22 +5472,20 @@ func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, } func (ec *executionContext) _Query_errorBubble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().ErrorBubble(rctx) @@ -5668,22 +5500,20 @@ func (ec *executionContext) _Query_errorBubble(ctx context.Context, field graphq } func (ec *executionContext) _Query_errors(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Errors(rctx) @@ -5698,22 +5528,20 @@ func (ec *executionContext) _Query_errors(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query_valid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Valid(rctx) @@ -5731,22 +5559,20 @@ func (ec *executionContext) _Query_valid(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query_panics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Panics(rctx) @@ -5761,22 +5587,20 @@ func (ec *executionContext) _Query_panics(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().PrimitiveObject(rctx) @@ -5794,22 +5618,20 @@ func (ec *executionContext) _Query_primitiveObject(ctx context.Context, field gr } func (ec *executionContext) _Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().PrimitiveStringObject(rctx) @@ -5827,20 +5649,19 @@ func (ec *executionContext) _Query_primitiveStringObject(ctx context.Context, fi } func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_defaultScalar_args(ctx, rawArgs) @@ -5849,7 +5670,6 @@ func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field grap return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().DefaultScalar(rctx, args["arg"].(string)) @@ -5867,22 +5687,20 @@ func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field grap } func (ec *executionContext) _Query_slices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Slices(rctx) @@ -5897,22 +5715,20 @@ func (ec *executionContext) _Query_slices(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().ScalarSlice(rctx) @@ -5930,20 +5746,19 @@ func (ec *executionContext) _Query_scalarSlice(ctx context.Context, field graphq } func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_fallback_args(ctx, rawArgs) @@ -5952,7 +5767,6 @@ func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.C return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Fallback(rctx, args["arg"].(FallbackToStringEncoding)) @@ -5970,22 +5784,20 @@ func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.C } func (ec *executionContext) _Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().OptionalUnion(rctx) @@ -6000,22 +5812,20 @@ func (ec *executionContext) _Query_optionalUnion(ctx context.Context, field grap } func (ec *executionContext) _Query_validType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().ValidType(rctx) @@ -6030,22 +5840,20 @@ func (ec *executionContext) _Query_validType(ctx context.Context, field graphql. } func (ec *executionContext) _Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().WrappedStruct(rctx) @@ -6063,22 +5871,20 @@ func (ec *executionContext) _Query_wrappedStruct(ctx context.Context, field grap } func (ec *executionContext) _Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().WrappedScalar(rctx) @@ -6096,20 +5902,19 @@ func (ec *executionContext) _Query_wrappedScalar(ctx context.Context, field grap } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -6118,7 +5923,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -6130,25 +5934,23 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col res := resTmp.(*introspection.Type) fc.Result = res return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) -} - -func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } +} + +func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -6163,22 +5965,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) _Rectangle_length(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Rectangle", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Rectangle", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Length, nil @@ -6193,22 +5993,20 @@ func (ec *executionContext) _Rectangle_length(ctx context.Context, field graphql } func (ec *executionContext) _Rectangle_width(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Rectangle", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Rectangle", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Width, nil @@ -6223,22 +6021,20 @@ func (ec *executionContext) _Rectangle_width(ctx context.Context, field graphql. } func (ec *executionContext) _Rectangle_area(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Rectangle", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Rectangle", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Area(), nil @@ -6253,22 +6049,20 @@ func (ec *executionContext) _Rectangle_area(ctx context.Context, field graphql.C } func (ec *executionContext) _Slices_test1(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Slices", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Slices", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Test1, nil @@ -6283,22 +6077,20 @@ func (ec *executionContext) _Slices_test1(ctx context.Context, field graphql.Col } func (ec *executionContext) _Slices_test2(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Slices", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Slices", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Test2, nil @@ -6313,22 +6105,20 @@ func (ec *executionContext) _Slices_test2(ctx context.Context, field graphql.Col } func (ec *executionContext) _Slices_test3(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Slices", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Slices", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Test3, nil @@ -6346,22 +6136,20 @@ func (ec *executionContext) _Slices_test3(ctx context.Context, field graphql.Col } func (ec *executionContext) _Slices_test4(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Slices", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Slices", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Test4, nil @@ -6379,22 +6167,20 @@ func (ec *executionContext) _Slices_test4(ctx context.Context, field graphql.Col } func (ec *executionContext) _Subscription_updated(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Subscription().Updated(rctx) @@ -6422,22 +6208,20 @@ func (ec *executionContext) _Subscription_updated(ctx context.Context, field gra } func (ec *executionContext) _Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Subscription().InitPayload(rctx) @@ -6465,20 +6249,19 @@ func (ec *executionContext) _Subscription_initPayload(ctx context.Context, field } func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Subscription_directiveArg_args(ctx, rawArgs) @@ -6487,7 +6270,6 @@ func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, fiel return nil } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Subscription().DirectiveArg(rctx, args["arg"].(string)) @@ -6512,20 +6294,19 @@ func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, fiel } func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Subscription_directiveNullableArg_args(ctx, rawArgs) @@ -6534,7 +6315,6 @@ func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Conte return nil } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Subscription().DirectiveNullableArg(rctx, args["arg"].(*int), args["arg2"].(*int), args["arg3"].(*string)) @@ -6559,22 +6339,20 @@ func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Conte } func (ec *executionContext) _Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -6625,22 +6403,20 @@ func (ec *executionContext) _Subscription_directiveDouble(ctx context.Context, f } func (ec *executionContext) _Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -6685,22 +6461,20 @@ func (ec *executionContext) _Subscription_directiveUnimplemented(ctx context.Con } func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -6718,22 +6492,20 @@ func (ec *executionContext) _User_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _User_friends(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.User().Friends(rctx, obj) @@ -6751,22 +6523,20 @@ func (ec *executionContext) _User_friends(ctx context.Context, field graphql.Col } func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Created, nil @@ -6784,22 +6554,20 @@ func (ec *executionContext) _User_created(ctx context.Context, field graphql.Col } func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Updated, nil @@ -6814,22 +6582,20 @@ func (ec *executionContext) _User_updated(ctx context.Context, field graphql.Col } func (ec *executionContext) _ValidType_differentCase(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ValidType", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ValidType", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DifferentCase, nil @@ -6847,22 +6613,20 @@ func (ec *executionContext) _ValidType_differentCase(ctx context.Context, field } func (ec *executionContext) _ValidType_different_case(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ValidType", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ValidType", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DifferentCaseOld, nil @@ -6880,20 +6644,19 @@ func (ec *executionContext) _ValidType_different_case(ctx context.Context, field } func (ec *executionContext) _ValidType_validInputKeywords(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ValidType", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ValidType", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_ValidType_validInputKeywords_args(ctx, rawArgs) @@ -6902,7 +6665,6 @@ func (ec *executionContext) _ValidType_validInputKeywords(ctx context.Context, f return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ValidInputKeywords, nil @@ -6920,20 +6682,19 @@ func (ec *executionContext) _ValidType_validInputKeywords(ctx context.Context, f } func (ec *executionContext) _ValidType_validArgs(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "ValidType", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "ValidType", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_ValidType_validArgs_args(ctx, rawArgs) @@ -6942,7 +6703,6 @@ func (ec *executionContext) _ValidType_validArgs(ctx context.Context, field grap return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ValidArgs, nil @@ -6960,22 +6720,20 @@ func (ec *executionContext) _ValidType_validArgs(ctx context.Context, field grap } func (ec *executionContext) _WrappedStruct_name(ctx context.Context, field graphql.CollectedField, obj *WrappedStruct) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "WrappedStruct", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "WrappedStruct", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -6993,22 +6751,20 @@ func (ec *executionContext) _WrappedStruct_name(ctx context.Context, field graph } func (ec *executionContext) _XXIt_id(ctx context.Context, field graphql.CollectedField, obj *XXIt) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "XXIt", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "XXIt", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -7026,22 +6782,20 @@ func (ec *executionContext) _XXIt_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _XxIt_id(ctx context.Context, field graphql.CollectedField, obj *XxIt) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "XxIt", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "XxIt", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -7059,22 +6813,20 @@ func (ec *executionContext) _XxIt_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -7092,22 +6844,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -7122,22 +6872,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -7155,22 +6903,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -7188,22 +6934,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -7221,22 +6965,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -7251,22 +6993,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -7284,22 +7024,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -7314,22 +7052,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -7347,22 +7083,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -7377,22 +7111,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -7410,22 +7142,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -7443,22 +7173,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -7476,22 +7204,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -7504,24 +7230,22 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel fc.Result = res return ec.marshalOString2ᚖstring(ctx, field.Selections, res) } - -func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } + +func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -7539,22 +7263,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -7569,22 +7291,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -7602,22 +7322,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -7632,22 +7350,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -7665,22 +7381,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -7698,22 +7412,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -7728,22 +7440,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -7758,22 +7468,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -7791,22 +7499,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -7824,22 +7530,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -7854,22 +7558,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -7884,20 +7586,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -7906,7 +7607,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -7921,22 +7621,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -7951,22 +7649,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -7981,20 +7677,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -8003,7 +7698,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -8018,22 +7712,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -8048,22 +7740,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -8078,22 +7768,20 @@ func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.Co } func (ec *executionContext) _asdfIt_id(ctx context.Context, field graphql.CollectedField, obj *AsdfIt) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "asdfIt", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "asdfIt", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -8111,22 +7799,20 @@ func (ec *executionContext) _asdfIt_id(ctx context.Context, field graphql.Collec } func (ec *executionContext) _iIt_id(ctx context.Context, field graphql.CollectedField, obj *IIt) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "iIt", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "iIt", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -9590,7 +9276,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -10196,7 +9881,6 @@ func (ec *executionContext) _Subscription(ctx context.Context, sel ast.Selection fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Subscription", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) if len(fields) != 1 { ec.Errorf(ctx, "must subscribe to exactly one stream") @@ -10956,7 +10640,6 @@ func (ec *executionContext) marshalNPrimitive2ᚕgithubᚗcomᚋ99designsᚋgqlg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -10998,7 +10681,6 @@ func (ec *executionContext) marshalNPrimitiveString2ᚕgithubᚗcomᚋ99designs fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11172,7 +10854,6 @@ func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11253,7 +10934,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11325,7 +11005,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11375,7 +11054,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11417,7 +11095,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11771,7 +11448,6 @@ func (ec *executionContext) marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99design fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11812,7 +11488,6 @@ func (ec *executionContext) marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designs fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -11921,7 +11596,6 @@ func (ec *executionContext) marshalOShape2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -12136,7 +11810,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -12177,7 +11850,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -12218,7 +11890,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -12274,7 +11945,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/codegen/type.gotpl b/codegen/type.gotpl index b0274fc16e0..dad8a8d9984 100644 --- a/codegen/type.gotpl +++ b/codegen/type.gotpl @@ -78,7 +78,6 @@ fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/chat/generated.go b/example/chat/generated.go index 0a200af5322..e667c1fa3c8 100644 --- a/example/chat/generated.go +++ b/example/chat/generated.go @@ -450,22 +450,20 @@ func (ec *executionContext) _subscriptionMiddleware(ctx context.Context, obj *as // region **************************** field.gotpl ***************************** func (ec *executionContext) _Chatroom_name(ctx context.Context, field graphql.CollectedField, obj *Chatroom) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Chatroom", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Chatroom", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -486,22 +484,20 @@ func (ec *executionContext) _Chatroom_name(ctx context.Context, field graphql.Co } func (ec *executionContext) _Chatroom_messages(ctx context.Context, field graphql.CollectedField, obj *Chatroom) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Chatroom", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Chatroom", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Messages, nil @@ -522,22 +518,20 @@ func (ec *executionContext) _Chatroom_messages(ctx context.Context, field graphq } func (ec *executionContext) _Message_id(ctx context.Context, field graphql.CollectedField, obj *Message) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Message", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Message", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -558,22 +552,20 @@ func (ec *executionContext) _Message_id(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Message_text(ctx context.Context, field graphql.CollectedField, obj *Message) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Message", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Message", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Text, nil @@ -594,22 +586,20 @@ func (ec *executionContext) _Message_text(ctx context.Context, field graphql.Col } func (ec *executionContext) _Message_createdBy(ctx context.Context, field graphql.CollectedField, obj *Message) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Message", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Message", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.CreatedBy, nil @@ -630,22 +620,20 @@ func (ec *executionContext) _Message_createdBy(ctx context.Context, field graphq } func (ec *executionContext) _Message_createdAt(ctx context.Context, field graphql.CollectedField, obj *Message) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Message", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Message", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.CreatedAt, nil @@ -666,20 +654,19 @@ func (ec *executionContext) _Message_createdAt(ctx context.Context, field graphq } func (ec *executionContext) _Mutation_post(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_post_args(ctx, rawArgs) @@ -688,7 +675,6 @@ func (ec *executionContext) _Mutation_post(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().Post(rctx, args["text"].(string), args["username"].(string), args["roomName"].(string)) @@ -709,20 +695,19 @@ func (ec *executionContext) _Mutation_post(ctx context.Context, field graphql.Co } func (ec *executionContext) _Query_room(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_room_args(ctx, rawArgs) @@ -731,7 +716,6 @@ func (ec *executionContext) _Query_room(ctx context.Context, field graphql.Colle return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Room(rctx, args["name"].(string)) @@ -749,20 +733,19 @@ func (ec *executionContext) _Query_room(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -771,7 +754,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -789,22 +771,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -822,20 +802,19 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) _Subscription_messageAdded(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Subscription", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = nil } }() + fc := &graphql.FieldContext{ + Object: "Subscription", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Subscription_messageAdded_args(ctx, rawArgs) @@ -844,7 +823,6 @@ func (ec *executionContext) _Subscription_messageAdded(ctx context.Context, fiel return nil } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Subscription().MessageAdded(rctx, args["roomName"].(string)) @@ -875,22 +853,20 @@ func (ec *executionContext) _Subscription_messageAdded(ctx context.Context, fiel } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -911,22 +887,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -944,22 +918,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -980,22 +952,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1016,22 +986,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1052,22 +1020,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1085,22 +1051,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1121,22 +1085,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1154,24 +1116,22 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Name, nil }) if err != nil { @@ -1190,22 +1150,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1223,22 +1181,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1259,22 +1215,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1295,22 +1249,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1331,22 +1283,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1364,22 +1314,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1400,22 +1348,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1433,22 +1379,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1469,22 +1413,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1502,22 +1444,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1538,22 +1478,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1574,22 +1512,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1607,22 +1543,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1640,22 +1574,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1676,22 +1608,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1712,22 +1642,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1745,22 +1673,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1778,20 +1704,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1800,7 +1725,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1818,22 +1742,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1851,22 +1773,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1884,20 +1804,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1906,7 +1825,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1924,22 +1842,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1957,22 +1873,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -2082,7 +1996,6 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Mutation", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2114,7 +2027,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2155,7 +2067,6 @@ func (ec *executionContext) _Subscription(ctx context.Context, sel ast.Selection fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Subscription", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) if len(fields) != 1 { ec.Errorf(ctx, "must subscribe to exactly one stream") @@ -2459,7 +2370,6 @@ func (ec *executionContext) marshalNMessage2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2539,7 +2449,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2611,7 +2520,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2661,7 +2569,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2703,7 +2610,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2825,7 +2731,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2866,7 +2771,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2907,7 +2811,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2963,7 +2866,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/config/generated.go b/example/config/generated.go index 76fb16a48f5..f7467fbfc75 100644 --- a/example/config/generated.go +++ b/example/config/generated.go @@ -324,20 +324,19 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _Mutation_createTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_createTodo_args(ctx, rawArgs) @@ -346,7 +345,6 @@ func (ec *executionContext) _Mutation_createTodo(ctx context.Context, field grap return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().CreateTodo(rctx, args["input"].(NewTodo)) @@ -367,22 +365,20 @@ func (ec *executionContext) _Mutation_createTodo(ctx context.Context, field grap } func (ec *executionContext) _Query_todos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Todos(rctx) @@ -403,20 +399,19 @@ func (ec *executionContext) _Query_todos(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -425,7 +420,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -443,22 +437,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -476,22 +468,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Todo().ID(rctx, obj) @@ -512,22 +502,20 @@ func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _Todo_databaseId(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DatabaseID, nil @@ -548,22 +536,20 @@ func (ec *executionContext) _Todo_databaseId(ctx context.Context, field graphql. } func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -584,22 +570,20 @@ func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Todo_done(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Done, nil @@ -620,22 +604,20 @@ func (ec *executionContext) _Todo_done(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Todo_user(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.User, nil @@ -656,22 +638,20 @@ func (ec *executionContext) _Todo_user(ctx context.Context, field graphql.Collec } func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -692,22 +672,20 @@ func (ec *executionContext) _User_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.FullName(), nil @@ -728,22 +706,20 @@ func (ec *executionContext) _User_name(ctx context.Context, field graphql.Collec } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -764,22 +740,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -797,22 +771,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -833,22 +805,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -869,22 +839,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -905,22 +873,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -938,22 +904,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -974,22 +938,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1007,24 +969,22 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Name, nil }) if err != nil { @@ -1043,22 +1003,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1076,22 +1034,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1112,22 +1068,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1148,22 +1102,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1184,22 +1136,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1217,22 +1167,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1253,22 +1201,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1286,22 +1232,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1322,22 +1266,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1355,22 +1297,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1391,22 +1331,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1427,22 +1365,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1460,22 +1396,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1493,22 +1427,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1529,22 +1461,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1565,22 +1495,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1598,22 +1526,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1631,20 +1557,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1653,7 +1578,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1671,22 +1595,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1704,22 +1626,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1737,20 +1657,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1759,7 +1678,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1777,22 +1695,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1810,22 +1726,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -1885,7 +1799,6 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Mutation", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -1917,7 +1830,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2364,7 +2276,6 @@ func (ec *executionContext) marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2430,7 +2341,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2502,7 +2412,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2552,7 +2461,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2594,7 +2502,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2737,7 +2644,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2778,7 +2684,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2819,7 +2724,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2875,7 +2779,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/dataloader/generated.go b/example/dataloader/generated.go index 1b5bf32ef26..ed5a94077ac 100644 --- a/example/dataloader/generated.go +++ b/example/dataloader/generated.go @@ -386,22 +386,20 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _Address_id(ctx context.Context, field graphql.CollectedField, obj *Address) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Address", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Address", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -422,22 +420,20 @@ func (ec *executionContext) _Address_id(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Address_street(ctx context.Context, field graphql.CollectedField, obj *Address) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Address", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Address", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Street, nil @@ -458,22 +454,20 @@ func (ec *executionContext) _Address_street(ctx context.Context, field graphql.C } func (ec *executionContext) _Address_country(ctx context.Context, field graphql.CollectedField, obj *Address) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Address", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Address", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Country, nil @@ -494,22 +488,20 @@ func (ec *executionContext) _Address_country(ctx context.Context, field graphql. } func (ec *executionContext) _Customer_id(ctx context.Context, field graphql.CollectedField, obj *Customer) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Customer", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Customer", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -530,22 +522,20 @@ func (ec *executionContext) _Customer_id(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Customer_name(ctx context.Context, field graphql.CollectedField, obj *Customer) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Customer", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Customer", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -566,22 +556,20 @@ func (ec *executionContext) _Customer_name(ctx context.Context, field graphql.Co } func (ec *executionContext) _Customer_address(ctx context.Context, field graphql.CollectedField, obj *Customer) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Customer", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Customer", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Customer().Address(rctx, obj) @@ -599,22 +587,20 @@ func (ec *executionContext) _Customer_address(ctx context.Context, field graphql } func (ec *executionContext) _Customer_orders(ctx context.Context, field graphql.CollectedField, obj *Customer) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Customer", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Customer", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Customer().Orders(rctx, obj) @@ -632,22 +618,20 @@ func (ec *executionContext) _Customer_orders(ctx context.Context, field graphql. } func (ec *executionContext) _Item_name(ctx context.Context, field graphql.CollectedField, obj *Item) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Item", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Item", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -668,22 +652,20 @@ func (ec *executionContext) _Item_name(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Order_id(ctx context.Context, field graphql.CollectedField, obj *Order) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Order", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Order", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -704,22 +686,20 @@ func (ec *executionContext) _Order_id(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Order_date(ctx context.Context, field graphql.CollectedField, obj *Order) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Order", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Order", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Date, nil @@ -740,22 +720,20 @@ func (ec *executionContext) _Order_date(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Order_amount(ctx context.Context, field graphql.CollectedField, obj *Order) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Order", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Order", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Amount, nil @@ -776,22 +754,20 @@ func (ec *executionContext) _Order_amount(ctx context.Context, field graphql.Col } func (ec *executionContext) _Order_items(ctx context.Context, field graphql.CollectedField, obj *Order) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Order", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Order", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Order().Items(rctx, obj) @@ -809,22 +785,20 @@ func (ec *executionContext) _Order_items(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query_customers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Customers(rctx) @@ -842,20 +816,19 @@ func (ec *executionContext) _Query_customers(ctx context.Context, field graphql. } func (ec *executionContext) _Query_torture1d(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_torture1d_args(ctx, rawArgs) @@ -864,7 +837,6 @@ func (ec *executionContext) _Query_torture1d(ctx context.Context, field graphql. return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Torture1d(rctx, args["customerIds"].([]int)) @@ -882,20 +854,19 @@ func (ec *executionContext) _Query_torture1d(ctx context.Context, field graphql. } func (ec *executionContext) _Query_torture2d(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_torture2d_args(ctx, rawArgs) @@ -904,7 +875,6 @@ func (ec *executionContext) _Query_torture2d(ctx context.Context, field graphql. return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Torture2d(rctx, args["customerIds"].([][]int)) @@ -922,20 +892,19 @@ func (ec *executionContext) _Query_torture2d(ctx context.Context, field graphql. } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -944,7 +913,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -962,22 +930,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -995,22 +961,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1031,22 +995,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1064,24 +1026,22 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Locations, nil }) if err != nil { @@ -1100,22 +1060,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1136,22 +1094,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1172,22 +1128,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1205,22 +1159,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1241,22 +1193,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1274,22 +1224,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1310,22 +1258,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1343,22 +1289,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1379,22 +1323,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1415,22 +1357,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1451,22 +1391,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1484,22 +1422,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1520,22 +1456,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1553,22 +1487,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1589,22 +1521,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1622,22 +1552,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1658,22 +1586,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1694,22 +1620,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1727,22 +1651,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1760,22 +1682,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1796,22 +1716,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1832,22 +1750,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1865,22 +1781,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1898,20 +1812,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1920,7 +1833,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1938,22 +1850,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1971,22 +1881,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -2004,20 +1912,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -2026,7 +1933,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -2044,22 +1950,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -2077,22 +1981,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -2294,7 +2196,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2724,7 +2625,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2796,7 +2696,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2846,7 +2745,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2888,7 +2786,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2987,7 +2884,6 @@ func (ec *executionContext) marshalOCustomer2ᚕᚕᚖgithubᚗcomᚋ99designs fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3028,7 +2924,6 @@ func (ec *executionContext) marshalOCustomer2ᚕᚖgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3133,7 +3028,6 @@ func (ec *executionContext) marshalOItem2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3174,7 +3068,6 @@ func (ec *executionContext) marshalOOrder2ᚕᚖgithubᚗcomᚋ99designsᚋgqlge fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3238,7 +3131,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3279,7 +3171,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3320,7 +3211,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3376,7 +3266,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/fileupload/generated.go b/example/fileupload/generated.go index 8e0781b8cea..c2c34d4e136 100644 --- a/example/fileupload/generated.go +++ b/example/fileupload/generated.go @@ -369,22 +369,20 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _File_id(ctx context.Context, field graphql.CollectedField, obj *model.File) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "File", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "File", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -405,22 +403,20 @@ func (ec *executionContext) _File_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _File_name(ctx context.Context, field graphql.CollectedField, obj *model.File) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "File", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "File", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -441,22 +437,20 @@ func (ec *executionContext) _File_name(ctx context.Context, field graphql.Collec } func (ec *executionContext) _File_content(ctx context.Context, field graphql.CollectedField, obj *model.File) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "File", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "File", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Content, nil @@ -477,20 +471,19 @@ func (ec *executionContext) _File_content(ctx context.Context, field graphql.Col } func (ec *executionContext) _Mutation_singleUpload(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_singleUpload_args(ctx, rawArgs) @@ -499,7 +492,6 @@ func (ec *executionContext) _Mutation_singleUpload(ctx context.Context, field gr return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().SingleUpload(rctx, args["file"].(graphql.Upload)) @@ -520,20 +512,19 @@ func (ec *executionContext) _Mutation_singleUpload(ctx context.Context, field gr } func (ec *executionContext) _Mutation_singleUploadWithPayload(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_singleUploadWithPayload_args(ctx, rawArgs) @@ -542,7 +533,6 @@ func (ec *executionContext) _Mutation_singleUploadWithPayload(ctx context.Contex return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().SingleUploadWithPayload(rctx, args["req"].(model.UploadFile)) @@ -563,20 +553,19 @@ func (ec *executionContext) _Mutation_singleUploadWithPayload(ctx context.Contex } func (ec *executionContext) _Mutation_multipleUpload(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_multipleUpload_args(ctx, rawArgs) @@ -585,7 +574,6 @@ func (ec *executionContext) _Mutation_multipleUpload(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().MultipleUpload(rctx, args["files"].([]*graphql.Upload)) @@ -606,20 +594,19 @@ func (ec *executionContext) _Mutation_multipleUpload(ctx context.Context, field } func (ec *executionContext) _Mutation_multipleUploadWithPayload(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_multipleUploadWithPayload_args(ctx, rawArgs) @@ -628,7 +615,6 @@ func (ec *executionContext) _Mutation_multipleUploadWithPayload(ctx context.Cont return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().MultipleUploadWithPayload(rctx, args["req"].([]*model.UploadFile)) @@ -649,22 +635,20 @@ func (ec *executionContext) _Mutation_multipleUploadWithPayload(ctx context.Cont } func (ec *executionContext) _Query_empty(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Empty(rctx) @@ -685,20 +669,19 @@ func (ec *executionContext) _Query_empty(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -707,7 +690,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -725,22 +707,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -758,22 +738,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -794,22 +772,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -827,22 +803,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -863,22 +837,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -899,22 +871,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -935,22 +905,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -968,22 +936,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1004,22 +970,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1037,22 +1001,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1073,24 +1035,22 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Description, nil }) if err != nil { @@ -1106,22 +1066,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1142,22 +1100,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1178,22 +1134,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1214,22 +1168,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1247,22 +1199,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1283,22 +1233,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1316,22 +1264,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1352,22 +1298,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1385,22 +1329,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1421,22 +1363,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1457,22 +1397,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1490,22 +1428,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1523,22 +1459,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1559,22 +1493,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1595,22 +1527,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1628,22 +1558,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1661,20 +1589,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1683,7 +1610,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1701,22 +1627,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1734,22 +1658,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1767,20 +1689,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1789,7 +1710,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1807,22 +1727,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1840,22 +1758,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -1952,7 +1868,6 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Mutation", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -1999,7 +1914,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2312,7 +2226,6 @@ func (ec *executionContext) marshalNFile2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2485,7 +2398,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2557,7 +2469,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2607,7 +2518,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2649,7 +2559,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2760,7 +2669,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2801,7 +2709,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2842,7 +2749,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2898,7 +2804,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/scalars/generated.go b/example/scalars/generated.go index 3b4d51b7634..054ff243543 100644 --- a/example/scalars/generated.go +++ b/example/scalars/generated.go @@ -357,22 +357,20 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _Address_id(ctx context.Context, field graphql.CollectedField, obj *model.Address) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Address", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Address", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -393,22 +391,20 @@ func (ec *executionContext) _Address_id(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Address_location(ctx context.Context, field graphql.CollectedField, obj *model.Address) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Address", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Address", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Location, nil @@ -426,20 +422,19 @@ func (ec *executionContext) _Address_location(ctx context.Context, field graphql } func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_user_args(ctx, rawArgs) @@ -448,7 +443,6 @@ func (ec *executionContext) _Query_user(ctx context.Context, field graphql.Colle return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().User(rctx, args["id"].(external.ObjectID)) @@ -466,20 +460,19 @@ func (ec *executionContext) _Query_user(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Query_search(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_search_args(ctx, rawArgs) @@ -488,7 +481,6 @@ func (ec *executionContext) _Query_search(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Search(rctx, args["input"].(*model.SearchArgs)) @@ -509,20 +501,19 @@ func (ec *executionContext) _Query_search(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -531,7 +522,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -549,22 +539,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -582,22 +570,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -618,22 +604,20 @@ func (ec *executionContext) _User_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -654,22 +638,20 @@ func (ec *executionContext) _User_name(ctx context.Context, field graphql.Collec } func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Created, nil @@ -687,22 +669,20 @@ func (ec *executionContext) _User_created(ctx context.Context, field graphql.Col } func (ec *executionContext) _User_isBanned(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsBanned, nil @@ -723,22 +703,20 @@ func (ec *executionContext) _User_isBanned(ctx context.Context, field graphql.Co } func (ec *executionContext) _User_primitiveResolver(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.User().PrimitiveResolver(rctx, obj) @@ -759,22 +737,20 @@ func (ec *executionContext) _User_primitiveResolver(ctx context.Context, field g } func (ec *executionContext) _User_customResolver(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.User().CustomResolver(rctx, obj) @@ -795,22 +771,20 @@ func (ec *executionContext) _User_customResolver(ctx context.Context, field grap } func (ec *executionContext) _User_address(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Address, nil @@ -828,22 +802,20 @@ func (ec *executionContext) _User_address(ctx context.Context, field graphql.Col } func (ec *executionContext) _User_tier(ctx context.Context, field graphql.CollectedField, obj *model.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Tier, nil @@ -861,22 +833,20 @@ func (ec *executionContext) _User_tier(ctx context.Context, field graphql.Collec } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -897,22 +867,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -930,22 +898,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -966,22 +932,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1002,22 +966,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1038,24 +1000,22 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Description, nil }) if err != nil { @@ -1071,22 +1031,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1107,22 +1065,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1140,22 +1096,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1176,22 +1130,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1209,22 +1161,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1245,22 +1195,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1281,22 +1229,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1317,22 +1263,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1350,22 +1294,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1386,22 +1328,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1419,22 +1359,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1455,22 +1393,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1488,22 +1424,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1524,22 +1458,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1560,22 +1492,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1593,22 +1523,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1626,22 +1554,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1662,22 +1588,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1698,22 +1622,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1731,22 +1653,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1764,20 +1684,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1786,7 +1705,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1804,22 +1722,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1837,22 +1753,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1870,20 +1784,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1892,7 +1805,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1910,22 +1822,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1943,22 +1853,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -2053,7 +1961,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2512,7 +2419,6 @@ func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2564,7 +2470,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2636,7 +2541,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2686,7 +2590,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2728,7 +2631,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2931,7 +2833,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2972,7 +2873,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3013,7 +2913,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3069,7 +2968,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/selection/generated.go b/example/selection/generated.go index 61e862b7665..6f3184ede85 100644 --- a/example/selection/generated.go +++ b/example/selection/generated.go @@ -275,22 +275,20 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _Like_reaction(ctx context.Context, field graphql.CollectedField, obj *Like) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Like", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Like", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Reaction, nil @@ -311,22 +309,20 @@ func (ec *executionContext) _Like_reaction(ctx context.Context, field graphql.Co } func (ec *executionContext) _Like_sent(ctx context.Context, field graphql.CollectedField, obj *Like) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Like", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Like", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Sent, nil @@ -347,22 +343,20 @@ func (ec *executionContext) _Like_sent(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Like_selection(ctx context.Context, field graphql.CollectedField, obj *Like) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Like", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Like", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Selection, nil @@ -380,22 +374,20 @@ func (ec *executionContext) _Like_selection(ctx context.Context, field graphql.C } func (ec *executionContext) _Like_collected(ctx context.Context, field graphql.CollectedField, obj *Like) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Like", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Like", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Collected, nil @@ -413,22 +405,20 @@ func (ec *executionContext) _Like_collected(ctx context.Context, field graphql.C } func (ec *executionContext) _Post_message(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Post", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Post", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Message, nil @@ -449,22 +439,20 @@ func (ec *executionContext) _Post_message(ctx context.Context, field graphql.Col } func (ec *executionContext) _Post_sent(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Post", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Post", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Sent, nil @@ -485,22 +473,20 @@ func (ec *executionContext) _Post_sent(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Post_selection(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Post", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Post", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Selection, nil @@ -518,22 +504,20 @@ func (ec *executionContext) _Post_selection(ctx context.Context, field graphql.C } func (ec *executionContext) _Post_collected(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Post", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Post", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Collected, nil @@ -551,22 +535,20 @@ func (ec *executionContext) _Post_collected(ctx context.Context, field graphql.C } func (ec *executionContext) _Query_events(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Events(rctx) @@ -584,20 +566,19 @@ func (ec *executionContext) _Query_events(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -606,7 +587,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -624,22 +604,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -657,22 +635,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -693,22 +669,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -726,22 +700,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -762,22 +734,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -798,22 +768,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -834,22 +802,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -867,22 +833,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -903,22 +867,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -936,22 +898,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -972,22 +932,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1005,22 +963,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1041,22 +997,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1075,24 +1029,22 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col fc.Result = res return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) } - -func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } + +func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1113,22 +1065,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1146,22 +1096,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1182,22 +1130,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1215,22 +1161,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1251,22 +1195,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1284,22 +1226,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1320,22 +1260,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1356,22 +1294,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1389,22 +1325,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1422,22 +1356,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1458,22 +1390,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1494,22 +1424,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1527,22 +1455,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1560,20 +1486,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1582,7 +1507,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1600,22 +1524,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1633,22 +1555,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1666,20 +1586,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1688,7 +1607,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1706,22 +1624,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1739,22 +1655,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -1879,7 +1793,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2227,7 +2140,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2299,7 +2211,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2349,7 +2260,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2391,7 +2301,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2479,7 +2388,6 @@ func (ec *executionContext) marshalOEvent2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2575,7 +2483,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2616,7 +2523,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2657,7 +2563,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2713,7 +2618,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/starwars/generated/exec.go b/example/starwars/generated/exec.go index 7157f1f796e..5f01f2ea8d6 100644 --- a/example/starwars/generated/exec.go +++ b/example/starwars/generated/exec.go @@ -939,22 +939,20 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _Droid_id(ctx context.Context, field graphql.CollectedField, obj *models.Droid) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Droid", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Droid", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -975,22 +973,20 @@ func (ec *executionContext) _Droid_id(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Droid_name(ctx context.Context, field graphql.CollectedField, obj *models.Droid) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Droid", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Droid", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1011,22 +1007,20 @@ func (ec *executionContext) _Droid_name(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Droid_friends(ctx context.Context, field graphql.CollectedField, obj *models.Droid) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Droid", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Droid", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Droid().Friends(rctx, obj) @@ -1044,20 +1038,19 @@ func (ec *executionContext) _Droid_friends(ctx context.Context, field graphql.Co } func (ec *executionContext) _Droid_friendsConnection(ctx context.Context, field graphql.CollectedField, obj *models.Droid) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Droid", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Droid", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Droid_friendsConnection_args(ctx, rawArgs) @@ -1066,7 +1059,6 @@ func (ec *executionContext) _Droid_friendsConnection(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Droid().FriendsConnection(rctx, obj, args["first"].(*int), args["after"].(*string)) @@ -1087,22 +1079,20 @@ func (ec *executionContext) _Droid_friendsConnection(ctx context.Context, field } func (ec *executionContext) _Droid_appearsIn(ctx context.Context, field graphql.CollectedField, obj *models.Droid) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Droid", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Droid", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.AppearsIn, nil @@ -1123,22 +1113,20 @@ func (ec *executionContext) _Droid_appearsIn(ctx context.Context, field graphql. } func (ec *executionContext) _Droid_primaryFunction(ctx context.Context, field graphql.CollectedField, obj *models.Droid) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Droid", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Droid", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PrimaryFunction, nil @@ -1156,22 +1144,20 @@ func (ec *executionContext) _Droid_primaryFunction(ctx context.Context, field gr } func (ec *executionContext) _FriendsConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.FriendsConnection) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "FriendsConnection", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "FriendsConnection", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.TotalCount(), nil @@ -1192,22 +1178,20 @@ func (ec *executionContext) _FriendsConnection_totalCount(ctx context.Context, f } func (ec *executionContext) _FriendsConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.FriendsConnection) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "FriendsConnection", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "FriendsConnection", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.FriendsConnection().Edges(rctx, obj) @@ -1225,22 +1209,20 @@ func (ec *executionContext) _FriendsConnection_edges(ctx context.Context, field } func (ec *executionContext) _FriendsConnection_friends(ctx context.Context, field graphql.CollectedField, obj *models.FriendsConnection) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "FriendsConnection", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "FriendsConnection", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.FriendsConnection().Friends(rctx, obj) @@ -1258,22 +1240,20 @@ func (ec *executionContext) _FriendsConnection_friends(ctx context.Context, fiel } func (ec *executionContext) _FriendsConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.FriendsConnection) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "FriendsConnection", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "FriendsConnection", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PageInfo(), nil @@ -1294,22 +1274,20 @@ func (ec *executionContext) _FriendsConnection_pageInfo(ctx context.Context, fie } func (ec *executionContext) _FriendsEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.FriendsEdge) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "FriendsEdge", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "FriendsEdge", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Cursor, nil @@ -1330,22 +1308,20 @@ func (ec *executionContext) _FriendsEdge_cursor(ctx context.Context, field graph } func (ec *executionContext) _FriendsEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.FriendsEdge) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "FriendsEdge", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "FriendsEdge", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Node, nil @@ -1363,22 +1339,20 @@ func (ec *executionContext) _FriendsEdge_node(ctx context.Context, field graphql } func (ec *executionContext) _Human_id(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -1399,22 +1373,20 @@ func (ec *executionContext) _Human_id(ctx context.Context, field graphql.Collect } func (ec *executionContext) _Human_name(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1435,20 +1407,19 @@ func (ec *executionContext) _Human_name(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Human_height(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Human_height_args(ctx, rawArgs) @@ -1457,7 +1428,6 @@ func (ec *executionContext) _Human_height(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Height(args["unit"].(models.LengthUnit)), nil @@ -1478,22 +1448,20 @@ func (ec *executionContext) _Human_height(ctx context.Context, field graphql.Col } func (ec *executionContext) _Human_mass(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Mass, nil @@ -1511,22 +1479,20 @@ func (ec *executionContext) _Human_mass(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Human_friends(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Human().Friends(rctx, obj) @@ -1544,20 +1510,19 @@ func (ec *executionContext) _Human_friends(ctx context.Context, field graphql.Co } func (ec *executionContext) _Human_friendsConnection(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Human_friendsConnection_args(ctx, rawArgs) @@ -1566,7 +1531,6 @@ func (ec *executionContext) _Human_friendsConnection(ctx context.Context, field return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Human().FriendsConnection(rctx, obj, args["first"].(*int), args["after"].(*string)) @@ -1587,22 +1551,20 @@ func (ec *executionContext) _Human_friendsConnection(ctx context.Context, field } func (ec *executionContext) _Human_appearsIn(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.AppearsIn, nil @@ -1623,24 +1585,22 @@ func (ec *executionContext) _Human_appearsIn(ctx context.Context, field graphql. } func (ec *executionContext) _Human_starships(ctx context.Context, field graphql.CollectedField, obj *models.Human) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Human", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "Human", + Field: field, + Args: nil, + IsMethod: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return ec.resolvers.Human().Starships(rctx, obj) }) if err != nil { @@ -1656,20 +1616,19 @@ func (ec *executionContext) _Human_starships(ctx context.Context, field graphql. } func (ec *executionContext) _Mutation_createReview(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Mutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Mutation_createReview_args(ctx, rawArgs) @@ -1678,7 +1637,6 @@ func (ec *executionContext) _Mutation_createReview(ctx context.Context, field gr return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Mutation().CreateReview(rctx, args["episode"].(models.Episode), args["review"].(models.Review)) @@ -1696,22 +1654,20 @@ func (ec *executionContext) _Mutation_createReview(ctx context.Context, field gr } func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "PageInfo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "PageInfo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.StartCursor, nil @@ -1732,22 +1688,20 @@ func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field gra } func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "PageInfo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "PageInfo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EndCursor, nil @@ -1768,22 +1722,20 @@ func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graph } func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "PageInfo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "PageInfo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.HasNextPage, nil @@ -1804,20 +1756,19 @@ func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field gra } func (ec *executionContext) _Query_hero(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_hero_args(ctx, rawArgs) @@ -1826,7 +1777,6 @@ func (ec *executionContext) _Query_hero(ctx context.Context, field graphql.Colle return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Hero(rctx, args["episode"].(*models.Episode)) @@ -1844,20 +1794,19 @@ func (ec *executionContext) _Query_hero(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Query_reviews(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_reviews_args(ctx, rawArgs) @@ -1866,7 +1815,6 @@ func (ec *executionContext) _Query_reviews(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Reviews(rctx, args["episode"].(models.Episode), args["since"].(*time.Time)) @@ -1887,20 +1835,19 @@ func (ec *executionContext) _Query_reviews(ctx context.Context, field graphql.Co } func (ec *executionContext) _Query_search(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_search_args(ctx, rawArgs) @@ -1909,7 +1856,6 @@ func (ec *executionContext) _Query_search(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Search(rctx, args["text"].(string)) @@ -1930,20 +1876,19 @@ func (ec *executionContext) _Query_search(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query_character(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_character_args(ctx, rawArgs) @@ -1952,7 +1897,6 @@ func (ec *executionContext) _Query_character(ctx context.Context, field graphql. return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Character(rctx, args["id"].(string)) @@ -1970,20 +1914,19 @@ func (ec *executionContext) _Query_character(ctx context.Context, field graphql. } func (ec *executionContext) _Query_droid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_droid_args(ctx, rawArgs) @@ -1992,7 +1935,6 @@ func (ec *executionContext) _Query_droid(ctx context.Context, field graphql.Coll return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Droid(rctx, args["id"].(string)) @@ -2010,20 +1952,19 @@ func (ec *executionContext) _Query_droid(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query_human(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_human_args(ctx, rawArgs) @@ -2032,7 +1973,6 @@ func (ec *executionContext) _Query_human(ctx context.Context, field graphql.Coll return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Human(rctx, args["id"].(string)) @@ -2050,20 +1990,19 @@ func (ec *executionContext) _Query_human(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query_starship(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_starship_args(ctx, rawArgs) @@ -2072,7 +2011,6 @@ func (ec *executionContext) _Query_starship(ctx context.Context, field graphql.C return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Starship(rctx, args["id"].(string)) @@ -2090,20 +2028,19 @@ func (ec *executionContext) _Query_starship(ctx context.Context, field graphql.C } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -2112,7 +2049,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -2130,22 +2066,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -2163,22 +2097,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) _Review_stars(ctx context.Context, field graphql.CollectedField, obj *models.Review) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Review", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Review", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Stars, nil @@ -2199,22 +2131,20 @@ func (ec *executionContext) _Review_stars(ctx context.Context, field graphql.Col } func (ec *executionContext) _Review_commentary(ctx context.Context, field graphql.CollectedField, obj *models.Review) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Review", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Review", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Commentary, nil @@ -2232,22 +2162,20 @@ func (ec *executionContext) _Review_commentary(ctx context.Context, field graphq } func (ec *executionContext) _Review_time(ctx context.Context, field graphql.CollectedField, obj *models.Review) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Review", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Review", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Time, nil @@ -2265,22 +2193,20 @@ func (ec *executionContext) _Review_time(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Starship_id(ctx context.Context, field graphql.CollectedField, obj *models.Starship) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Starship", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Starship", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -2301,22 +2227,20 @@ func (ec *executionContext) _Starship_id(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Starship_name(ctx context.Context, field graphql.CollectedField, obj *models.Starship) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Starship", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Starship", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -2337,29 +2261,27 @@ func (ec *executionContext) _Starship_name(ctx context.Context, field graphql.Co } func (ec *executionContext) _Starship_length(ctx context.Context, field graphql.CollectedField, obj *models.Starship) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Starship", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - rawArgs := field.ArgumentMap(ec.Variables) - args, err := ec.field_Starship_length_args(ctx, rawArgs) - if err != nil { - ec.Error(ctx, err) - return graphql.Null + fc := &graphql.FieldContext{ + Object: "Starship", + Field: field, + Args: nil, + IsMethod: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + rawArgs := field.ArgumentMap(ec.Variables) + args, err := ec.field_Starship_length_args(ctx, rawArgs) + if err != nil { + ec.Error(ctx, err) + return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Starship().Length(rctx, obj, args["unit"].(*models.LengthUnit)) @@ -2380,22 +2302,20 @@ func (ec *executionContext) _Starship_length(ctx context.Context, field graphql. } func (ec *executionContext) _Starship_history(ctx context.Context, field graphql.CollectedField, obj *models.Starship) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Starship", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Starship", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.History, nil @@ -2416,22 +2336,20 @@ func (ec *executionContext) _Starship_history(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -2452,22 +2370,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -2485,22 +2401,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -2521,22 +2435,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -2557,22 +2469,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -2593,22 +2503,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -2626,22 +2534,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -2662,22 +2568,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -2695,22 +2599,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -2731,22 +2633,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -2764,22 +2664,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -2800,22 +2698,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -2836,22 +2732,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -2872,22 +2766,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -2905,22 +2797,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -2941,22 +2831,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -2974,22 +2862,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -3010,22 +2896,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -3043,22 +2927,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -3079,22 +2961,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -3115,22 +2995,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -3148,22 +3026,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -3181,22 +3057,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -3217,22 +3091,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -3253,22 +3125,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -3286,22 +3156,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -3319,20 +3187,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -3341,7 +3208,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -3359,22 +3225,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -3392,22 +3256,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -3425,20 +3287,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -3447,7 +3308,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -3465,22 +3325,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -3498,22 +3356,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -3844,7 +3700,6 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Mutation", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -3910,7 +3765,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -4409,7 +4263,6 @@ func (ec *executionContext) marshalNEpisode2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4583,7 +4436,6 @@ func (ec *executionContext) marshalNReview2ᚕᚖgithubᚗcomᚋ99designsᚋgqlg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4645,7 +4497,6 @@ func (ec *executionContext) marshalNSearchResult2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4715,7 +4566,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4787,7 +4637,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4837,7 +4686,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4879,7 +4727,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -4974,7 +4821,6 @@ func (ec *executionContext) marshalOCharacter2ᚕgithubᚗcomᚋ99designsᚋgqlg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -5058,7 +4904,6 @@ func (ec *executionContext) marshalOFriendsEdge2ᚕᚖgithubᚗcomᚋ99designs fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -5195,7 +5040,6 @@ func (ec *executionContext) marshalOStarship2ᚕᚖgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -5289,7 +5133,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -5330,7 +5173,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -5371,7 +5213,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -5427,7 +5268,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/todo/generated.go b/example/todo/generated.go index 6f9e3ed3a28..1b1421ad5cd 100644 --- a/example/todo/generated.go +++ b/example/todo/generated.go @@ -498,20 +498,19 @@ func (ec *executionContext) _fieldMiddleware(ctx context.Context, obj interface{ // region **************************** field.gotpl ***************************** func (ec *executionContext) _MyMutation_createTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyMutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyMutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyMutation_createTodo_args(ctx, rawArgs) @@ -520,7 +519,6 @@ func (ec *executionContext) _MyMutation_createTodo(ctx context.Context, field gr return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyMutation().CreateTodo(rctx, args["todo"].(TodoInput)) @@ -538,20 +536,19 @@ func (ec *executionContext) _MyMutation_createTodo(ctx context.Context, field gr } func (ec *executionContext) _MyMutation_updateTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyMutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyMutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyMutation_updateTodo_args(ctx, rawArgs) @@ -560,7 +557,6 @@ func (ec *executionContext) _MyMutation_updateTodo(ctx context.Context, field gr return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyMutation().UpdateTodo(rctx, args["id"].(int), args["changes"].(map[string]interface{})) @@ -575,20 +571,19 @@ func (ec *executionContext) _MyMutation_updateTodo(ctx context.Context, field gr } func (ec *executionContext) _MyQuery_todo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyQuery_todo_args(ctx, rawArgs) @@ -597,7 +592,6 @@ func (ec *executionContext) _MyQuery_todo(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyQuery().Todo(rctx, args["id"].(int)) @@ -612,22 +606,20 @@ func (ec *executionContext) _MyQuery_todo(ctx context.Context, field graphql.Col } func (ec *executionContext) _MyQuery_lastTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyQuery().LastTodo(rctx) @@ -642,22 +634,20 @@ func (ec *executionContext) _MyQuery_lastTodo(ctx context.Context, field graphql } func (ec *executionContext) _MyQuery_todos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyQuery().Todos(rctx) @@ -675,20 +665,19 @@ func (ec *executionContext) _MyQuery_todos(ctx context.Context, field graphql.Co } func (ec *executionContext) _MyQuery___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyQuery___type_args(ctx, rawArgs) @@ -697,7 +686,6 @@ func (ec *executionContext) _MyQuery___type(ctx context.Context, field graphql.C return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -712,22 +700,20 @@ func (ec *executionContext) _MyQuery___type(ctx context.Context, field graphql.C } func (ec *executionContext) _MyQuery___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -742,22 +728,20 @@ func (ec *executionContext) _MyQuery___schema(ctx context.Context, field graphql } func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -775,22 +759,20 @@ func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Text, nil @@ -808,22 +790,20 @@ func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Todo_done(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -865,22 +845,20 @@ func (ec *executionContext) _Todo_done(ctx context.Context, field graphql.Collec } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -898,22 +876,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -928,22 +904,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -961,22 +935,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -994,22 +966,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1027,22 +997,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1057,22 +1025,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1090,22 +1056,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1120,22 +1084,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1153,24 +1115,22 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Description, nil }) @@ -1183,22 +1143,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1216,22 +1174,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1249,22 +1205,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1282,22 +1236,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1312,22 +1264,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1345,22 +1295,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1375,22 +1323,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1408,22 +1354,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1438,22 +1382,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1471,22 +1413,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1504,22 +1444,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1534,22 +1472,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1564,22 +1500,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1597,22 +1531,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1630,22 +1562,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1660,22 +1590,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1690,20 +1618,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1712,7 +1639,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1727,22 +1653,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1757,22 +1681,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1787,20 +1709,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1809,7 +1730,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1824,22 +1744,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1854,22 +1772,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -1926,7 +1842,6 @@ func (ec *executionContext) _MyMutation(ctx context.Context, sel ast.SelectionSe ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "MyMutation", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -1960,7 +1875,6 @@ func (ec *executionContext) _MyQuery(ctx context.Context, sel ast.SelectionSet) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "MyQuery", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2392,7 +2306,6 @@ func (ec *executionContext) marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2448,7 +2361,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2520,7 +2432,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2570,7 +2481,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2612,7 +2522,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2734,7 +2643,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2775,7 +2683,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2816,7 +2723,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2872,7 +2778,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/example/type-system-extension/generated.go b/example/type-system-extension/generated.go index 45557d74bc7..5286d9265cc 100644 --- a/example/type-system-extension/generated.go +++ b/example/type-system-extension/generated.go @@ -379,20 +379,19 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _MyMutation_createTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyMutation", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyMutation", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyMutation_createTodo_args(ctx, rawArgs) @@ -401,7 +400,6 @@ func (ec *executionContext) _MyMutation_createTodo(ctx context.Context, field gr return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyMutation().CreateTodo(rctx, args["todo"].(TodoInput)) @@ -422,22 +420,20 @@ func (ec *executionContext) _MyMutation_createTodo(ctx context.Context, field gr } func (ec *executionContext) _MyQuery_todos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyQuery().Todos(rctx) @@ -458,20 +454,19 @@ func (ec *executionContext) _MyQuery_todos(ctx context.Context, field graphql.Co } func (ec *executionContext) _MyQuery_todo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyQuery_todo_args(ctx, rawArgs) @@ -480,7 +475,6 @@ func (ec *executionContext) _MyQuery_todo(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.MyQuery().Todo(rctx, args["id"].(string)) @@ -498,20 +492,19 @@ func (ec *executionContext) _MyQuery_todo(ctx context.Context, field graphql.Col } func (ec *executionContext) _MyQuery___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_MyQuery___type_args(ctx, rawArgs) @@ -520,7 +513,6 @@ func (ec *executionContext) _MyQuery___type(ctx context.Context, field graphql.C return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -538,22 +530,20 @@ func (ec *executionContext) _MyQuery___type(ctx context.Context, field graphql.C } func (ec *executionContext) _MyQuery___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "MyQuery", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "MyQuery", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -571,22 +561,20 @@ func (ec *executionContext) _MyQuery___schema(ctx context.Context, field graphql } func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.ID, nil @@ -607,22 +595,20 @@ func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.Collecte } func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Text, nil @@ -643,22 +629,20 @@ func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.Collec } func (ec *executionContext) _Todo_state(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.State, nil @@ -679,22 +663,20 @@ func (ec *executionContext) _Todo_state(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Todo_verified(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Todo", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Todo", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { directive0 := func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children @@ -735,22 +717,20 @@ func (ec *executionContext) _Todo_verified(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -771,22 +751,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -804,22 +782,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -840,22 +816,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -876,22 +850,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -912,22 +884,20 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -945,22 +915,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -981,22 +949,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1014,22 +980,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1050,22 +1014,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1083,24 +1045,22 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Args, nil }) if err != nil { @@ -1119,22 +1079,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1155,22 +1113,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1191,22 +1147,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1224,22 +1178,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1260,22 +1212,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1293,22 +1243,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1329,22 +1277,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1362,22 +1308,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1398,22 +1342,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1434,22 +1376,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1467,22 +1407,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1500,22 +1438,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1536,22 +1472,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1572,22 +1506,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1605,22 +1537,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1638,20 +1568,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1660,7 +1589,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1678,22 +1606,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1711,22 +1637,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1744,20 +1668,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1766,7 +1689,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1784,22 +1706,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -1817,22 +1737,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -1912,7 +1830,6 @@ func (ec *executionContext) _MyMutation(ctx context.Context, sel ast.SelectionSe ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "MyMutation", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -1944,7 +1861,6 @@ func (ec *executionContext) _MyQuery(ctx context.Context, sel ast.SelectionSet) ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "MyQuery", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2347,7 +2263,6 @@ func (ec *executionContext) marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2403,7 +2318,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2475,7 +2389,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2525,7 +2438,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2567,7 +2479,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2689,7 +2600,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2730,7 +2640,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2771,7 +2680,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2827,7 +2735,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { diff --git a/graphql/context_field.go b/graphql/context_field.go index 5471adfaccd..802b60e4c5e 100644 --- a/graphql/context_field.go +++ b/graphql/context_field.go @@ -26,9 +26,6 @@ type FieldContext struct { Result interface{} // IsMethod indicates if the resolver is a method IsMethod bool - - // Stats collected while executing this field - Stats FieldStats } type FieldStats struct { diff --git a/graphql/handler/apollotracing/tracer.go b/graphql/handler/apollotracing/tracer.go index ce790aa718c..e943e17ac97 100644 --- a/graphql/handler/apollotracing/tracer.go +++ b/graphql/handler/apollotracing/tracer.go @@ -57,6 +57,8 @@ func (a Tracer) InterceptField(ctx context.Context, next graphql.Resolver) (res panic("missing tracing extension") } + start := graphql.Now() + defer func() { td.mu.Lock() defer td.mu.Unlock() @@ -69,8 +71,8 @@ func (a Tracer) InterceptField(ctx context.Context, next graphql.Resolver) (res ParentType: fc.Object, FieldName: fc.Field.Name, ReturnType: fc.Field.Definition.Type.String(), - StartOffset: fc.Stats.Started.Sub(rc.Stats.OperationStart), - Duration: end.Sub(fc.Stats.Started), + StartOffset: start.Sub(rc.Stats.OperationStart), + Duration: end.Sub(start), }) }() diff --git a/graphql/handler/testserver/testserver.go b/graphql/handler/testserver/testserver.go index 878b67b7c48..0a1d91b420a 100644 --- a/graphql/handler/testserver/testserver.go +++ b/graphql/handler/testserver/testserver.go @@ -62,9 +62,6 @@ func New() *TestServer { Definition: schema.Types["Query"].Fields.ForName("name"), }, }, - Stats: graphql.FieldStats{ - Started: graphql.Now(), - }, }) res, err := graphql.GetOperationContext(ctx).ResolverMiddleware(ctx, func(ctx context.Context) (interface{}, error) { return &graphql.Response{Data: []byte(`{"name":"test"}`)}, nil diff --git a/integration/generated.go b/integration/generated.go index fa633ca390f..06b04db9851 100644 --- a/integration/generated.go +++ b/integration/generated.go @@ -417,22 +417,20 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** func (ec *executionContext) _Element_child(ctx context.Context, field graphql.CollectedField, obj *models.Element) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Element", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Element", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Element().Child(rctx, obj) @@ -453,22 +451,20 @@ func (ec *executionContext) _Element_child(ctx context.Context, field graphql.Co } func (ec *executionContext) _Element_error(ctx context.Context, field graphql.CollectedField, obj *models.Element) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Element", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Element", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Element().Error(rctx, obj) @@ -489,22 +485,20 @@ func (ec *executionContext) _Element_error(ctx context.Context, field graphql.Co } func (ec *executionContext) _Element_mismatched(ctx context.Context, field graphql.CollectedField, obj *models.Element) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Element", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Element", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Element().Mismatched(rctx, obj) @@ -522,22 +516,20 @@ func (ec *executionContext) _Element_mismatched(ctx context.Context, field graph } func (ec *executionContext) _Query_path(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Path(rctx) @@ -555,20 +547,19 @@ func (ec *executionContext) _Query_path(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Query_date(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_date_args(ctx, rawArgs) @@ -577,7 +568,6 @@ func (ec *executionContext) _Query_date(ctx context.Context, field graphql.Colle return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Date(rctx, args["filter"].(models.DateFilter)) @@ -598,22 +588,20 @@ func (ec *executionContext) _Query_date(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Query_viewer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Viewer(rctx) @@ -631,22 +619,20 @@ func (ec *executionContext) _Query_viewer(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query_jsonEncoding(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().JSONEncoding(rctx) @@ -667,20 +653,19 @@ func (ec *executionContext) _Query_jsonEncoding(ctx context.Context, field graph } func (ec *executionContext) _Query_error(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_error_args(ctx, rawArgs) @@ -689,7 +674,6 @@ func (ec *executionContext) _Query_error(ctx context.Context, field graphql.Coll return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Error(rctx, args["type"].(*models.ErrorType)) @@ -710,20 +694,19 @@ func (ec *executionContext) _Query_error(ctx context.Context, field graphql.Coll } func (ec *executionContext) _Query_complexity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query_complexity_args(ctx, rawArgs) @@ -732,7 +715,6 @@ func (ec *executionContext) _Query_complexity(ctx context.Context, field graphql return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.Query().Complexity(rctx, args["value"].(int)) @@ -753,20 +735,19 @@ func (ec *executionContext) _Query_complexity(ctx context.Context, field graphql } func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field_Query___type_args(ctx, rawArgs) @@ -775,7 +756,6 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectType(args["name"].(string)) @@ -793,22 +773,20 @@ func (ec *executionContext) _Query___type(ctx context.Context, field graphql.Col } func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Query", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Query", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.introspectSchema() @@ -826,22 +804,20 @@ func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.C } func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *remote_api.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -862,22 +838,20 @@ func (ec *executionContext) _User_name(ctx context.Context, field graphql.Collec } func (ec *executionContext) _User_likes(ctx context.Context, field graphql.CollectedField, obj *remote_api.User) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "User", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "User", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return ec.resolvers.User().Likes(rctx, obj) @@ -898,22 +872,20 @@ func (ec *executionContext) _User_likes(ctx context.Context, field graphql.Colle } func (ec *executionContext) _Viewer_user(ctx context.Context, field graphql.CollectedField, obj *models.Viewer) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "Viewer", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "Viewer", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.User, nil @@ -931,22 +903,20 @@ func (ec *executionContext) _Viewer_user(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -967,22 +937,20 @@ func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql } func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1000,22 +968,20 @@ func (ec *executionContext) ___Directive_description(ctx context.Context, field } func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Locations, nil @@ -1036,22 +1002,20 @@ func (ec *executionContext) ___Directive_locations(ctx context.Context, field gr } func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Directive", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Directive", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1072,22 +1036,20 @@ func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1108,24 +1070,22 @@ func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql } func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() - ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() - resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { - ctx = rctx // use context from middleware stack in children + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children return obj.Description, nil }) if err != nil { @@ -1141,22 +1101,20 @@ func (ec *executionContext) ___EnumValue_description(ctx context.Context, field } func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1177,22 +1135,20 @@ func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field } func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__EnumValue", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1210,22 +1166,20 @@ func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, } func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1246,22 +1200,20 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1279,22 +1231,20 @@ func (ec *executionContext) ___Field_description(ctx context.Context, field grap } func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Args, nil @@ -1315,22 +1265,20 @@ func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1351,22 +1299,20 @@ func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.Col } func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.IsDeprecated(), nil @@ -1387,22 +1333,20 @@ func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field gra } func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Field", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Field", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DeprecationReason(), nil @@ -1420,22 +1364,20 @@ func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, fiel } func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name, nil @@ -1456,22 +1398,20 @@ func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description, nil @@ -1489,22 +1429,20 @@ func (ec *executionContext) ___InputValue_description(ctx context.Context, field } func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Type, nil @@ -1525,22 +1463,20 @@ func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphq } func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - Args: nil, - IsMethod: false, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + Args: nil, + IsMethod: false, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.DefaultValue, nil @@ -1558,22 +1494,20 @@ func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, fiel } func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Types(), nil @@ -1594,22 +1528,20 @@ func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.C } func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.QueryType(), nil @@ -1630,22 +1562,20 @@ func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graph } func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.MutationType(), nil @@ -1663,22 +1593,20 @@ func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field gr } func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.SubscriptionType(), nil @@ -1696,22 +1624,20 @@ func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, fiel } func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Schema", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Schema", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Directives(), nil @@ -1732,22 +1658,20 @@ func (ec *executionContext) ___Schema_directives(ctx context.Context, field grap } func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Kind(), nil @@ -1768,22 +1692,20 @@ func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Name(), nil @@ -1801,22 +1723,20 @@ func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.Coll } func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Description(), nil @@ -1834,20 +1754,19 @@ func (ec *executionContext) ___Type_description(ctx context.Context, field graph } func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_fields_args(ctx, rawArgs) @@ -1856,7 +1775,6 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Fields(args["includeDeprecated"].(bool)), nil @@ -1874,22 +1792,20 @@ func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.Co } func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.Interfaces(), nil @@ -1907,22 +1823,20 @@ func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphq } func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.PossibleTypes(), nil @@ -1940,20 +1854,19 @@ func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field gra } func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) rawArgs := field.ArgumentMap(ec.Variables) args, err := ec.field___Type_enumValues_args(ctx, rawArgs) @@ -1962,7 +1875,6 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq return graphql.Null } fc.Args = args - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.EnumValues(args["includeDeprecated"].(bool)), nil @@ -1980,22 +1892,20 @@ func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphq } func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.InputFields(), nil @@ -2013,22 +1923,20 @@ func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graph } func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { - fc := &graphql.FieldContext{ - Object: "__Type", - Field: field, - Args: nil, - IsMethod: true, - Stats: graphql.FieldStats{Started: graphql.Now()}, - } defer func() { - fc.Stats.Completed = graphql.Now() if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) ret = graphql.Null } }() + fc := &graphql.FieldContext{ + Object: "__Type", + Field: field, + Args: nil, + IsMethod: true, + } + ctx = graphql.WithFieldContext(ctx, fc) - fc.Stats.ArgumentsCompleted = graphql.Now() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children return obj.OfType(), nil @@ -2162,7 +2070,6 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ Object: "Query", - Stats: graphql.FieldStats{Started: graphql.Now()}, }) out := graphql.NewFieldSet(fields) @@ -2679,7 +2586,6 @@ func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2751,7 +2657,6 @@ func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Co fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2801,7 +2706,6 @@ func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2843,7 +2747,6 @@ func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -2991,7 +2894,6 @@ func (ec *executionContext) marshalOElement2ᚕᚖgithubᚗcomᚋ99designsᚋgql fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3131,7 +3033,6 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3172,7 +3073,6 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3213,7 +3113,6 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) { @@ -3269,7 +3168,6 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen fc := &graphql.FieldContext{ Index: &i, Result: &v[i], - Stats: graphql.FieldStats{Started: graphql.Now()}, } ctx := graphql.WithFieldContext(ctx, fc) f := func(i int) {