1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2
3package graph
4
5import (
6 "context"
7 "errors"
8 "fmt"
9 "strconv"
10 "sync/atomic"
11 "time"
12
13 "github.com/99designs/gqlgen/graphql"
14 "github.com/git-bug/git-bug/api/graphql/models"
15 "github.com/git-bug/git-bug/entities/board"
16 "github.com/git-bug/git-bug/entity"
17 "github.com/vektah/gqlparser/v2/ast"
18)
19
20// region ************************** generated!.gotpl **************************
21
22type BoardAddItemDraftOperationResolver interface {
23 Author(ctx context.Context, obj *board.AddItemDraftOperation) (models.IdentityWrapper, error)
24}
25type BoardAddItemEntityOperationResolver interface {
26 Author(ctx context.Context, obj *board.AddItemEntityOperation) (models.IdentityWrapper, error)
27
28 EntityType(ctx context.Context, obj *board.AddItemEntityOperation) (models.BoardItemEntityType, error)
29}
30type BoardCreateOperationResolver interface {
31 Author(ctx context.Context, obj *board.CreateOperation) (models.IdentityWrapper, error)
32}
33type BoardSetDescriptionOperationResolver interface {
34 Author(ctx context.Context, obj *board.SetDescriptionOperation) (models.IdentityWrapper, error)
35}
36type BoardSetTitleOperationResolver interface {
37 Author(ctx context.Context, obj *board.SetTitleOperation) (models.IdentityWrapper, error)
38}
39
40// endregion ************************** generated!.gotpl **************************
41
42// region ***************************** args.gotpl *****************************
43
44// endregion ***************************** args.gotpl *****************************
45
46// region ************************** directives.gotpl **************************
47
48// endregion ************************** directives.gotpl **************************
49
50// region **************************** field.gotpl *****************************
51
52func (ec *executionContext) _BoardAddItemDraftOperation_id(ctx context.Context, field graphql.CollectedField, obj *board.AddItemDraftOperation) (ret graphql.Marshaler) {
53 fc, err := ec.fieldContext_BoardAddItemDraftOperation_id(ctx, field)
54 if err != nil {
55 return graphql.Null
56 }
57 ctx = graphql.WithFieldContext(ctx, fc)
58 defer func() {
59 if r := recover(); r != nil {
60 ec.Error(ctx, ec.Recover(ctx, r))
61 ret = graphql.Null
62 }
63 }()
64 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
65 ctx = rctx // use context from middleware stack in children
66 return obj.Id(), nil
67 })
68 if err != nil {
69 ec.Error(ctx, err)
70 return graphql.Null
71 }
72 if resTmp == nil {
73 if !graphql.HasFieldError(ctx, fc) {
74 ec.Errorf(ctx, "must not be null")
75 }
76 return graphql.Null
77 }
78 res := resTmp.(entity.Id)
79 fc.Result = res
80 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
81}
82
83func (ec *executionContext) fieldContext_BoardAddItemDraftOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
84 fc = &graphql.FieldContext{
85 Object: "BoardAddItemDraftOperation",
86 Field: field,
87 IsMethod: true,
88 IsResolver: false,
89 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
90 return nil, errors.New("field of type ID does not have child fields")
91 },
92 }
93 return fc, nil
94}
95
96func (ec *executionContext) _BoardAddItemDraftOperation_author(ctx context.Context, field graphql.CollectedField, obj *board.AddItemDraftOperation) (ret graphql.Marshaler) {
97 fc, err := ec.fieldContext_BoardAddItemDraftOperation_author(ctx, field)
98 if err != nil {
99 return graphql.Null
100 }
101 ctx = graphql.WithFieldContext(ctx, fc)
102 defer func() {
103 if r := recover(); r != nil {
104 ec.Error(ctx, ec.Recover(ctx, r))
105 ret = graphql.Null
106 }
107 }()
108 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
109 ctx = rctx // use context from middleware stack in children
110 return ec.resolvers.BoardAddItemDraftOperation().Author(rctx, obj)
111 })
112 if err != nil {
113 ec.Error(ctx, err)
114 return graphql.Null
115 }
116 if resTmp == nil {
117 if !graphql.HasFieldError(ctx, fc) {
118 ec.Errorf(ctx, "must not be null")
119 }
120 return graphql.Null
121 }
122 res := resTmp.(models.IdentityWrapper)
123 fc.Result = res
124 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
125}
126
127func (ec *executionContext) fieldContext_BoardAddItemDraftOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
128 fc = &graphql.FieldContext{
129 Object: "BoardAddItemDraftOperation",
130 Field: field,
131 IsMethod: true,
132 IsResolver: true,
133 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
134 switch field.Name {
135 case "id":
136 return ec.fieldContext_Identity_id(ctx, field)
137 case "humanId":
138 return ec.fieldContext_Identity_humanId(ctx, field)
139 case "name":
140 return ec.fieldContext_Identity_name(ctx, field)
141 case "email":
142 return ec.fieldContext_Identity_email(ctx, field)
143 case "login":
144 return ec.fieldContext_Identity_login(ctx, field)
145 case "displayName":
146 return ec.fieldContext_Identity_displayName(ctx, field)
147 case "avatarUrl":
148 return ec.fieldContext_Identity_avatarUrl(ctx, field)
149 case "isProtected":
150 return ec.fieldContext_Identity_isProtected(ctx, field)
151 }
152 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
153 },
154 }
155 return fc, nil
156}
157
158func (ec *executionContext) _BoardAddItemDraftOperation_date(ctx context.Context, field graphql.CollectedField, obj *board.AddItemDraftOperation) (ret graphql.Marshaler) {
159 fc, err := ec.fieldContext_BoardAddItemDraftOperation_date(ctx, field)
160 if err != nil {
161 return graphql.Null
162 }
163 ctx = graphql.WithFieldContext(ctx, fc)
164 defer func() {
165 if r := recover(); r != nil {
166 ec.Error(ctx, ec.Recover(ctx, r))
167 ret = graphql.Null
168 }
169 }()
170 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
171 ctx = rctx // use context from middleware stack in children
172 return obj.Time(), nil
173 })
174 if err != nil {
175 ec.Error(ctx, err)
176 return graphql.Null
177 }
178 if resTmp == nil {
179 if !graphql.HasFieldError(ctx, fc) {
180 ec.Errorf(ctx, "must not be null")
181 }
182 return graphql.Null
183 }
184 res := resTmp.(time.Time)
185 fc.Result = res
186 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
187}
188
189func (ec *executionContext) fieldContext_BoardAddItemDraftOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
190 fc = &graphql.FieldContext{
191 Object: "BoardAddItemDraftOperation",
192 Field: field,
193 IsMethod: true,
194 IsResolver: false,
195 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
196 return nil, errors.New("field of type Time does not have child fields")
197 },
198 }
199 return fc, nil
200}
201
202func (ec *executionContext) _BoardAddItemDraftOperation_columnId(ctx context.Context, field graphql.CollectedField, obj *board.AddItemDraftOperation) (ret graphql.Marshaler) {
203 fc, err := ec.fieldContext_BoardAddItemDraftOperation_columnId(ctx, field)
204 if err != nil {
205 return graphql.Null
206 }
207 ctx = graphql.WithFieldContext(ctx, fc)
208 defer func() {
209 if r := recover(); r != nil {
210 ec.Error(ctx, ec.Recover(ctx, r))
211 ret = graphql.Null
212 }
213 }()
214 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
215 ctx = rctx // use context from middleware stack in children
216 return obj.ColumnId, nil
217 })
218 if err != nil {
219 ec.Error(ctx, err)
220 return graphql.Null
221 }
222 if resTmp == nil {
223 if !graphql.HasFieldError(ctx, fc) {
224 ec.Errorf(ctx, "must not be null")
225 }
226 return graphql.Null
227 }
228 res := resTmp.(entity.Id)
229 fc.Result = res
230 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
231}
232
233func (ec *executionContext) fieldContext_BoardAddItemDraftOperation_columnId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
234 fc = &graphql.FieldContext{
235 Object: "BoardAddItemDraftOperation",
236 Field: field,
237 IsMethod: false,
238 IsResolver: false,
239 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
240 return nil, errors.New("field of type ID does not have child fields")
241 },
242 }
243 return fc, nil
244}
245
246func (ec *executionContext) _BoardAddItemDraftOperation_title(ctx context.Context, field graphql.CollectedField, obj *board.AddItemDraftOperation) (ret graphql.Marshaler) {
247 fc, err := ec.fieldContext_BoardAddItemDraftOperation_title(ctx, field)
248 if err != nil {
249 return graphql.Null
250 }
251 ctx = graphql.WithFieldContext(ctx, fc)
252 defer func() {
253 if r := recover(); r != nil {
254 ec.Error(ctx, ec.Recover(ctx, r))
255 ret = graphql.Null
256 }
257 }()
258 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
259 ctx = rctx // use context from middleware stack in children
260 return obj.Title, nil
261 })
262 if err != nil {
263 ec.Error(ctx, err)
264 return graphql.Null
265 }
266 if resTmp == nil {
267 if !graphql.HasFieldError(ctx, fc) {
268 ec.Errorf(ctx, "must not be null")
269 }
270 return graphql.Null
271 }
272 res := resTmp.(string)
273 fc.Result = res
274 return ec.marshalNString2string(ctx, field.Selections, res)
275}
276
277func (ec *executionContext) fieldContext_BoardAddItemDraftOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
278 fc = &graphql.FieldContext{
279 Object: "BoardAddItemDraftOperation",
280 Field: field,
281 IsMethod: false,
282 IsResolver: false,
283 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
284 return nil, errors.New("field of type String does not have child fields")
285 },
286 }
287 return fc, nil
288}
289
290func (ec *executionContext) _BoardAddItemEntityOperation_id(ctx context.Context, field graphql.CollectedField, obj *board.AddItemEntityOperation) (ret graphql.Marshaler) {
291 fc, err := ec.fieldContext_BoardAddItemEntityOperation_id(ctx, field)
292 if err != nil {
293 return graphql.Null
294 }
295 ctx = graphql.WithFieldContext(ctx, fc)
296 defer func() {
297 if r := recover(); r != nil {
298 ec.Error(ctx, ec.Recover(ctx, r))
299 ret = graphql.Null
300 }
301 }()
302 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
303 ctx = rctx // use context from middleware stack in children
304 return obj.Id(), nil
305 })
306 if err != nil {
307 ec.Error(ctx, err)
308 return graphql.Null
309 }
310 if resTmp == nil {
311 if !graphql.HasFieldError(ctx, fc) {
312 ec.Errorf(ctx, "must not be null")
313 }
314 return graphql.Null
315 }
316 res := resTmp.(entity.Id)
317 fc.Result = res
318 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
319}
320
321func (ec *executionContext) fieldContext_BoardAddItemEntityOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
322 fc = &graphql.FieldContext{
323 Object: "BoardAddItemEntityOperation",
324 Field: field,
325 IsMethod: true,
326 IsResolver: false,
327 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
328 return nil, errors.New("field of type ID does not have child fields")
329 },
330 }
331 return fc, nil
332}
333
334func (ec *executionContext) _BoardAddItemEntityOperation_author(ctx context.Context, field graphql.CollectedField, obj *board.AddItemEntityOperation) (ret graphql.Marshaler) {
335 fc, err := ec.fieldContext_BoardAddItemEntityOperation_author(ctx, field)
336 if err != nil {
337 return graphql.Null
338 }
339 ctx = graphql.WithFieldContext(ctx, fc)
340 defer func() {
341 if r := recover(); r != nil {
342 ec.Error(ctx, ec.Recover(ctx, r))
343 ret = graphql.Null
344 }
345 }()
346 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
347 ctx = rctx // use context from middleware stack in children
348 return ec.resolvers.BoardAddItemEntityOperation().Author(rctx, obj)
349 })
350 if err != nil {
351 ec.Error(ctx, err)
352 return graphql.Null
353 }
354 if resTmp == nil {
355 if !graphql.HasFieldError(ctx, fc) {
356 ec.Errorf(ctx, "must not be null")
357 }
358 return graphql.Null
359 }
360 res := resTmp.(models.IdentityWrapper)
361 fc.Result = res
362 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
363}
364
365func (ec *executionContext) fieldContext_BoardAddItemEntityOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
366 fc = &graphql.FieldContext{
367 Object: "BoardAddItemEntityOperation",
368 Field: field,
369 IsMethod: true,
370 IsResolver: true,
371 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
372 switch field.Name {
373 case "id":
374 return ec.fieldContext_Identity_id(ctx, field)
375 case "humanId":
376 return ec.fieldContext_Identity_humanId(ctx, field)
377 case "name":
378 return ec.fieldContext_Identity_name(ctx, field)
379 case "email":
380 return ec.fieldContext_Identity_email(ctx, field)
381 case "login":
382 return ec.fieldContext_Identity_login(ctx, field)
383 case "displayName":
384 return ec.fieldContext_Identity_displayName(ctx, field)
385 case "avatarUrl":
386 return ec.fieldContext_Identity_avatarUrl(ctx, field)
387 case "isProtected":
388 return ec.fieldContext_Identity_isProtected(ctx, field)
389 }
390 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
391 },
392 }
393 return fc, nil
394}
395
396func (ec *executionContext) _BoardAddItemEntityOperation_date(ctx context.Context, field graphql.CollectedField, obj *board.AddItemEntityOperation) (ret graphql.Marshaler) {
397 fc, err := ec.fieldContext_BoardAddItemEntityOperation_date(ctx, field)
398 if err != nil {
399 return graphql.Null
400 }
401 ctx = graphql.WithFieldContext(ctx, fc)
402 defer func() {
403 if r := recover(); r != nil {
404 ec.Error(ctx, ec.Recover(ctx, r))
405 ret = graphql.Null
406 }
407 }()
408 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
409 ctx = rctx // use context from middleware stack in children
410 return obj.Time(), nil
411 })
412 if err != nil {
413 ec.Error(ctx, err)
414 return graphql.Null
415 }
416 if resTmp == nil {
417 if !graphql.HasFieldError(ctx, fc) {
418 ec.Errorf(ctx, "must not be null")
419 }
420 return graphql.Null
421 }
422 res := resTmp.(time.Time)
423 fc.Result = res
424 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
425}
426
427func (ec *executionContext) fieldContext_BoardAddItemEntityOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
428 fc = &graphql.FieldContext{
429 Object: "BoardAddItemEntityOperation",
430 Field: field,
431 IsMethod: true,
432 IsResolver: false,
433 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
434 return nil, errors.New("field of type Time does not have child fields")
435 },
436 }
437 return fc, nil
438}
439
440func (ec *executionContext) _BoardAddItemEntityOperation_columnId(ctx context.Context, field graphql.CollectedField, obj *board.AddItemEntityOperation) (ret graphql.Marshaler) {
441 fc, err := ec.fieldContext_BoardAddItemEntityOperation_columnId(ctx, field)
442 if err != nil {
443 return graphql.Null
444 }
445 ctx = graphql.WithFieldContext(ctx, fc)
446 defer func() {
447 if r := recover(); r != nil {
448 ec.Error(ctx, ec.Recover(ctx, r))
449 ret = graphql.Null
450 }
451 }()
452 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
453 ctx = rctx // use context from middleware stack in children
454 return obj.ColumnId, nil
455 })
456 if err != nil {
457 ec.Error(ctx, err)
458 return graphql.Null
459 }
460 if resTmp == nil {
461 if !graphql.HasFieldError(ctx, fc) {
462 ec.Errorf(ctx, "must not be null")
463 }
464 return graphql.Null
465 }
466 res := resTmp.(entity.Id)
467 fc.Result = res
468 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
469}
470
471func (ec *executionContext) fieldContext_BoardAddItemEntityOperation_columnId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
472 fc = &graphql.FieldContext{
473 Object: "BoardAddItemEntityOperation",
474 Field: field,
475 IsMethod: false,
476 IsResolver: false,
477 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
478 return nil, errors.New("field of type ID does not have child fields")
479 },
480 }
481 return fc, nil
482}
483
484func (ec *executionContext) _BoardAddItemEntityOperation_entityType(ctx context.Context, field graphql.CollectedField, obj *board.AddItemEntityOperation) (ret graphql.Marshaler) {
485 fc, err := ec.fieldContext_BoardAddItemEntityOperation_entityType(ctx, field)
486 if err != nil {
487 return graphql.Null
488 }
489 ctx = graphql.WithFieldContext(ctx, fc)
490 defer func() {
491 if r := recover(); r != nil {
492 ec.Error(ctx, ec.Recover(ctx, r))
493 ret = graphql.Null
494 }
495 }()
496 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
497 ctx = rctx // use context from middleware stack in children
498 return ec.resolvers.BoardAddItemEntityOperation().EntityType(rctx, obj)
499 })
500 if err != nil {
501 ec.Error(ctx, err)
502 return graphql.Null
503 }
504 if resTmp == nil {
505 if !graphql.HasFieldError(ctx, fc) {
506 ec.Errorf(ctx, "must not be null")
507 }
508 return graphql.Null
509 }
510 res := resTmp.(models.BoardItemEntityType)
511 fc.Result = res
512 return ec.marshalNBoardItemEntityType2githubácomágitábugágitábugáapiágraphqlámodelsáBoardItemEntityType(ctx, field.Selections, res)
513}
514
515func (ec *executionContext) fieldContext_BoardAddItemEntityOperation_entityType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
516 fc = &graphql.FieldContext{
517 Object: "BoardAddItemEntityOperation",
518 Field: field,
519 IsMethod: true,
520 IsResolver: true,
521 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
522 return nil, errors.New("field of type BoardItemEntityType does not have child fields")
523 },
524 }
525 return fc, nil
526}
527
528func (ec *executionContext) _BoardAddItemEntityOperation_entityId(ctx context.Context, field graphql.CollectedField, obj *board.AddItemEntityOperation) (ret graphql.Marshaler) {
529 fc, err := ec.fieldContext_BoardAddItemEntityOperation_entityId(ctx, field)
530 if err != nil {
531 return graphql.Null
532 }
533 ctx = graphql.WithFieldContext(ctx, fc)
534 defer func() {
535 if r := recover(); r != nil {
536 ec.Error(ctx, ec.Recover(ctx, r))
537 ret = graphql.Null
538 }
539 }()
540 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
541 ctx = rctx // use context from middleware stack in children
542 return obj.EntityId, nil
543 })
544 if err != nil {
545 ec.Error(ctx, err)
546 return graphql.Null
547 }
548 if resTmp == nil {
549 if !graphql.HasFieldError(ctx, fc) {
550 ec.Errorf(ctx, "must not be null")
551 }
552 return graphql.Null
553 }
554 res := resTmp.(entity.Id)
555 fc.Result = res
556 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
557}
558
559func (ec *executionContext) fieldContext_BoardAddItemEntityOperation_entityId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
560 fc = &graphql.FieldContext{
561 Object: "BoardAddItemEntityOperation",
562 Field: field,
563 IsMethod: false,
564 IsResolver: false,
565 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
566 return nil, errors.New("field of type ID does not have child fields")
567 },
568 }
569 return fc, nil
570}
571
572func (ec *executionContext) _BoardCreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *board.CreateOperation) (ret graphql.Marshaler) {
573 fc, err := ec.fieldContext_BoardCreateOperation_id(ctx, field)
574 if err != nil {
575 return graphql.Null
576 }
577 ctx = graphql.WithFieldContext(ctx, fc)
578 defer func() {
579 if r := recover(); r != nil {
580 ec.Error(ctx, ec.Recover(ctx, r))
581 ret = graphql.Null
582 }
583 }()
584 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
585 ctx = rctx // use context from middleware stack in children
586 return obj.Id(), nil
587 })
588 if err != nil {
589 ec.Error(ctx, err)
590 return graphql.Null
591 }
592 if resTmp == nil {
593 if !graphql.HasFieldError(ctx, fc) {
594 ec.Errorf(ctx, "must not be null")
595 }
596 return graphql.Null
597 }
598 res := resTmp.(entity.Id)
599 fc.Result = res
600 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
601}
602
603func (ec *executionContext) fieldContext_BoardCreateOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
604 fc = &graphql.FieldContext{
605 Object: "BoardCreateOperation",
606 Field: field,
607 IsMethod: true,
608 IsResolver: false,
609 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
610 return nil, errors.New("field of type ID does not have child fields")
611 },
612 }
613 return fc, nil
614}
615
616func (ec *executionContext) _BoardCreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *board.CreateOperation) (ret graphql.Marshaler) {
617 fc, err := ec.fieldContext_BoardCreateOperation_author(ctx, field)
618 if err != nil {
619 return graphql.Null
620 }
621 ctx = graphql.WithFieldContext(ctx, fc)
622 defer func() {
623 if r := recover(); r != nil {
624 ec.Error(ctx, ec.Recover(ctx, r))
625 ret = graphql.Null
626 }
627 }()
628 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
629 ctx = rctx // use context from middleware stack in children
630 return ec.resolvers.BoardCreateOperation().Author(rctx, obj)
631 })
632 if err != nil {
633 ec.Error(ctx, err)
634 return graphql.Null
635 }
636 if resTmp == nil {
637 if !graphql.HasFieldError(ctx, fc) {
638 ec.Errorf(ctx, "must not be null")
639 }
640 return graphql.Null
641 }
642 res := resTmp.(models.IdentityWrapper)
643 fc.Result = res
644 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
645}
646
647func (ec *executionContext) fieldContext_BoardCreateOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
648 fc = &graphql.FieldContext{
649 Object: "BoardCreateOperation",
650 Field: field,
651 IsMethod: true,
652 IsResolver: true,
653 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
654 switch field.Name {
655 case "id":
656 return ec.fieldContext_Identity_id(ctx, field)
657 case "humanId":
658 return ec.fieldContext_Identity_humanId(ctx, field)
659 case "name":
660 return ec.fieldContext_Identity_name(ctx, field)
661 case "email":
662 return ec.fieldContext_Identity_email(ctx, field)
663 case "login":
664 return ec.fieldContext_Identity_login(ctx, field)
665 case "displayName":
666 return ec.fieldContext_Identity_displayName(ctx, field)
667 case "avatarUrl":
668 return ec.fieldContext_Identity_avatarUrl(ctx, field)
669 case "isProtected":
670 return ec.fieldContext_Identity_isProtected(ctx, field)
671 }
672 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
673 },
674 }
675 return fc, nil
676}
677
678func (ec *executionContext) _BoardCreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *board.CreateOperation) (ret graphql.Marshaler) {
679 fc, err := ec.fieldContext_BoardCreateOperation_date(ctx, field)
680 if err != nil {
681 return graphql.Null
682 }
683 ctx = graphql.WithFieldContext(ctx, fc)
684 defer func() {
685 if r := recover(); r != nil {
686 ec.Error(ctx, ec.Recover(ctx, r))
687 ret = graphql.Null
688 }
689 }()
690 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
691 ctx = rctx // use context from middleware stack in children
692 return obj.Time(), nil
693 })
694 if err != nil {
695 ec.Error(ctx, err)
696 return graphql.Null
697 }
698 if resTmp == nil {
699 if !graphql.HasFieldError(ctx, fc) {
700 ec.Errorf(ctx, "must not be null")
701 }
702 return graphql.Null
703 }
704 res := resTmp.(time.Time)
705 fc.Result = res
706 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
707}
708
709func (ec *executionContext) fieldContext_BoardCreateOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
710 fc = &graphql.FieldContext{
711 Object: "BoardCreateOperation",
712 Field: field,
713 IsMethod: true,
714 IsResolver: false,
715 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
716 return nil, errors.New("field of type Time does not have child fields")
717 },
718 }
719 return fc, nil
720}
721
722func (ec *executionContext) _BoardCreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *board.CreateOperation) (ret graphql.Marshaler) {
723 fc, err := ec.fieldContext_BoardCreateOperation_title(ctx, field)
724 if err != nil {
725 return graphql.Null
726 }
727 ctx = graphql.WithFieldContext(ctx, fc)
728 defer func() {
729 if r := recover(); r != nil {
730 ec.Error(ctx, ec.Recover(ctx, r))
731 ret = graphql.Null
732 }
733 }()
734 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
735 ctx = rctx // use context from middleware stack in children
736 return obj.Title, nil
737 })
738 if err != nil {
739 ec.Error(ctx, err)
740 return graphql.Null
741 }
742 if resTmp == nil {
743 if !graphql.HasFieldError(ctx, fc) {
744 ec.Errorf(ctx, "must not be null")
745 }
746 return graphql.Null
747 }
748 res := resTmp.(string)
749 fc.Result = res
750 return ec.marshalNString2string(ctx, field.Selections, res)
751}
752
753func (ec *executionContext) fieldContext_BoardCreateOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
754 fc = &graphql.FieldContext{
755 Object: "BoardCreateOperation",
756 Field: field,
757 IsMethod: false,
758 IsResolver: false,
759 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
760 return nil, errors.New("field of type String does not have child fields")
761 },
762 }
763 return fc, nil
764}
765
766func (ec *executionContext) _BoardCreateOperation_description(ctx context.Context, field graphql.CollectedField, obj *board.CreateOperation) (ret graphql.Marshaler) {
767 fc, err := ec.fieldContext_BoardCreateOperation_description(ctx, field)
768 if err != nil {
769 return graphql.Null
770 }
771 ctx = graphql.WithFieldContext(ctx, fc)
772 defer func() {
773 if r := recover(); r != nil {
774 ec.Error(ctx, ec.Recover(ctx, r))
775 ret = graphql.Null
776 }
777 }()
778 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
779 ctx = rctx // use context from middleware stack in children
780 return obj.Description, nil
781 })
782 if err != nil {
783 ec.Error(ctx, err)
784 return graphql.Null
785 }
786 if resTmp == nil {
787 if !graphql.HasFieldError(ctx, fc) {
788 ec.Errorf(ctx, "must not be null")
789 }
790 return graphql.Null
791 }
792 res := resTmp.(string)
793 fc.Result = res
794 return ec.marshalNString2string(ctx, field.Selections, res)
795}
796
797func (ec *executionContext) fieldContext_BoardCreateOperation_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
798 fc = &graphql.FieldContext{
799 Object: "BoardCreateOperation",
800 Field: field,
801 IsMethod: false,
802 IsResolver: false,
803 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
804 return nil, errors.New("field of type String does not have child fields")
805 },
806 }
807 return fc, nil
808}
809
810func (ec *executionContext) _BoardCreateOperation_columns(ctx context.Context, field graphql.CollectedField, obj *board.CreateOperation) (ret graphql.Marshaler) {
811 fc, err := ec.fieldContext_BoardCreateOperation_columns(ctx, field)
812 if err != nil {
813 return graphql.Null
814 }
815 ctx = graphql.WithFieldContext(ctx, fc)
816 defer func() {
817 if r := recover(); r != nil {
818 ec.Error(ctx, ec.Recover(ctx, r))
819 ret = graphql.Null
820 }
821 }()
822 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
823 ctx = rctx // use context from middleware stack in children
824 return obj.Columns, nil
825 })
826 if err != nil {
827 ec.Error(ctx, err)
828 return graphql.Null
829 }
830 if resTmp == nil {
831 if !graphql.HasFieldError(ctx, fc) {
832 ec.Errorf(ctx, "must not be null")
833 }
834 return graphql.Null
835 }
836 res := resTmp.([]string)
837 fc.Result = res
838 return ec.marshalNString2ástringá(ctx, field.Selections, res)
839}
840
841func (ec *executionContext) fieldContext_BoardCreateOperation_columns(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
842 fc = &graphql.FieldContext{
843 Object: "BoardCreateOperation",
844 Field: field,
845 IsMethod: false,
846 IsResolver: false,
847 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
848 return nil, errors.New("field of type String does not have child fields")
849 },
850 }
851 return fc, nil
852}
853
854func (ec *executionContext) _BoardSetDescriptionOperation_id(ctx context.Context, field graphql.CollectedField, obj *board.SetDescriptionOperation) (ret graphql.Marshaler) {
855 fc, err := ec.fieldContext_BoardSetDescriptionOperation_id(ctx, field)
856 if err != nil {
857 return graphql.Null
858 }
859 ctx = graphql.WithFieldContext(ctx, fc)
860 defer func() {
861 if r := recover(); r != nil {
862 ec.Error(ctx, ec.Recover(ctx, r))
863 ret = graphql.Null
864 }
865 }()
866 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
867 ctx = rctx // use context from middleware stack in children
868 return obj.Id(), nil
869 })
870 if err != nil {
871 ec.Error(ctx, err)
872 return graphql.Null
873 }
874 if resTmp == nil {
875 if !graphql.HasFieldError(ctx, fc) {
876 ec.Errorf(ctx, "must not be null")
877 }
878 return graphql.Null
879 }
880 res := resTmp.(entity.Id)
881 fc.Result = res
882 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
883}
884
885func (ec *executionContext) fieldContext_BoardSetDescriptionOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
886 fc = &graphql.FieldContext{
887 Object: "BoardSetDescriptionOperation",
888 Field: field,
889 IsMethod: true,
890 IsResolver: false,
891 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
892 return nil, errors.New("field of type ID does not have child fields")
893 },
894 }
895 return fc, nil
896}
897
898func (ec *executionContext) _BoardSetDescriptionOperation_author(ctx context.Context, field graphql.CollectedField, obj *board.SetDescriptionOperation) (ret graphql.Marshaler) {
899 fc, err := ec.fieldContext_BoardSetDescriptionOperation_author(ctx, field)
900 if err != nil {
901 return graphql.Null
902 }
903 ctx = graphql.WithFieldContext(ctx, fc)
904 defer func() {
905 if r := recover(); r != nil {
906 ec.Error(ctx, ec.Recover(ctx, r))
907 ret = graphql.Null
908 }
909 }()
910 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
911 ctx = rctx // use context from middleware stack in children
912 return ec.resolvers.BoardSetDescriptionOperation().Author(rctx, obj)
913 })
914 if err != nil {
915 ec.Error(ctx, err)
916 return graphql.Null
917 }
918 if resTmp == nil {
919 if !graphql.HasFieldError(ctx, fc) {
920 ec.Errorf(ctx, "must not be null")
921 }
922 return graphql.Null
923 }
924 res := resTmp.(models.IdentityWrapper)
925 fc.Result = res
926 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
927}
928
929func (ec *executionContext) fieldContext_BoardSetDescriptionOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
930 fc = &graphql.FieldContext{
931 Object: "BoardSetDescriptionOperation",
932 Field: field,
933 IsMethod: true,
934 IsResolver: true,
935 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
936 switch field.Name {
937 case "id":
938 return ec.fieldContext_Identity_id(ctx, field)
939 case "humanId":
940 return ec.fieldContext_Identity_humanId(ctx, field)
941 case "name":
942 return ec.fieldContext_Identity_name(ctx, field)
943 case "email":
944 return ec.fieldContext_Identity_email(ctx, field)
945 case "login":
946 return ec.fieldContext_Identity_login(ctx, field)
947 case "displayName":
948 return ec.fieldContext_Identity_displayName(ctx, field)
949 case "avatarUrl":
950 return ec.fieldContext_Identity_avatarUrl(ctx, field)
951 case "isProtected":
952 return ec.fieldContext_Identity_isProtected(ctx, field)
953 }
954 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
955 },
956 }
957 return fc, nil
958}
959
960func (ec *executionContext) _BoardSetDescriptionOperation_date(ctx context.Context, field graphql.CollectedField, obj *board.SetDescriptionOperation) (ret graphql.Marshaler) {
961 fc, err := ec.fieldContext_BoardSetDescriptionOperation_date(ctx, field)
962 if err != nil {
963 return graphql.Null
964 }
965 ctx = graphql.WithFieldContext(ctx, fc)
966 defer func() {
967 if r := recover(); r != nil {
968 ec.Error(ctx, ec.Recover(ctx, r))
969 ret = graphql.Null
970 }
971 }()
972 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
973 ctx = rctx // use context from middleware stack in children
974 return obj.Time(), nil
975 })
976 if err != nil {
977 ec.Error(ctx, err)
978 return graphql.Null
979 }
980 if resTmp == nil {
981 if !graphql.HasFieldError(ctx, fc) {
982 ec.Errorf(ctx, "must not be null")
983 }
984 return graphql.Null
985 }
986 res := resTmp.(time.Time)
987 fc.Result = res
988 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
989}
990
991func (ec *executionContext) fieldContext_BoardSetDescriptionOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
992 fc = &graphql.FieldContext{
993 Object: "BoardSetDescriptionOperation",
994 Field: field,
995 IsMethod: true,
996 IsResolver: false,
997 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
998 return nil, errors.New("field of type Time does not have child fields")
999 },
1000 }
1001 return fc, nil
1002}
1003
1004func (ec *executionContext) _BoardSetDescriptionOperation_description(ctx context.Context, field graphql.CollectedField, obj *board.SetDescriptionOperation) (ret graphql.Marshaler) {
1005 fc, err := ec.fieldContext_BoardSetDescriptionOperation_description(ctx, field)
1006 if err != nil {
1007 return graphql.Null
1008 }
1009 ctx = graphql.WithFieldContext(ctx, fc)
1010 defer func() {
1011 if r := recover(); r != nil {
1012 ec.Error(ctx, ec.Recover(ctx, r))
1013 ret = graphql.Null
1014 }
1015 }()
1016 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1017 ctx = rctx // use context from middleware stack in children
1018 return obj.Description, nil
1019 })
1020 if err != nil {
1021 ec.Error(ctx, err)
1022 return graphql.Null
1023 }
1024 if resTmp == nil {
1025 if !graphql.HasFieldError(ctx, fc) {
1026 ec.Errorf(ctx, "must not be null")
1027 }
1028 return graphql.Null
1029 }
1030 res := resTmp.(string)
1031 fc.Result = res
1032 return ec.marshalNString2string(ctx, field.Selections, res)
1033}
1034
1035func (ec *executionContext) fieldContext_BoardSetDescriptionOperation_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1036 fc = &graphql.FieldContext{
1037 Object: "BoardSetDescriptionOperation",
1038 Field: field,
1039 IsMethod: false,
1040 IsResolver: false,
1041 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1042 return nil, errors.New("field of type String does not have child fields")
1043 },
1044 }
1045 return fc, nil
1046}
1047
1048func (ec *executionContext) _BoardSetDescriptionOperation_was(ctx context.Context, field graphql.CollectedField, obj *board.SetDescriptionOperation) (ret graphql.Marshaler) {
1049 fc, err := ec.fieldContext_BoardSetDescriptionOperation_was(ctx, field)
1050 if err != nil {
1051 return graphql.Null
1052 }
1053 ctx = graphql.WithFieldContext(ctx, fc)
1054 defer func() {
1055 if r := recover(); r != nil {
1056 ec.Error(ctx, ec.Recover(ctx, r))
1057 ret = graphql.Null
1058 }
1059 }()
1060 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1061 ctx = rctx // use context from middleware stack in children
1062 return obj.Was, nil
1063 })
1064 if err != nil {
1065 ec.Error(ctx, err)
1066 return graphql.Null
1067 }
1068 if resTmp == nil {
1069 if !graphql.HasFieldError(ctx, fc) {
1070 ec.Errorf(ctx, "must not be null")
1071 }
1072 return graphql.Null
1073 }
1074 res := resTmp.(string)
1075 fc.Result = res
1076 return ec.marshalNString2string(ctx, field.Selections, res)
1077}
1078
1079func (ec *executionContext) fieldContext_BoardSetDescriptionOperation_was(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1080 fc = &graphql.FieldContext{
1081 Object: "BoardSetDescriptionOperation",
1082 Field: field,
1083 IsMethod: false,
1084 IsResolver: false,
1085 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1086 return nil, errors.New("field of type String does not have child fields")
1087 },
1088 }
1089 return fc, nil
1090}
1091
1092func (ec *executionContext) _BoardSetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *board.SetTitleOperation) (ret graphql.Marshaler) {
1093 fc, err := ec.fieldContext_BoardSetTitleOperation_id(ctx, field)
1094 if err != nil {
1095 return graphql.Null
1096 }
1097 ctx = graphql.WithFieldContext(ctx, fc)
1098 defer func() {
1099 if r := recover(); r != nil {
1100 ec.Error(ctx, ec.Recover(ctx, r))
1101 ret = graphql.Null
1102 }
1103 }()
1104 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1105 ctx = rctx // use context from middleware stack in children
1106 return obj.Id(), nil
1107 })
1108 if err != nil {
1109 ec.Error(ctx, err)
1110 return graphql.Null
1111 }
1112 if resTmp == nil {
1113 if !graphql.HasFieldError(ctx, fc) {
1114 ec.Errorf(ctx, "must not be null")
1115 }
1116 return graphql.Null
1117 }
1118 res := resTmp.(entity.Id)
1119 fc.Result = res
1120 return ec.marshalNID2githubácomágitábugágitábugáentityáId(ctx, field.Selections, res)
1121}
1122
1123func (ec *executionContext) fieldContext_BoardSetTitleOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1124 fc = &graphql.FieldContext{
1125 Object: "BoardSetTitleOperation",
1126 Field: field,
1127 IsMethod: true,
1128 IsResolver: false,
1129 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1130 return nil, errors.New("field of type ID does not have child fields")
1131 },
1132 }
1133 return fc, nil
1134}
1135
1136func (ec *executionContext) _BoardSetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *board.SetTitleOperation) (ret graphql.Marshaler) {
1137 fc, err := ec.fieldContext_BoardSetTitleOperation_author(ctx, field)
1138 if err != nil {
1139 return graphql.Null
1140 }
1141 ctx = graphql.WithFieldContext(ctx, fc)
1142 defer func() {
1143 if r := recover(); r != nil {
1144 ec.Error(ctx, ec.Recover(ctx, r))
1145 ret = graphql.Null
1146 }
1147 }()
1148 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1149 ctx = rctx // use context from middleware stack in children
1150 return ec.resolvers.BoardSetTitleOperation().Author(rctx, obj)
1151 })
1152 if err != nil {
1153 ec.Error(ctx, err)
1154 return graphql.Null
1155 }
1156 if resTmp == nil {
1157 if !graphql.HasFieldError(ctx, fc) {
1158 ec.Errorf(ctx, "must not be null")
1159 }
1160 return graphql.Null
1161 }
1162 res := resTmp.(models.IdentityWrapper)
1163 fc.Result = res
1164 return ec.marshalNIdentity2githubácomágitábugágitábugáapiágraphqlámodelsáIdentityWrapper(ctx, field.Selections, res)
1165}
1166
1167func (ec *executionContext) fieldContext_BoardSetTitleOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1168 fc = &graphql.FieldContext{
1169 Object: "BoardSetTitleOperation",
1170 Field: field,
1171 IsMethod: true,
1172 IsResolver: true,
1173 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1174 switch field.Name {
1175 case "id":
1176 return ec.fieldContext_Identity_id(ctx, field)
1177 case "humanId":
1178 return ec.fieldContext_Identity_humanId(ctx, field)
1179 case "name":
1180 return ec.fieldContext_Identity_name(ctx, field)
1181 case "email":
1182 return ec.fieldContext_Identity_email(ctx, field)
1183 case "login":
1184 return ec.fieldContext_Identity_login(ctx, field)
1185 case "displayName":
1186 return ec.fieldContext_Identity_displayName(ctx, field)
1187 case "avatarUrl":
1188 return ec.fieldContext_Identity_avatarUrl(ctx, field)
1189 case "isProtected":
1190 return ec.fieldContext_Identity_isProtected(ctx, field)
1191 }
1192 return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1193 },
1194 }
1195 return fc, nil
1196}
1197
1198func (ec *executionContext) _BoardSetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *board.SetTitleOperation) (ret graphql.Marshaler) {
1199 fc, err := ec.fieldContext_BoardSetTitleOperation_date(ctx, field)
1200 if err != nil {
1201 return graphql.Null
1202 }
1203 ctx = graphql.WithFieldContext(ctx, fc)
1204 defer func() {
1205 if r := recover(); r != nil {
1206 ec.Error(ctx, ec.Recover(ctx, r))
1207 ret = graphql.Null
1208 }
1209 }()
1210 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1211 ctx = rctx // use context from middleware stack in children
1212 return obj.Time(), nil
1213 })
1214 if err != nil {
1215 ec.Error(ctx, err)
1216 return graphql.Null
1217 }
1218 if resTmp == nil {
1219 if !graphql.HasFieldError(ctx, fc) {
1220 ec.Errorf(ctx, "must not be null")
1221 }
1222 return graphql.Null
1223 }
1224 res := resTmp.(time.Time)
1225 fc.Result = res
1226 return ec.marshalNTime2timeáTime(ctx, field.Selections, res)
1227}
1228
1229func (ec *executionContext) fieldContext_BoardSetTitleOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1230 fc = &graphql.FieldContext{
1231 Object: "BoardSetTitleOperation",
1232 Field: field,
1233 IsMethod: true,
1234 IsResolver: false,
1235 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1236 return nil, errors.New("field of type Time does not have child fields")
1237 },
1238 }
1239 return fc, nil
1240}
1241
1242func (ec *executionContext) _BoardSetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *board.SetTitleOperation) (ret graphql.Marshaler) {
1243 fc, err := ec.fieldContext_BoardSetTitleOperation_title(ctx, field)
1244 if err != nil {
1245 return graphql.Null
1246 }
1247 ctx = graphql.WithFieldContext(ctx, fc)
1248 defer func() {
1249 if r := recover(); r != nil {
1250 ec.Error(ctx, ec.Recover(ctx, r))
1251 ret = graphql.Null
1252 }
1253 }()
1254 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1255 ctx = rctx // use context from middleware stack in children
1256 return obj.Title, nil
1257 })
1258 if err != nil {
1259 ec.Error(ctx, err)
1260 return graphql.Null
1261 }
1262 if resTmp == nil {
1263 if !graphql.HasFieldError(ctx, fc) {
1264 ec.Errorf(ctx, "must not be null")
1265 }
1266 return graphql.Null
1267 }
1268 res := resTmp.(string)
1269 fc.Result = res
1270 return ec.marshalNString2string(ctx, field.Selections, res)
1271}
1272
1273func (ec *executionContext) fieldContext_BoardSetTitleOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1274 fc = &graphql.FieldContext{
1275 Object: "BoardSetTitleOperation",
1276 Field: field,
1277 IsMethod: false,
1278 IsResolver: false,
1279 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1280 return nil, errors.New("field of type String does not have child fields")
1281 },
1282 }
1283 return fc, nil
1284}
1285
1286func (ec *executionContext) _BoardSetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *board.SetTitleOperation) (ret graphql.Marshaler) {
1287 fc, err := ec.fieldContext_BoardSetTitleOperation_was(ctx, field)
1288 if err != nil {
1289 return graphql.Null
1290 }
1291 ctx = graphql.WithFieldContext(ctx, fc)
1292 defer func() {
1293 if r := recover(); r != nil {
1294 ec.Error(ctx, ec.Recover(ctx, r))
1295 ret = graphql.Null
1296 }
1297 }()
1298 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1299 ctx = rctx // use context from middleware stack in children
1300 return obj.Was, nil
1301 })
1302 if err != nil {
1303 ec.Error(ctx, err)
1304 return graphql.Null
1305 }
1306 if resTmp == nil {
1307 if !graphql.HasFieldError(ctx, fc) {
1308 ec.Errorf(ctx, "must not be null")
1309 }
1310 return graphql.Null
1311 }
1312 res := resTmp.(string)
1313 fc.Result = res
1314 return ec.marshalNString2string(ctx, field.Selections, res)
1315}
1316
1317func (ec *executionContext) fieldContext_BoardSetTitleOperation_was(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1318 fc = &graphql.FieldContext{
1319 Object: "BoardSetTitleOperation",
1320 Field: field,
1321 IsMethod: false,
1322 IsResolver: false,
1323 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1324 return nil, errors.New("field of type String does not have child fields")
1325 },
1326 }
1327 return fc, nil
1328}
1329
1330// endregion **************************** field.gotpl *****************************
1331
1332// region **************************** input.gotpl *****************************
1333
1334// endregion **************************** input.gotpl *****************************
1335
1336// region ************************** interface.gotpl ***************************
1337
1338// endregion ************************** interface.gotpl ***************************
1339
1340// region **************************** object.gotpl ****************************
1341
1342var boardAddItemDraftOperationImplementors = []string{"BoardAddItemDraftOperation", "Operation", "Authored"}
1343
1344func (ec *executionContext) _BoardAddItemDraftOperation(ctx context.Context, sel ast.SelectionSet, obj *board.AddItemDraftOperation) graphql.Marshaler {
1345 fields := graphql.CollectFields(ec.OperationContext, sel, boardAddItemDraftOperationImplementors)
1346
1347 out := graphql.NewFieldSet(fields)
1348 deferred := make(map[string]*graphql.FieldSet)
1349 for i, field := range fields {
1350 switch field.Name {
1351 case "__typename":
1352 out.Values[i] = graphql.MarshalString("BoardAddItemDraftOperation")
1353 case "id":
1354 out.Values[i] = ec._BoardAddItemDraftOperation_id(ctx, field, obj)
1355 if out.Values[i] == graphql.Null {
1356 atomic.AddUint32(&out.Invalids, 1)
1357 }
1358 case "author":
1359 field := field
1360
1361 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1362 defer func() {
1363 if r := recover(); r != nil {
1364 ec.Error(ctx, ec.Recover(ctx, r))
1365 }
1366 }()
1367 res = ec._BoardAddItemDraftOperation_author(ctx, field, obj)
1368 if res == graphql.Null {
1369 atomic.AddUint32(&fs.Invalids, 1)
1370 }
1371 return res
1372 }
1373
1374 if field.Deferrable != nil {
1375 dfs, ok := deferred[field.Deferrable.Label]
1376 di := 0
1377 if ok {
1378 dfs.AddField(field)
1379 di = len(dfs.Values) - 1
1380 } else {
1381 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1382 deferred[field.Deferrable.Label] = dfs
1383 }
1384 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1385 return innerFunc(ctx, dfs)
1386 })
1387
1388 // don't run the out.Concurrently() call below
1389 out.Values[i] = graphql.Null
1390 continue
1391 }
1392
1393 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1394 case "date":
1395 out.Values[i] = ec._BoardAddItemDraftOperation_date(ctx, field, obj)
1396 if out.Values[i] == graphql.Null {
1397 atomic.AddUint32(&out.Invalids, 1)
1398 }
1399 case "columnId":
1400 out.Values[i] = ec._BoardAddItemDraftOperation_columnId(ctx, field, obj)
1401 if out.Values[i] == graphql.Null {
1402 atomic.AddUint32(&out.Invalids, 1)
1403 }
1404 case "title":
1405 out.Values[i] = ec._BoardAddItemDraftOperation_title(ctx, field, obj)
1406 if out.Values[i] == graphql.Null {
1407 atomic.AddUint32(&out.Invalids, 1)
1408 }
1409 default:
1410 panic("unknown field " + strconv.Quote(field.Name))
1411 }
1412 }
1413 out.Dispatch(ctx)
1414 if out.Invalids > 0 {
1415 return graphql.Null
1416 }
1417
1418 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1419
1420 for label, dfs := range deferred {
1421 ec.processDeferredGroup(graphql.DeferredGroup{
1422 Label: label,
1423 Path: graphql.GetPath(ctx),
1424 FieldSet: dfs,
1425 Context: ctx,
1426 })
1427 }
1428
1429 return out
1430}
1431
1432var boardAddItemEntityOperationImplementors = []string{"BoardAddItemEntityOperation", "Operation", "Authored"}
1433
1434func (ec *executionContext) _BoardAddItemEntityOperation(ctx context.Context, sel ast.SelectionSet, obj *board.AddItemEntityOperation) graphql.Marshaler {
1435 fields := graphql.CollectFields(ec.OperationContext, sel, boardAddItemEntityOperationImplementors)
1436
1437 out := graphql.NewFieldSet(fields)
1438 deferred := make(map[string]*graphql.FieldSet)
1439 for i, field := range fields {
1440 switch field.Name {
1441 case "__typename":
1442 out.Values[i] = graphql.MarshalString("BoardAddItemEntityOperation")
1443 case "id":
1444 out.Values[i] = ec._BoardAddItemEntityOperation_id(ctx, field, obj)
1445 if out.Values[i] == graphql.Null {
1446 atomic.AddUint32(&out.Invalids, 1)
1447 }
1448 case "author":
1449 field := field
1450
1451 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1452 defer func() {
1453 if r := recover(); r != nil {
1454 ec.Error(ctx, ec.Recover(ctx, r))
1455 }
1456 }()
1457 res = ec._BoardAddItemEntityOperation_author(ctx, field, obj)
1458 if res == graphql.Null {
1459 atomic.AddUint32(&fs.Invalids, 1)
1460 }
1461 return res
1462 }
1463
1464 if field.Deferrable != nil {
1465 dfs, ok := deferred[field.Deferrable.Label]
1466 di := 0
1467 if ok {
1468 dfs.AddField(field)
1469 di = len(dfs.Values) - 1
1470 } else {
1471 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1472 deferred[field.Deferrable.Label] = dfs
1473 }
1474 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1475 return innerFunc(ctx, dfs)
1476 })
1477
1478 // don't run the out.Concurrently() call below
1479 out.Values[i] = graphql.Null
1480 continue
1481 }
1482
1483 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1484 case "date":
1485 out.Values[i] = ec._BoardAddItemEntityOperation_date(ctx, field, obj)
1486 if out.Values[i] == graphql.Null {
1487 atomic.AddUint32(&out.Invalids, 1)
1488 }
1489 case "columnId":
1490 out.Values[i] = ec._BoardAddItemEntityOperation_columnId(ctx, field, obj)
1491 if out.Values[i] == graphql.Null {
1492 atomic.AddUint32(&out.Invalids, 1)
1493 }
1494 case "entityType":
1495 field := field
1496
1497 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1498 defer func() {
1499 if r := recover(); r != nil {
1500 ec.Error(ctx, ec.Recover(ctx, r))
1501 }
1502 }()
1503 res = ec._BoardAddItemEntityOperation_entityType(ctx, field, obj)
1504 if res == graphql.Null {
1505 atomic.AddUint32(&fs.Invalids, 1)
1506 }
1507 return res
1508 }
1509
1510 if field.Deferrable != nil {
1511 dfs, ok := deferred[field.Deferrable.Label]
1512 di := 0
1513 if ok {
1514 dfs.AddField(field)
1515 di = len(dfs.Values) - 1
1516 } else {
1517 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1518 deferred[field.Deferrable.Label] = dfs
1519 }
1520 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1521 return innerFunc(ctx, dfs)
1522 })
1523
1524 // don't run the out.Concurrently() call below
1525 out.Values[i] = graphql.Null
1526 continue
1527 }
1528
1529 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1530 case "entityId":
1531 out.Values[i] = ec._BoardAddItemEntityOperation_entityId(ctx, field, obj)
1532 if out.Values[i] == graphql.Null {
1533 atomic.AddUint32(&out.Invalids, 1)
1534 }
1535 default:
1536 panic("unknown field " + strconv.Quote(field.Name))
1537 }
1538 }
1539 out.Dispatch(ctx)
1540 if out.Invalids > 0 {
1541 return graphql.Null
1542 }
1543
1544 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1545
1546 for label, dfs := range deferred {
1547 ec.processDeferredGroup(graphql.DeferredGroup{
1548 Label: label,
1549 Path: graphql.GetPath(ctx),
1550 FieldSet: dfs,
1551 Context: ctx,
1552 })
1553 }
1554
1555 return out
1556}
1557
1558var boardCreateOperationImplementors = []string{"BoardCreateOperation", "Operation", "Authored"}
1559
1560func (ec *executionContext) _BoardCreateOperation(ctx context.Context, sel ast.SelectionSet, obj *board.CreateOperation) graphql.Marshaler {
1561 fields := graphql.CollectFields(ec.OperationContext, sel, boardCreateOperationImplementors)
1562
1563 out := graphql.NewFieldSet(fields)
1564 deferred := make(map[string]*graphql.FieldSet)
1565 for i, field := range fields {
1566 switch field.Name {
1567 case "__typename":
1568 out.Values[i] = graphql.MarshalString("BoardCreateOperation")
1569 case "id":
1570 out.Values[i] = ec._BoardCreateOperation_id(ctx, field, obj)
1571 if out.Values[i] == graphql.Null {
1572 atomic.AddUint32(&out.Invalids, 1)
1573 }
1574 case "author":
1575 field := field
1576
1577 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1578 defer func() {
1579 if r := recover(); r != nil {
1580 ec.Error(ctx, ec.Recover(ctx, r))
1581 }
1582 }()
1583 res = ec._BoardCreateOperation_author(ctx, field, obj)
1584 if res == graphql.Null {
1585 atomic.AddUint32(&fs.Invalids, 1)
1586 }
1587 return res
1588 }
1589
1590 if field.Deferrable != nil {
1591 dfs, ok := deferred[field.Deferrable.Label]
1592 di := 0
1593 if ok {
1594 dfs.AddField(field)
1595 di = len(dfs.Values) - 1
1596 } else {
1597 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1598 deferred[field.Deferrable.Label] = dfs
1599 }
1600 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1601 return innerFunc(ctx, dfs)
1602 })
1603
1604 // don't run the out.Concurrently() call below
1605 out.Values[i] = graphql.Null
1606 continue
1607 }
1608
1609 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1610 case "date":
1611 out.Values[i] = ec._BoardCreateOperation_date(ctx, field, obj)
1612 if out.Values[i] == graphql.Null {
1613 atomic.AddUint32(&out.Invalids, 1)
1614 }
1615 case "title":
1616 out.Values[i] = ec._BoardCreateOperation_title(ctx, field, obj)
1617 if out.Values[i] == graphql.Null {
1618 atomic.AddUint32(&out.Invalids, 1)
1619 }
1620 case "description":
1621 out.Values[i] = ec._BoardCreateOperation_description(ctx, field, obj)
1622 if out.Values[i] == graphql.Null {
1623 atomic.AddUint32(&out.Invalids, 1)
1624 }
1625 case "columns":
1626 out.Values[i] = ec._BoardCreateOperation_columns(ctx, field, obj)
1627 if out.Values[i] == graphql.Null {
1628 atomic.AddUint32(&out.Invalids, 1)
1629 }
1630 default:
1631 panic("unknown field " + strconv.Quote(field.Name))
1632 }
1633 }
1634 out.Dispatch(ctx)
1635 if out.Invalids > 0 {
1636 return graphql.Null
1637 }
1638
1639 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1640
1641 for label, dfs := range deferred {
1642 ec.processDeferredGroup(graphql.DeferredGroup{
1643 Label: label,
1644 Path: graphql.GetPath(ctx),
1645 FieldSet: dfs,
1646 Context: ctx,
1647 })
1648 }
1649
1650 return out
1651}
1652
1653var boardSetDescriptionOperationImplementors = []string{"BoardSetDescriptionOperation", "Operation", "Authored"}
1654
1655func (ec *executionContext) _BoardSetDescriptionOperation(ctx context.Context, sel ast.SelectionSet, obj *board.SetDescriptionOperation) graphql.Marshaler {
1656 fields := graphql.CollectFields(ec.OperationContext, sel, boardSetDescriptionOperationImplementors)
1657
1658 out := graphql.NewFieldSet(fields)
1659 deferred := make(map[string]*graphql.FieldSet)
1660 for i, field := range fields {
1661 switch field.Name {
1662 case "__typename":
1663 out.Values[i] = graphql.MarshalString("BoardSetDescriptionOperation")
1664 case "id":
1665 out.Values[i] = ec._BoardSetDescriptionOperation_id(ctx, field, obj)
1666 if out.Values[i] == graphql.Null {
1667 atomic.AddUint32(&out.Invalids, 1)
1668 }
1669 case "author":
1670 field := field
1671
1672 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1673 defer func() {
1674 if r := recover(); r != nil {
1675 ec.Error(ctx, ec.Recover(ctx, r))
1676 }
1677 }()
1678 res = ec._BoardSetDescriptionOperation_author(ctx, field, obj)
1679 if res == graphql.Null {
1680 atomic.AddUint32(&fs.Invalids, 1)
1681 }
1682 return res
1683 }
1684
1685 if field.Deferrable != nil {
1686 dfs, ok := deferred[field.Deferrable.Label]
1687 di := 0
1688 if ok {
1689 dfs.AddField(field)
1690 di = len(dfs.Values) - 1
1691 } else {
1692 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1693 deferred[field.Deferrable.Label] = dfs
1694 }
1695 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1696 return innerFunc(ctx, dfs)
1697 })
1698
1699 // don't run the out.Concurrently() call below
1700 out.Values[i] = graphql.Null
1701 continue
1702 }
1703
1704 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1705 case "date":
1706 out.Values[i] = ec._BoardSetDescriptionOperation_date(ctx, field, obj)
1707 if out.Values[i] == graphql.Null {
1708 atomic.AddUint32(&out.Invalids, 1)
1709 }
1710 case "description":
1711 out.Values[i] = ec._BoardSetDescriptionOperation_description(ctx, field, obj)
1712 if out.Values[i] == graphql.Null {
1713 atomic.AddUint32(&out.Invalids, 1)
1714 }
1715 case "was":
1716 out.Values[i] = ec._BoardSetDescriptionOperation_was(ctx, field, obj)
1717 if out.Values[i] == graphql.Null {
1718 atomic.AddUint32(&out.Invalids, 1)
1719 }
1720 default:
1721 panic("unknown field " + strconv.Quote(field.Name))
1722 }
1723 }
1724 out.Dispatch(ctx)
1725 if out.Invalids > 0 {
1726 return graphql.Null
1727 }
1728
1729 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1730
1731 for label, dfs := range deferred {
1732 ec.processDeferredGroup(graphql.DeferredGroup{
1733 Label: label,
1734 Path: graphql.GetPath(ctx),
1735 FieldSet: dfs,
1736 Context: ctx,
1737 })
1738 }
1739
1740 return out
1741}
1742
1743var boardSetTitleOperationImplementors = []string{"BoardSetTitleOperation", "Operation", "Authored"}
1744
1745func (ec *executionContext) _BoardSetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *board.SetTitleOperation) graphql.Marshaler {
1746 fields := graphql.CollectFields(ec.OperationContext, sel, boardSetTitleOperationImplementors)
1747
1748 out := graphql.NewFieldSet(fields)
1749 deferred := make(map[string]*graphql.FieldSet)
1750 for i, field := range fields {
1751 switch field.Name {
1752 case "__typename":
1753 out.Values[i] = graphql.MarshalString("BoardSetTitleOperation")
1754 case "id":
1755 out.Values[i] = ec._BoardSetTitleOperation_id(ctx, field, obj)
1756 if out.Values[i] == graphql.Null {
1757 atomic.AddUint32(&out.Invalids, 1)
1758 }
1759 case "author":
1760 field := field
1761
1762 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1763 defer func() {
1764 if r := recover(); r != nil {
1765 ec.Error(ctx, ec.Recover(ctx, r))
1766 }
1767 }()
1768 res = ec._BoardSetTitleOperation_author(ctx, field, obj)
1769 if res == graphql.Null {
1770 atomic.AddUint32(&fs.Invalids, 1)
1771 }
1772 return res
1773 }
1774
1775 if field.Deferrable != nil {
1776 dfs, ok := deferred[field.Deferrable.Label]
1777 di := 0
1778 if ok {
1779 dfs.AddField(field)
1780 di = len(dfs.Values) - 1
1781 } else {
1782 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1783 deferred[field.Deferrable.Label] = dfs
1784 }
1785 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1786 return innerFunc(ctx, dfs)
1787 })
1788
1789 // don't run the out.Concurrently() call below
1790 out.Values[i] = graphql.Null
1791 continue
1792 }
1793
1794 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1795 case "date":
1796 out.Values[i] = ec._BoardSetTitleOperation_date(ctx, field, obj)
1797 if out.Values[i] == graphql.Null {
1798 atomic.AddUint32(&out.Invalids, 1)
1799 }
1800 case "title":
1801 out.Values[i] = ec._BoardSetTitleOperation_title(ctx, field, obj)
1802 if out.Values[i] == graphql.Null {
1803 atomic.AddUint32(&out.Invalids, 1)
1804 }
1805 case "was":
1806 out.Values[i] = ec._BoardSetTitleOperation_was(ctx, field, obj)
1807 if out.Values[i] == graphql.Null {
1808 atomic.AddUint32(&out.Invalids, 1)
1809 }
1810 default:
1811 panic("unknown field " + strconv.Quote(field.Name))
1812 }
1813 }
1814 out.Dispatch(ctx)
1815 if out.Invalids > 0 {
1816 return graphql.Null
1817 }
1818
1819 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1820
1821 for label, dfs := range deferred {
1822 ec.processDeferredGroup(graphql.DeferredGroup{
1823 Label: label,
1824 Path: graphql.GetPath(ctx),
1825 FieldSet: dfs,
1826 Context: ctx,
1827 })
1828 }
1829
1830 return out
1831}
1832
1833// endregion **************************** object.gotpl ****************************
1834
1835// region ***************************** type.gotpl *****************************
1836
1837func (ec *executionContext) unmarshalNBoardItemEntityType2githubácomágitábugágitábugáapiágraphqlámodelsáBoardItemEntityType(ctx context.Context, v any) (models.BoardItemEntityType, error) {
1838 var res models.BoardItemEntityType
1839 err := res.UnmarshalGQL(v)
1840 return res, graphql.ErrorOnPath(ctx, err)
1841}
1842
1843func (ec *executionContext) marshalNBoardItemEntityType2githubácomágitábugágitábugáapiágraphqlámodelsáBoardItemEntityType(ctx context.Context, sel ast.SelectionSet, v models.BoardItemEntityType) graphql.Marshaler {
1844 return v
1845}
1846
1847// endregion ***************************** type.gotpl *****************************