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