1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "context"
7 "fmt"
8 "strconv"
9 "sync/atomic"
10
11 "github.com/99designs/gqlgen/graphql"
12 "github.com/99designs/gqlgen/graphql/introspection"
13 "github.com/git-bug/git-bug/api/graphql/models"
14 "github.com/vektah/gqlparser/v2/ast"
15)
16
17// region ************************** generated!.gotpl **************************
18
19type MutationResolver interface {
20 NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
21 AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
22 AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error)
23 AddCommentAndReopen(ctx context.Context, input models.AddCommentAndReopenBugInput) (*models.AddCommentAndReopenBugPayload, error)
24 EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error)
25 ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
26 OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
27 CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
28 SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
29}
30type QueryResolver interface {
31 Repository(ctx context.Context, ref *string) (*models.Repository, error)
32}
33
34// endregion ************************** generated!.gotpl **************************
35
36// region ***************************** args.gotpl *****************************
37
38func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
39 var err error
40 args := map[string]interface{}{}
41 var arg0 models.AddCommentAndCloseBugInput
42 if tmp, ok := rawArgs["input"]; ok {
43 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
44 arg0, err = ec.unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx, tmp)
45 if err != nil {
46 return nil, err
47 }
48 }
49 args["input"] = arg0
50 return args, nil
51}
52
53func (ec *executionContext) field_Mutation_addCommentAndReopen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
54 var err error
55 args := map[string]interface{}{}
56 var arg0 models.AddCommentAndReopenBugInput
57 if tmp, ok := rawArgs["input"]; ok {
58 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
59 arg0, err = ec.unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx, tmp)
60 if err != nil {
61 return nil, err
62 }
63 }
64 args["input"] = arg0
65 return args, nil
66}
67
68func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
69 var err error
70 args := map[string]interface{}{}
71 var arg0 models.AddCommentInput
72 if tmp, ok := rawArgs["input"]; ok {
73 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
74 arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
75 if err != nil {
76 return nil, err
77 }
78 }
79 args["input"] = arg0
80 return args, nil
81}
82
83func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
84 var err error
85 args := map[string]interface{}{}
86 var arg0 *models.ChangeLabelInput
87 if tmp, ok := rawArgs["input"]; ok {
88 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
89 arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
90 if err != nil {
91 return nil, err
92 }
93 }
94 args["input"] = arg0
95 return args, nil
96}
97
98func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
99 var err error
100 args := map[string]interface{}{}
101 var arg0 models.CloseBugInput
102 if tmp, ok := rawArgs["input"]; ok {
103 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
104 arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
105 if err != nil {
106 return nil, err
107 }
108 }
109 args["input"] = arg0
110 return args, nil
111}
112
113func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
114 var err error
115 args := map[string]interface{}{}
116 var arg0 models.EditCommentInput
117 if tmp, ok := rawArgs["input"]; ok {
118 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
119 arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
120 if err != nil {
121 return nil, err
122 }
123 }
124 args["input"] = arg0
125 return args, nil
126}
127
128func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
129 var err error
130 args := map[string]interface{}{}
131 var arg0 models.NewBugInput
132 if tmp, ok := rawArgs["input"]; ok {
133 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
134 arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
135 if err != nil {
136 return nil, err
137 }
138 }
139 args["input"] = arg0
140 return args, nil
141}
142
143func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
144 var err error
145 args := map[string]interface{}{}
146 var arg0 models.OpenBugInput
147 if tmp, ok := rawArgs["input"]; ok {
148 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
149 arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
150 if err != nil {
151 return nil, err
152 }
153 }
154 args["input"] = arg0
155 return args, nil
156}
157
158func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
159 var err error
160 args := map[string]interface{}{}
161 var arg0 models.SetTitleInput
162 if tmp, ok := rawArgs["input"]; ok {
163 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
164 arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
165 if err != nil {
166 return nil, err
167 }
168 }
169 args["input"] = arg0
170 return args, nil
171}
172
173func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
174 var err error
175 args := map[string]interface{}{}
176 var arg0 string
177 if tmp, ok := rawArgs["name"]; ok {
178 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
179 arg0, err = ec.unmarshalNString2string(ctx, tmp)
180 if err != nil {
181 return nil, err
182 }
183 }
184 args["name"] = arg0
185 return args, nil
186}
187
188func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
189 var err error
190 args := map[string]interface{}{}
191 var arg0 *string
192 if tmp, ok := rawArgs["ref"]; ok {
193 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
194 arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
195 if err != nil {
196 return nil, err
197 }
198 }
199 args["ref"] = arg0
200 return args, nil
201}
202
203// endregion ***************************** args.gotpl *****************************
204
205// region ************************** directives.gotpl **************************
206
207// endregion ************************** directives.gotpl **************************
208
209// region **************************** field.gotpl *****************************
210
211func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
212 fc, err := ec.fieldContext_Mutation_newBug(ctx, field)
213 if err != nil {
214 return graphql.Null
215 }
216 ctx = graphql.WithFieldContext(ctx, fc)
217 defer func() {
218 if r := recover(); r != nil {
219 ec.Error(ctx, ec.Recover(ctx, r))
220 ret = graphql.Null
221 }
222 }()
223 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
224 ctx = rctx // use context from middleware stack in children
225 return ec.resolvers.Mutation().NewBug(rctx, fc.Args["input"].(models.NewBugInput))
226 })
227 if err != nil {
228 ec.Error(ctx, err)
229 return graphql.Null
230 }
231 if resTmp == nil {
232 if !graphql.HasFieldError(ctx, fc) {
233 ec.Errorf(ctx, "must not be null")
234 }
235 return graphql.Null
236 }
237 res := resTmp.(*models.NewBugPayload)
238 fc.Result = res
239 return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
240}
241
242func (ec *executionContext) fieldContext_Mutation_newBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
243 fc = &graphql.FieldContext{
244 Object: "Mutation",
245 Field: field,
246 IsMethod: true,
247 IsResolver: true,
248 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
249 switch field.Name {
250 case "clientMutationId":
251 return ec.fieldContext_NewBugPayload_clientMutationId(ctx, field)
252 case "bug":
253 return ec.fieldContext_NewBugPayload_bug(ctx, field)
254 case "operation":
255 return ec.fieldContext_NewBugPayload_operation(ctx, field)
256 }
257 return nil, fmt.Errorf("no field named %q was found under type NewBugPayload", field.Name)
258 },
259 }
260 defer func() {
261 if r := recover(); r != nil {
262 err = ec.Recover(ctx, r)
263 ec.Error(ctx, err)
264 }
265 }()
266 ctx = graphql.WithFieldContext(ctx, fc)
267 if fc.Args, err = ec.field_Mutation_newBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
268 ec.Error(ctx, err)
269 return fc, err
270 }
271 return fc, nil
272}
273
274func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
275 fc, err := ec.fieldContext_Mutation_addComment(ctx, field)
276 if err != nil {
277 return graphql.Null
278 }
279 ctx = graphql.WithFieldContext(ctx, fc)
280 defer func() {
281 if r := recover(); r != nil {
282 ec.Error(ctx, ec.Recover(ctx, r))
283 ret = graphql.Null
284 }
285 }()
286 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
287 ctx = rctx // use context from middleware stack in children
288 return ec.resolvers.Mutation().AddComment(rctx, fc.Args["input"].(models.AddCommentInput))
289 })
290 if err != nil {
291 ec.Error(ctx, err)
292 return graphql.Null
293 }
294 if resTmp == nil {
295 if !graphql.HasFieldError(ctx, fc) {
296 ec.Errorf(ctx, "must not be null")
297 }
298 return graphql.Null
299 }
300 res := resTmp.(*models.AddCommentPayload)
301 fc.Result = res
302 return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
303}
304
305func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
306 fc = &graphql.FieldContext{
307 Object: "Mutation",
308 Field: field,
309 IsMethod: true,
310 IsResolver: true,
311 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
312 switch field.Name {
313 case "clientMutationId":
314 return ec.fieldContext_AddCommentPayload_clientMutationId(ctx, field)
315 case "bug":
316 return ec.fieldContext_AddCommentPayload_bug(ctx, field)
317 case "operation":
318 return ec.fieldContext_AddCommentPayload_operation(ctx, field)
319 }
320 return nil, fmt.Errorf("no field named %q was found under type AddCommentPayload", field.Name)
321 },
322 }
323 defer func() {
324 if r := recover(); r != nil {
325 err = ec.Recover(ctx, r)
326 ec.Error(ctx, err)
327 }
328 }()
329 ctx = graphql.WithFieldContext(ctx, fc)
330 if fc.Args, err = ec.field_Mutation_addComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
331 ec.Error(ctx, err)
332 return fc, err
333 }
334 return fc, nil
335}
336
337func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
338 fc, err := ec.fieldContext_Mutation_addCommentAndClose(ctx, field)
339 if err != nil {
340 return graphql.Null
341 }
342 ctx = graphql.WithFieldContext(ctx, fc)
343 defer func() {
344 if r := recover(); r != nil {
345 ec.Error(ctx, ec.Recover(ctx, r))
346 ret = graphql.Null
347 }
348 }()
349 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
350 ctx = rctx // use context from middleware stack in children
351 return ec.resolvers.Mutation().AddCommentAndClose(rctx, fc.Args["input"].(models.AddCommentAndCloseBugInput))
352 })
353 if err != nil {
354 ec.Error(ctx, err)
355 return graphql.Null
356 }
357 if resTmp == nil {
358 if !graphql.HasFieldError(ctx, fc) {
359 ec.Errorf(ctx, "must not be null")
360 }
361 return graphql.Null
362 }
363 res := resTmp.(*models.AddCommentAndCloseBugPayload)
364 fc.Result = res
365 return ec.marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx, field.Selections, res)
366}
367
368func (ec *executionContext) fieldContext_Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
369 fc = &graphql.FieldContext{
370 Object: "Mutation",
371 Field: field,
372 IsMethod: true,
373 IsResolver: true,
374 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
375 switch field.Name {
376 case "clientMutationId":
377 return ec.fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx, field)
378 case "bug":
379 return ec.fieldContext_AddCommentAndCloseBugPayload_bug(ctx, field)
380 case "commentOperation":
381 return ec.fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx, field)
382 case "statusOperation":
383 return ec.fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx, field)
384 }
385 return nil, fmt.Errorf("no field named %q was found under type AddCommentAndCloseBugPayload", field.Name)
386 },
387 }
388 defer func() {
389 if r := recover(); r != nil {
390 err = ec.Recover(ctx, r)
391 ec.Error(ctx, err)
392 }
393 }()
394 ctx = graphql.WithFieldContext(ctx, fc)
395 if fc.Args, err = ec.field_Mutation_addCommentAndClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
396 ec.Error(ctx, err)
397 return fc, err
398 }
399 return fc, nil
400}
401
402func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
403 fc, err := ec.fieldContext_Mutation_addCommentAndReopen(ctx, field)
404 if err != nil {
405 return graphql.Null
406 }
407 ctx = graphql.WithFieldContext(ctx, fc)
408 defer func() {
409 if r := recover(); r != nil {
410 ec.Error(ctx, ec.Recover(ctx, r))
411 ret = graphql.Null
412 }
413 }()
414 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
415 ctx = rctx // use context from middleware stack in children
416 return ec.resolvers.Mutation().AddCommentAndReopen(rctx, fc.Args["input"].(models.AddCommentAndReopenBugInput))
417 })
418 if err != nil {
419 ec.Error(ctx, err)
420 return graphql.Null
421 }
422 if resTmp == nil {
423 if !graphql.HasFieldError(ctx, fc) {
424 ec.Errorf(ctx, "must not be null")
425 }
426 return graphql.Null
427 }
428 res := resTmp.(*models.AddCommentAndReopenBugPayload)
429 fc.Result = res
430 return ec.marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx, field.Selections, res)
431}
432
433func (ec *executionContext) fieldContext_Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
434 fc = &graphql.FieldContext{
435 Object: "Mutation",
436 Field: field,
437 IsMethod: true,
438 IsResolver: true,
439 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
440 switch field.Name {
441 case "clientMutationId":
442 return ec.fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx, field)
443 case "bug":
444 return ec.fieldContext_AddCommentAndReopenBugPayload_bug(ctx, field)
445 case "commentOperation":
446 return ec.fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx, field)
447 case "statusOperation":
448 return ec.fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx, field)
449 }
450 return nil, fmt.Errorf("no field named %q was found under type AddCommentAndReopenBugPayload", field.Name)
451 },
452 }
453 defer func() {
454 if r := recover(); r != nil {
455 err = ec.Recover(ctx, r)
456 ec.Error(ctx, err)
457 }
458 }()
459 ctx = graphql.WithFieldContext(ctx, fc)
460 if fc.Args, err = ec.field_Mutation_addCommentAndReopen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
461 ec.Error(ctx, err)
462 return fc, err
463 }
464 return fc, nil
465}
466
467func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
468 fc, err := ec.fieldContext_Mutation_editComment(ctx, field)
469 if err != nil {
470 return graphql.Null
471 }
472 ctx = graphql.WithFieldContext(ctx, fc)
473 defer func() {
474 if r := recover(); r != nil {
475 ec.Error(ctx, ec.Recover(ctx, r))
476 ret = graphql.Null
477 }
478 }()
479 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
480 ctx = rctx // use context from middleware stack in children
481 return ec.resolvers.Mutation().EditComment(rctx, fc.Args["input"].(models.EditCommentInput))
482 })
483 if err != nil {
484 ec.Error(ctx, err)
485 return graphql.Null
486 }
487 if resTmp == nil {
488 if !graphql.HasFieldError(ctx, fc) {
489 ec.Errorf(ctx, "must not be null")
490 }
491 return graphql.Null
492 }
493 res := resTmp.(*models.EditCommentPayload)
494 fc.Result = res
495 return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
496}
497
498func (ec *executionContext) fieldContext_Mutation_editComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
499 fc = &graphql.FieldContext{
500 Object: "Mutation",
501 Field: field,
502 IsMethod: true,
503 IsResolver: true,
504 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
505 switch field.Name {
506 case "clientMutationId":
507 return ec.fieldContext_EditCommentPayload_clientMutationId(ctx, field)
508 case "bug":
509 return ec.fieldContext_EditCommentPayload_bug(ctx, field)
510 case "operation":
511 return ec.fieldContext_EditCommentPayload_operation(ctx, field)
512 }
513 return nil, fmt.Errorf("no field named %q was found under type EditCommentPayload", field.Name)
514 },
515 }
516 defer func() {
517 if r := recover(); r != nil {
518 err = ec.Recover(ctx, r)
519 ec.Error(ctx, err)
520 }
521 }()
522 ctx = graphql.WithFieldContext(ctx, fc)
523 if fc.Args, err = ec.field_Mutation_editComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
524 ec.Error(ctx, err)
525 return fc, err
526 }
527 return fc, nil
528}
529
530func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
531 fc, err := ec.fieldContext_Mutation_changeLabels(ctx, field)
532 if err != nil {
533 return graphql.Null
534 }
535 ctx = graphql.WithFieldContext(ctx, fc)
536 defer func() {
537 if r := recover(); r != nil {
538 ec.Error(ctx, ec.Recover(ctx, r))
539 ret = graphql.Null
540 }
541 }()
542 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
543 ctx = rctx // use context from middleware stack in children
544 return ec.resolvers.Mutation().ChangeLabels(rctx, fc.Args["input"].(*models.ChangeLabelInput))
545 })
546 if err != nil {
547 ec.Error(ctx, err)
548 return graphql.Null
549 }
550 if resTmp == nil {
551 if !graphql.HasFieldError(ctx, fc) {
552 ec.Errorf(ctx, "must not be null")
553 }
554 return graphql.Null
555 }
556 res := resTmp.(*models.ChangeLabelPayload)
557 fc.Result = res
558 return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
559}
560
561func (ec *executionContext) fieldContext_Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
562 fc = &graphql.FieldContext{
563 Object: "Mutation",
564 Field: field,
565 IsMethod: true,
566 IsResolver: true,
567 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
568 switch field.Name {
569 case "clientMutationId":
570 return ec.fieldContext_ChangeLabelPayload_clientMutationId(ctx, field)
571 case "bug":
572 return ec.fieldContext_ChangeLabelPayload_bug(ctx, field)
573 case "operation":
574 return ec.fieldContext_ChangeLabelPayload_operation(ctx, field)
575 case "results":
576 return ec.fieldContext_ChangeLabelPayload_results(ctx, field)
577 }
578 return nil, fmt.Errorf("no field named %q was found under type ChangeLabelPayload", field.Name)
579 },
580 }
581 defer func() {
582 if r := recover(); r != nil {
583 err = ec.Recover(ctx, r)
584 ec.Error(ctx, err)
585 }
586 }()
587 ctx = graphql.WithFieldContext(ctx, fc)
588 if fc.Args, err = ec.field_Mutation_changeLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
589 ec.Error(ctx, err)
590 return fc, err
591 }
592 return fc, nil
593}
594
595func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
596 fc, err := ec.fieldContext_Mutation_openBug(ctx, field)
597 if err != nil {
598 return graphql.Null
599 }
600 ctx = graphql.WithFieldContext(ctx, fc)
601 defer func() {
602 if r := recover(); r != nil {
603 ec.Error(ctx, ec.Recover(ctx, r))
604 ret = graphql.Null
605 }
606 }()
607 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
608 ctx = rctx // use context from middleware stack in children
609 return ec.resolvers.Mutation().OpenBug(rctx, fc.Args["input"].(models.OpenBugInput))
610 })
611 if err != nil {
612 ec.Error(ctx, err)
613 return graphql.Null
614 }
615 if resTmp == nil {
616 if !graphql.HasFieldError(ctx, fc) {
617 ec.Errorf(ctx, "must not be null")
618 }
619 return graphql.Null
620 }
621 res := resTmp.(*models.OpenBugPayload)
622 fc.Result = res
623 return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
624}
625
626func (ec *executionContext) fieldContext_Mutation_openBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
627 fc = &graphql.FieldContext{
628 Object: "Mutation",
629 Field: field,
630 IsMethod: true,
631 IsResolver: true,
632 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
633 switch field.Name {
634 case "clientMutationId":
635 return ec.fieldContext_OpenBugPayload_clientMutationId(ctx, field)
636 case "bug":
637 return ec.fieldContext_OpenBugPayload_bug(ctx, field)
638 case "operation":
639 return ec.fieldContext_OpenBugPayload_operation(ctx, field)
640 }
641 return nil, fmt.Errorf("no field named %q was found under type OpenBugPayload", field.Name)
642 },
643 }
644 defer func() {
645 if r := recover(); r != nil {
646 err = ec.Recover(ctx, r)
647 ec.Error(ctx, err)
648 }
649 }()
650 ctx = graphql.WithFieldContext(ctx, fc)
651 if fc.Args, err = ec.field_Mutation_openBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
652 ec.Error(ctx, err)
653 return fc, err
654 }
655 return fc, nil
656}
657
658func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
659 fc, err := ec.fieldContext_Mutation_closeBug(ctx, field)
660 if err != nil {
661 return graphql.Null
662 }
663 ctx = graphql.WithFieldContext(ctx, fc)
664 defer func() {
665 if r := recover(); r != nil {
666 ec.Error(ctx, ec.Recover(ctx, r))
667 ret = graphql.Null
668 }
669 }()
670 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
671 ctx = rctx // use context from middleware stack in children
672 return ec.resolvers.Mutation().CloseBug(rctx, fc.Args["input"].(models.CloseBugInput))
673 })
674 if err != nil {
675 ec.Error(ctx, err)
676 return graphql.Null
677 }
678 if resTmp == nil {
679 if !graphql.HasFieldError(ctx, fc) {
680 ec.Errorf(ctx, "must not be null")
681 }
682 return graphql.Null
683 }
684 res := resTmp.(*models.CloseBugPayload)
685 fc.Result = res
686 return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
687}
688
689func (ec *executionContext) fieldContext_Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
690 fc = &graphql.FieldContext{
691 Object: "Mutation",
692 Field: field,
693 IsMethod: true,
694 IsResolver: true,
695 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
696 switch field.Name {
697 case "clientMutationId":
698 return ec.fieldContext_CloseBugPayload_clientMutationId(ctx, field)
699 case "bug":
700 return ec.fieldContext_CloseBugPayload_bug(ctx, field)
701 case "operation":
702 return ec.fieldContext_CloseBugPayload_operation(ctx, field)
703 }
704 return nil, fmt.Errorf("no field named %q was found under type CloseBugPayload", field.Name)
705 },
706 }
707 defer func() {
708 if r := recover(); r != nil {
709 err = ec.Recover(ctx, r)
710 ec.Error(ctx, err)
711 }
712 }()
713 ctx = graphql.WithFieldContext(ctx, fc)
714 if fc.Args, err = ec.field_Mutation_closeBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
715 ec.Error(ctx, err)
716 return fc, err
717 }
718 return fc, nil
719}
720
721func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
722 fc, err := ec.fieldContext_Mutation_setTitle(ctx, field)
723 if err != nil {
724 return graphql.Null
725 }
726 ctx = graphql.WithFieldContext(ctx, fc)
727 defer func() {
728 if r := recover(); r != nil {
729 ec.Error(ctx, ec.Recover(ctx, r))
730 ret = graphql.Null
731 }
732 }()
733 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
734 ctx = rctx // use context from middleware stack in children
735 return ec.resolvers.Mutation().SetTitle(rctx, fc.Args["input"].(models.SetTitleInput))
736 })
737 if err != nil {
738 ec.Error(ctx, err)
739 return graphql.Null
740 }
741 if resTmp == nil {
742 if !graphql.HasFieldError(ctx, fc) {
743 ec.Errorf(ctx, "must not be null")
744 }
745 return graphql.Null
746 }
747 res := resTmp.(*models.SetTitlePayload)
748 fc.Result = res
749 return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
750}
751
752func (ec *executionContext) fieldContext_Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
753 fc = &graphql.FieldContext{
754 Object: "Mutation",
755 Field: field,
756 IsMethod: true,
757 IsResolver: true,
758 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
759 switch field.Name {
760 case "clientMutationId":
761 return ec.fieldContext_SetTitlePayload_clientMutationId(ctx, field)
762 case "bug":
763 return ec.fieldContext_SetTitlePayload_bug(ctx, field)
764 case "operation":
765 return ec.fieldContext_SetTitlePayload_operation(ctx, field)
766 }
767 return nil, fmt.Errorf("no field named %q was found under type SetTitlePayload", field.Name)
768 },
769 }
770 defer func() {
771 if r := recover(); r != nil {
772 err = ec.Recover(ctx, r)
773 ec.Error(ctx, err)
774 }
775 }()
776 ctx = graphql.WithFieldContext(ctx, fc)
777 if fc.Args, err = ec.field_Mutation_setTitle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
778 ec.Error(ctx, err)
779 return fc, err
780 }
781 return fc, nil
782}
783
784func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
785 fc, err := ec.fieldContext_Query_repository(ctx, field)
786 if err != nil {
787 return graphql.Null
788 }
789 ctx = graphql.WithFieldContext(ctx, fc)
790 defer func() {
791 if r := recover(); r != nil {
792 ec.Error(ctx, ec.Recover(ctx, r))
793 ret = graphql.Null
794 }
795 }()
796 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
797 ctx = rctx // use context from middleware stack in children
798 return ec.resolvers.Query().Repository(rctx, fc.Args["ref"].(*string))
799 })
800 if err != nil {
801 ec.Error(ctx, err)
802 return graphql.Null
803 }
804 if resTmp == nil {
805 return graphql.Null
806 }
807 res := resTmp.(*models.Repository)
808 fc.Result = res
809 return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
810}
811
812func (ec *executionContext) fieldContext_Query_repository(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
813 fc = &graphql.FieldContext{
814 Object: "Query",
815 Field: field,
816 IsMethod: true,
817 IsResolver: true,
818 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
819 switch field.Name {
820 case "name":
821 return ec.fieldContext_Repository_name(ctx, field)
822 case "allBugs":
823 return ec.fieldContext_Repository_allBugs(ctx, field)
824 case "bug":
825 return ec.fieldContext_Repository_bug(ctx, field)
826 case "allIdentities":
827 return ec.fieldContext_Repository_allIdentities(ctx, field)
828 case "identity":
829 return ec.fieldContext_Repository_identity(ctx, field)
830 case "userIdentity":
831 return ec.fieldContext_Repository_userIdentity(ctx, field)
832 case "validLabels":
833 return ec.fieldContext_Repository_validLabels(ctx, field)
834 }
835 return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
836 },
837 }
838 defer func() {
839 if r := recover(); r != nil {
840 err = ec.Recover(ctx, r)
841 ec.Error(ctx, err)
842 }
843 }()
844 ctx = graphql.WithFieldContext(ctx, fc)
845 if fc.Args, err = ec.field_Query_repository_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
846 ec.Error(ctx, err)
847 return fc, err
848 }
849 return fc, nil
850}
851
852func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
853 fc, err := ec.fieldContext_Query___type(ctx, field)
854 if err != nil {
855 return graphql.Null
856 }
857 ctx = graphql.WithFieldContext(ctx, fc)
858 defer func() {
859 if r := recover(); r != nil {
860 ec.Error(ctx, ec.Recover(ctx, r))
861 ret = graphql.Null
862 }
863 }()
864 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
865 ctx = rctx // use context from middleware stack in children
866 return ec.introspectType(fc.Args["name"].(string))
867 })
868 if err != nil {
869 ec.Error(ctx, err)
870 return graphql.Null
871 }
872 if resTmp == nil {
873 return graphql.Null
874 }
875 res := resTmp.(*introspection.Type)
876 fc.Result = res
877 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
878}
879
880func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
881 fc = &graphql.FieldContext{
882 Object: "Query",
883 Field: field,
884 IsMethod: true,
885 IsResolver: false,
886 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
887 switch field.Name {
888 case "kind":
889 return ec.fieldContext___Type_kind(ctx, field)
890 case "name":
891 return ec.fieldContext___Type_name(ctx, field)
892 case "description":
893 return ec.fieldContext___Type_description(ctx, field)
894 case "fields":
895 return ec.fieldContext___Type_fields(ctx, field)
896 case "interfaces":
897 return ec.fieldContext___Type_interfaces(ctx, field)
898 case "possibleTypes":
899 return ec.fieldContext___Type_possibleTypes(ctx, field)
900 case "enumValues":
901 return ec.fieldContext___Type_enumValues(ctx, field)
902 case "inputFields":
903 return ec.fieldContext___Type_inputFields(ctx, field)
904 case "ofType":
905 return ec.fieldContext___Type_ofType(ctx, field)
906 case "specifiedByURL":
907 return ec.fieldContext___Type_specifiedByURL(ctx, field)
908 }
909 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
910 },
911 }
912 defer func() {
913 if r := recover(); r != nil {
914 err = ec.Recover(ctx, r)
915 ec.Error(ctx, err)
916 }
917 }()
918 ctx = graphql.WithFieldContext(ctx, fc)
919 if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
920 ec.Error(ctx, err)
921 return fc, err
922 }
923 return fc, nil
924}
925
926func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
927 fc, err := ec.fieldContext_Query___schema(ctx, field)
928 if err != nil {
929 return graphql.Null
930 }
931 ctx = graphql.WithFieldContext(ctx, fc)
932 defer func() {
933 if r := recover(); r != nil {
934 ec.Error(ctx, ec.Recover(ctx, r))
935 ret = graphql.Null
936 }
937 }()
938 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
939 ctx = rctx // use context from middleware stack in children
940 return ec.introspectSchema()
941 })
942 if err != nil {
943 ec.Error(ctx, err)
944 return graphql.Null
945 }
946 if resTmp == nil {
947 return graphql.Null
948 }
949 res := resTmp.(*introspection.Schema)
950 fc.Result = res
951 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
952}
953
954func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
955 fc = &graphql.FieldContext{
956 Object: "Query",
957 Field: field,
958 IsMethod: true,
959 IsResolver: false,
960 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
961 switch field.Name {
962 case "description":
963 return ec.fieldContext___Schema_description(ctx, field)
964 case "types":
965 return ec.fieldContext___Schema_types(ctx, field)
966 case "queryType":
967 return ec.fieldContext___Schema_queryType(ctx, field)
968 case "mutationType":
969 return ec.fieldContext___Schema_mutationType(ctx, field)
970 case "subscriptionType":
971 return ec.fieldContext___Schema_subscriptionType(ctx, field)
972 case "directives":
973 return ec.fieldContext___Schema_directives(ctx, field)
974 }
975 return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
976 },
977 }
978 return fc, nil
979}
980
981// endregion **************************** field.gotpl *****************************
982
983// region **************************** input.gotpl *****************************
984
985// endregion **************************** input.gotpl *****************************
986
987// region ************************** interface.gotpl ***************************
988
989// endregion ************************** interface.gotpl ***************************
990
991// region **************************** object.gotpl ****************************
992
993var mutationImplementors = []string{"Mutation"}
994
995func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
996 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
997 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
998 Object: "Mutation",
999 })
1000
1001 out := graphql.NewFieldSet(fields)
1002 deferred := make(map[string]*graphql.FieldSet)
1003 for i, field := range fields {
1004 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
1005 Object: field.Name,
1006 Field: field,
1007 })
1008
1009 switch field.Name {
1010 case "__typename":
1011 out.Values[i] = graphql.MarshalString("Mutation")
1012 case "newBug":
1013 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1014 return ec._Mutation_newBug(ctx, field)
1015 })
1016 if out.Values[i] == graphql.Null {
1017 out.Invalids++
1018 }
1019 case "addComment":
1020 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1021 return ec._Mutation_addComment(ctx, field)
1022 })
1023 if out.Values[i] == graphql.Null {
1024 out.Invalids++
1025 }
1026 case "addCommentAndClose":
1027 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1028 return ec._Mutation_addCommentAndClose(ctx, field)
1029 })
1030 if out.Values[i] == graphql.Null {
1031 out.Invalids++
1032 }
1033 case "addCommentAndReopen":
1034 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1035 return ec._Mutation_addCommentAndReopen(ctx, field)
1036 })
1037 if out.Values[i] == graphql.Null {
1038 out.Invalids++
1039 }
1040 case "editComment":
1041 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1042 return ec._Mutation_editComment(ctx, field)
1043 })
1044 if out.Values[i] == graphql.Null {
1045 out.Invalids++
1046 }
1047 case "changeLabels":
1048 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1049 return ec._Mutation_changeLabels(ctx, field)
1050 })
1051 if out.Values[i] == graphql.Null {
1052 out.Invalids++
1053 }
1054 case "openBug":
1055 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1056 return ec._Mutation_openBug(ctx, field)
1057 })
1058 if out.Values[i] == graphql.Null {
1059 out.Invalids++
1060 }
1061 case "closeBug":
1062 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1063 return ec._Mutation_closeBug(ctx, field)
1064 })
1065 if out.Values[i] == graphql.Null {
1066 out.Invalids++
1067 }
1068 case "setTitle":
1069 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1070 return ec._Mutation_setTitle(ctx, field)
1071 })
1072 if out.Values[i] == graphql.Null {
1073 out.Invalids++
1074 }
1075 default:
1076 panic("unknown field " + strconv.Quote(field.Name))
1077 }
1078 }
1079 out.Dispatch(ctx)
1080 if out.Invalids > 0 {
1081 return graphql.Null
1082 }
1083
1084 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1085
1086 for label, dfs := range deferred {
1087 ec.processDeferredGroup(graphql.DeferredGroup{
1088 Label: label,
1089 Path: graphql.GetPath(ctx),
1090 FieldSet: dfs,
1091 Context: ctx,
1092 })
1093 }
1094
1095 return out
1096}
1097
1098var queryImplementors = []string{"Query"}
1099
1100func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
1101 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
1102 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
1103 Object: "Query",
1104 })
1105
1106 out := graphql.NewFieldSet(fields)
1107 deferred := make(map[string]*graphql.FieldSet)
1108 for i, field := range fields {
1109 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
1110 Object: field.Name,
1111 Field: field,
1112 })
1113
1114 switch field.Name {
1115 case "__typename":
1116 out.Values[i] = graphql.MarshalString("Query")
1117 case "repository":
1118 field := field
1119
1120 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1121 defer func() {
1122 if r := recover(); r != nil {
1123 ec.Error(ctx, ec.Recover(ctx, r))
1124 }
1125 }()
1126 res = ec._Query_repository(ctx, field)
1127 return res
1128 }
1129
1130 rrm := func(ctx context.Context) graphql.Marshaler {
1131 return ec.OperationContext.RootResolverMiddleware(ctx,
1132 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1133 }
1134
1135 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
1136 case "__type":
1137 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1138 return ec._Query___type(ctx, field)
1139 })
1140 case "__schema":
1141 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1142 return ec._Query___schema(ctx, field)
1143 })
1144 default:
1145 panic("unknown field " + strconv.Quote(field.Name))
1146 }
1147 }
1148 out.Dispatch(ctx)
1149 if out.Invalids > 0 {
1150 return graphql.Null
1151 }
1152
1153 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1154
1155 for label, dfs := range deferred {
1156 ec.processDeferredGroup(graphql.DeferredGroup{
1157 Label: label,
1158 Path: graphql.GetPath(ctx),
1159 FieldSet: dfs,
1160 Context: ctx,
1161 })
1162 }
1163
1164 return out
1165}
1166
1167// endregion **************************** object.gotpl ****************************
1168
1169// region ***************************** type.gotpl *****************************
1170
1171// endregion ***************************** type.gotpl *****************************