├── --debug=localhost
├── .dockerignore
├── .vscode
├── launch.json
└── settings.json
├── Dockerfile
├── README.md
├── backend
├── .gitignore
├── generated.go
├── gqlgen.yml
├── resolver.go
├── schema.graphql
└── server
│ ├── server.go
│ └── temp
│ └── .gitkeep
├── demo.gif
├── docker-compose.debug.yml
├── docker-compose.yml
├── flutter
├── .gitignore
├── .metadata
├── .vscode
│ └── settings.json
├── README.md
├── android
│ ├── app
│ │ ├── build.gradle
│ │ └── src
│ │ │ ├── debug
│ │ │ └── AndroidManifest.xml
│ │ │ ├── main
│ │ │ ├── AndroidManifest.xml
│ │ │ ├── java
│ │ │ │ └── com
│ │ │ │ │ └── example
│ │ │ │ │ └── flutter_graphql_upload
│ │ │ │ │ └── MainActivity.java
│ │ │ └── res
│ │ │ │ ├── drawable
│ │ │ │ └── launch_background.xml
│ │ │ │ ├── mipmap-hdpi
│ │ │ │ └── ic_launcher.png
│ │ │ │ ├── mipmap-mdpi
│ │ │ │ └── ic_launcher.png
│ │ │ │ ├── mipmap-xhdpi
│ │ │ │ └── ic_launcher.png
│ │ │ │ ├── mipmap-xxhdpi
│ │ │ │ └── ic_launcher.png
│ │ │ │ ├── mipmap-xxxhdpi
│ │ │ │ └── ic_launcher.png
│ │ │ │ └── values
│ │ │ │ └── styles.xml
│ │ │ └── profile
│ │ │ └── AndroidManifest.xml
│ ├── build.gradle
│ ├── gradle.properties
│ ├── gradle
│ │ └── wrapper
│ │ │ └── gradle-wrapper.properties
│ └── settings.gradle
├── images
│ ├── chrome.svg
│ ├── firefox.svg
│ └── safari.svg
├── ios
│ ├── Flutter
│ │ ├── AppFrameworkInfo.plist
│ │ ├── Debug.xcconfig
│ │ └── Release.xcconfig
│ ├── Runner.xcodeproj
│ │ ├── project.pbxproj
│ │ ├── project.xcworkspace
│ │ │ └── contents.xcworkspacedata
│ │ └── xcshareddata
│ │ │ └── xcschemes
│ │ │ └── Runner.xcscheme
│ ├── Runner.xcworkspace
│ │ └── contents.xcworkspacedata
│ └── Runner
│ │ ├── AppDelegate.h
│ │ ├── AppDelegate.m
│ │ ├── Assets.xcassets
│ │ ├── AppIcon.appiconset
│ │ │ ├── Contents.json
│ │ │ ├── Icon-App-1024x1024@1x.png
│ │ │ ├── Icon-App-20x20@1x.png
│ │ │ ├── Icon-App-20x20@2x.png
│ │ │ ├── Icon-App-20x20@3x.png
│ │ │ ├── Icon-App-29x29@1x.png
│ │ │ ├── Icon-App-29x29@2x.png
│ │ │ ├── Icon-App-29x29@3x.png
│ │ │ ├── Icon-App-40x40@1x.png
│ │ │ ├── Icon-App-40x40@2x.png
│ │ │ ├── Icon-App-40x40@3x.png
│ │ │ ├── Icon-App-60x60@2x.png
│ │ │ ├── Icon-App-60x60@3x.png
│ │ │ ├── Icon-App-76x76@1x.png
│ │ │ ├── Icon-App-76x76@2x.png
│ │ │ └── Icon-App-83.5x83.5@2x.png
│ │ └── LaunchImage.imageset
│ │ │ ├── Contents.json
│ │ │ ├── LaunchImage.png
│ │ │ ├── LaunchImage@2x.png
│ │ │ ├── LaunchImage@3x.png
│ │ │ └── README.md
│ │ ├── Base.lproj
│ │ ├── LaunchScreen.storyboard
│ │ └── Main.storyboard
│ │ ├── Info.plist
│ │ └── main.m
├── lib
│ └── main.dart
├── pubspec.lock
├── pubspec.yaml
└── test
│ └── widget_test.dart
├── go.mod
└── go.sum
/--debug=localhost:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mainawycliffe/flutter-graphql-upload-example/687b45e889eafbed8b7a658769c5741f97f6b02c/--debug=localhost
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | npm-debug.log
3 | Dockerfile*
4 | docker-compose*
5 | .dockerignore
6 | .git
7 | .gitignore
8 | .env
9 | */bin
10 | */obj
11 | README.md
12 | LICENSE
13 | .vscode
14 | flutter_graphql_upload
--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mainawycliffe/flutter-graphql-upload-example/687b45e889eafbed8b7a658769c5741f97f6b02c/.vscode/launch.json
--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "workbench.colorCustomizations": {}
3 | }
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 |
2 | #build stage
3 | FROM golang:alpine AS builder
4 | WORKDIR /app
5 | COPY . .
6 | WORKDIR /app/backend/server
7 | RUN apk add --no-cache git
8 | RUN go get -d -v ./...
9 | RUN go build -v -o app
10 |
11 | #final stage
12 | FROM alpine:latest
13 | RUN apk --no-cache add ca-certificates
14 | COPY --from=builder /app/backend/server/app /app
15 | RUN mkdir -p temp
16 | ENTRYPOINT ./app
17 | EXPOSE 8080
18 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Flutter GraphQL Image Uploads
2 |
3 | This repo is to demo how to upload files using GraphQL and Flutter. The backend is build using Golang but can be run using docker - no need to install golang.
4 |
5 | ## Backend
6 |
7 | To run the backend, you can use [docker compose](https://docs.docker.com/compose/), simply run `docker-compose up -d --build` at the root directory.
8 |
9 | ### Upload Image Mutation
10 |
11 | To test the server, you can use the built in GraphiQL, whose URL is [http://localhost:8080](http://localhost:8080).
12 |
13 | You can run the upload file Mutation below:
14 |
15 | ```graphql
16 | mutation($file: Upload!) {
17 | upload(file: $file)
18 | }
19 | ```
20 |
21 | ## Frontend
22 |
23 | To run the frontend, change directory to the `flutter` directory, and run `flutter run`. Make sure you have flutter [installed](https://flutter.dev/docs/get-started/install).
24 |
25 | ### Demo
26 |
27 |
28 | 
29 |
30 |
31 | ### Accompanying Post
32 |
33 | You can find a detailed explanation for the fronted [here](https://codinglatte.com/posts/flutter/flutter-and-graphql-how-to-upload-files/).
34 |
35 | ## Contributions
36 |
37 | PR are welcome.
38 |
--------------------------------------------------------------------------------
/backend/.gitignore:
--------------------------------------------------------------------------------
1 | server/temp/*
2 | !server/temp/.gitkeep
--------------------------------------------------------------------------------
/backend/generated.go:
--------------------------------------------------------------------------------
1 | // Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
2 |
3 | package backend
4 |
5 | import (
6 | "bytes"
7 | "context"
8 | "errors"
9 | "strconv"
10 | "sync"
11 | "sync/atomic"
12 |
13 | "github.com/99designs/gqlgen/graphql"
14 | "github.com/99designs/gqlgen/graphql/introspection"
15 | "github.com/vektah/gqlparser"
16 | "github.com/vektah/gqlparser/ast"
17 | )
18 |
19 | // region ************************** generated!.gotpl **************************
20 |
21 | // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
22 | func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
23 | return &executableSchema{
24 | resolvers: cfg.Resolvers,
25 | directives: cfg.Directives,
26 | complexity: cfg.Complexity,
27 | }
28 | }
29 |
30 | type Config struct {
31 | Resolvers ResolverRoot
32 | Directives DirectiveRoot
33 | Complexity ComplexityRoot
34 | }
35 |
36 | type ResolverRoot interface {
37 | Mutation() MutationResolver
38 | Query() QueryResolver
39 | }
40 |
41 | type DirectiveRoot struct {
42 | }
43 |
44 | type ComplexityRoot struct {
45 | Mutation struct {
46 | Upload func(childComplexity int, file graphql.Upload) int
47 | }
48 |
49 | Query struct {
50 | Hello func(childComplexity int, name string) int
51 | }
52 | }
53 |
54 | type MutationResolver interface {
55 | Upload(ctx context.Context, file graphql.Upload) (string, error)
56 | }
57 | type QueryResolver interface {
58 | Hello(ctx context.Context, name string) (string, error)
59 | }
60 |
61 | type executableSchema struct {
62 | resolvers ResolverRoot
63 | directives DirectiveRoot
64 | complexity ComplexityRoot
65 | }
66 |
67 | func (e *executableSchema) Schema() *ast.Schema {
68 | return parsedSchema
69 | }
70 |
71 | func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
72 | ec := executionContext{nil, e}
73 | _ = ec
74 | switch typeName + "." + field {
75 |
76 | case "Mutation.upload":
77 | if e.complexity.Mutation.Upload == nil {
78 | break
79 | }
80 |
81 | args, err := ec.field_Mutation_upload_args(context.TODO(), rawArgs)
82 | if err != nil {
83 | return 0, false
84 | }
85 |
86 | return e.complexity.Mutation.Upload(childComplexity, args["file"].(graphql.Upload)), true
87 |
88 | case "Query.hello":
89 | if e.complexity.Query.Hello == nil {
90 | break
91 | }
92 |
93 | args, err := ec.field_Query_hello_args(context.TODO(), rawArgs)
94 | if err != nil {
95 | return 0, false
96 | }
97 |
98 | return e.complexity.Query.Hello(childComplexity, args["name"].(string)), true
99 |
100 | }
101 | return 0, false
102 | }
103 |
104 | func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
105 | ec := executionContext{graphql.GetRequestContext(ctx), e}
106 |
107 | buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
108 | data := ec._Query(ctx, op.SelectionSet)
109 | var buf bytes.Buffer
110 | data.MarshalGQL(&buf)
111 | return buf.Bytes()
112 | })
113 |
114 | return &graphql.Response{
115 | Data: buf,
116 | Errors: ec.Errors,
117 | Extensions: ec.Extensions,
118 | }
119 | }
120 |
121 | func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
122 | ec := executionContext{graphql.GetRequestContext(ctx), e}
123 |
124 | buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
125 | data := ec._Mutation(ctx, op.SelectionSet)
126 | var buf bytes.Buffer
127 | data.MarshalGQL(&buf)
128 | return buf.Bytes()
129 | })
130 |
131 | return &graphql.Response{
132 | Data: buf,
133 | Errors: ec.Errors,
134 | Extensions: ec.Extensions,
135 | }
136 | }
137 |
138 | func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
139 | return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
140 | }
141 |
142 | type executionContext struct {
143 | *graphql.RequestContext
144 | *executableSchema
145 | }
146 |
147 | func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
148 | if ec.DisableIntrospection {
149 | return nil, errors.New("introspection disabled")
150 | }
151 | return introspection.WrapSchema(parsedSchema), nil
152 | }
153 |
154 | func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
155 | if ec.DisableIntrospection {
156 | return nil, errors.New("introspection disabled")
157 | }
158 | return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
159 | }
160 |
161 | var parsedSchema = gqlparser.MustLoadSchema(
162 | &ast.Source{Name: "schema.graphql", Input: `scalar Upload
163 |
164 | type Query {
165 | hello(name: String!): String!
166 | }
167 |
168 | type Mutation {
169 | upload(file: Upload!): String!
170 | }
171 | `},
172 | )
173 |
174 | // endregion ************************** generated!.gotpl **************************
175 |
176 | // region ***************************** args.gotpl *****************************
177 |
178 | func (ec *executionContext) field_Mutation_upload_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
179 | var err error
180 | args := map[string]interface{}{}
181 | var arg0 graphql.Upload
182 | if tmp, ok := rawArgs["file"]; ok {
183 | arg0, err = ec.unmarshalNUpload2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx, tmp)
184 | if err != nil {
185 | return nil, err
186 | }
187 | }
188 | args["file"] = arg0
189 | return args, nil
190 | }
191 |
192 | func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
193 | var err error
194 | args := map[string]interface{}{}
195 | var arg0 string
196 | if tmp, ok := rawArgs["name"]; ok {
197 | arg0, err = ec.unmarshalNString2string(ctx, tmp)
198 | if err != nil {
199 | return nil, err
200 | }
201 | }
202 | args["name"] = arg0
203 | return args, nil
204 | }
205 |
206 | func (ec *executionContext) field_Query_hello_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
207 | var err error
208 | args := map[string]interface{}{}
209 | var arg0 string
210 | if tmp, ok := rawArgs["name"]; ok {
211 | arg0, err = ec.unmarshalNString2string(ctx, tmp)
212 | if err != nil {
213 | return nil, err
214 | }
215 | }
216 | args["name"] = arg0
217 | return args, nil
218 | }
219 |
220 | func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
221 | var err error
222 | args := map[string]interface{}{}
223 | var arg0 bool
224 | if tmp, ok := rawArgs["includeDeprecated"]; ok {
225 | arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
226 | if err != nil {
227 | return nil, err
228 | }
229 | }
230 | args["includeDeprecated"] = arg0
231 | return args, nil
232 | }
233 |
234 | func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
235 | var err error
236 | args := map[string]interface{}{}
237 | var arg0 bool
238 | if tmp, ok := rawArgs["includeDeprecated"]; ok {
239 | arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
240 | if err != nil {
241 | return nil, err
242 | }
243 | }
244 | args["includeDeprecated"] = arg0
245 | return args, nil
246 | }
247 |
248 | // endregion ***************************** args.gotpl *****************************
249 |
250 | // region ************************** directives.gotpl **************************
251 |
252 | // endregion ************************** directives.gotpl **************************
253 |
254 | // region **************************** field.gotpl *****************************
255 |
256 | func (ec *executionContext) _Mutation_upload(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
257 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
258 | defer func() {
259 | if r := recover(); r != nil {
260 | ec.Error(ctx, ec.Recover(ctx, r))
261 | ret = graphql.Null
262 | }
263 | ec.Tracer.EndFieldExecution(ctx)
264 | }()
265 | rctx := &graphql.ResolverContext{
266 | Object: "Mutation",
267 | Field: field,
268 | Args: nil,
269 | IsMethod: true,
270 | }
271 | ctx = graphql.WithResolverContext(ctx, rctx)
272 | rawArgs := field.ArgumentMap(ec.Variables)
273 | args, err := ec.field_Mutation_upload_args(ctx, rawArgs)
274 | if err != nil {
275 | ec.Error(ctx, err)
276 | return graphql.Null
277 | }
278 | rctx.Args = args
279 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
280 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
281 | ctx = rctx // use context from middleware stack in children
282 | return ec.resolvers.Mutation().Upload(rctx, args["file"].(graphql.Upload))
283 | })
284 | if err != nil {
285 | ec.Error(ctx, err)
286 | return graphql.Null
287 | }
288 | if resTmp == nil {
289 | if !ec.HasError(rctx) {
290 | ec.Errorf(ctx, "must not be null")
291 | }
292 | return graphql.Null
293 | }
294 | res := resTmp.(string)
295 | rctx.Result = res
296 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
297 | return ec.marshalNString2string(ctx, field.Selections, res)
298 | }
299 |
300 | func (ec *executionContext) _Query_hello(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
301 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
302 | defer func() {
303 | if r := recover(); r != nil {
304 | ec.Error(ctx, ec.Recover(ctx, r))
305 | ret = graphql.Null
306 | }
307 | ec.Tracer.EndFieldExecution(ctx)
308 | }()
309 | rctx := &graphql.ResolverContext{
310 | Object: "Query",
311 | Field: field,
312 | Args: nil,
313 | IsMethod: true,
314 | }
315 | ctx = graphql.WithResolverContext(ctx, rctx)
316 | rawArgs := field.ArgumentMap(ec.Variables)
317 | args, err := ec.field_Query_hello_args(ctx, rawArgs)
318 | if err != nil {
319 | ec.Error(ctx, err)
320 | return graphql.Null
321 | }
322 | rctx.Args = args
323 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
324 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
325 | ctx = rctx // use context from middleware stack in children
326 | return ec.resolvers.Query().Hello(rctx, args["name"].(string))
327 | })
328 | if err != nil {
329 | ec.Error(ctx, err)
330 | return graphql.Null
331 | }
332 | if resTmp == nil {
333 | if !ec.HasError(rctx) {
334 | ec.Errorf(ctx, "must not be null")
335 | }
336 | return graphql.Null
337 | }
338 | res := resTmp.(string)
339 | rctx.Result = res
340 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
341 | return ec.marshalNString2string(ctx, field.Selections, res)
342 | }
343 |
344 | func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
345 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
346 | defer func() {
347 | if r := recover(); r != nil {
348 | ec.Error(ctx, ec.Recover(ctx, r))
349 | ret = graphql.Null
350 | }
351 | ec.Tracer.EndFieldExecution(ctx)
352 | }()
353 | rctx := &graphql.ResolverContext{
354 | Object: "Query",
355 | Field: field,
356 | Args: nil,
357 | IsMethod: true,
358 | }
359 | ctx = graphql.WithResolverContext(ctx, rctx)
360 | rawArgs := field.ArgumentMap(ec.Variables)
361 | args, err := ec.field_Query___type_args(ctx, rawArgs)
362 | if err != nil {
363 | ec.Error(ctx, err)
364 | return graphql.Null
365 | }
366 | rctx.Args = args
367 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
368 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
369 | ctx = rctx // use context from middleware stack in children
370 | return ec.introspectType(args["name"].(string))
371 | })
372 | if err != nil {
373 | ec.Error(ctx, err)
374 | return graphql.Null
375 | }
376 | if resTmp == nil {
377 | return graphql.Null
378 | }
379 | res := resTmp.(*introspection.Type)
380 | rctx.Result = res
381 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
382 | return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
383 | }
384 |
385 | func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
386 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
387 | defer func() {
388 | if r := recover(); r != nil {
389 | ec.Error(ctx, ec.Recover(ctx, r))
390 | ret = graphql.Null
391 | }
392 | ec.Tracer.EndFieldExecution(ctx)
393 | }()
394 | rctx := &graphql.ResolverContext{
395 | Object: "Query",
396 | Field: field,
397 | Args: nil,
398 | IsMethod: true,
399 | }
400 | ctx = graphql.WithResolverContext(ctx, rctx)
401 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
402 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
403 | ctx = rctx // use context from middleware stack in children
404 | return ec.introspectSchema()
405 | })
406 | if err != nil {
407 | ec.Error(ctx, err)
408 | return graphql.Null
409 | }
410 | if resTmp == nil {
411 | return graphql.Null
412 | }
413 | res := resTmp.(*introspection.Schema)
414 | rctx.Result = res
415 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
416 | return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
417 | }
418 |
419 | func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
420 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
421 | defer func() {
422 | if r := recover(); r != nil {
423 | ec.Error(ctx, ec.Recover(ctx, r))
424 | ret = graphql.Null
425 | }
426 | ec.Tracer.EndFieldExecution(ctx)
427 | }()
428 | rctx := &graphql.ResolverContext{
429 | Object: "__Directive",
430 | Field: field,
431 | Args: nil,
432 | IsMethod: false,
433 | }
434 | ctx = graphql.WithResolverContext(ctx, rctx)
435 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
436 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
437 | ctx = rctx // use context from middleware stack in children
438 | return obj.Name, nil
439 | })
440 | if err != nil {
441 | ec.Error(ctx, err)
442 | return graphql.Null
443 | }
444 | if resTmp == nil {
445 | if !ec.HasError(rctx) {
446 | ec.Errorf(ctx, "must not be null")
447 | }
448 | return graphql.Null
449 | }
450 | res := resTmp.(string)
451 | rctx.Result = res
452 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
453 | return ec.marshalNString2string(ctx, field.Selections, res)
454 | }
455 |
456 | func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
457 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
458 | defer func() {
459 | if r := recover(); r != nil {
460 | ec.Error(ctx, ec.Recover(ctx, r))
461 | ret = graphql.Null
462 | }
463 | ec.Tracer.EndFieldExecution(ctx)
464 | }()
465 | rctx := &graphql.ResolverContext{
466 | Object: "__Directive",
467 | Field: field,
468 | Args: nil,
469 | IsMethod: false,
470 | }
471 | ctx = graphql.WithResolverContext(ctx, rctx)
472 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
473 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
474 | ctx = rctx // use context from middleware stack in children
475 | return obj.Description, nil
476 | })
477 | if err != nil {
478 | ec.Error(ctx, err)
479 | return graphql.Null
480 | }
481 | if resTmp == nil {
482 | return graphql.Null
483 | }
484 | res := resTmp.(string)
485 | rctx.Result = res
486 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
487 | return ec.marshalOString2string(ctx, field.Selections, res)
488 | }
489 |
490 | func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
491 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
492 | defer func() {
493 | if r := recover(); r != nil {
494 | ec.Error(ctx, ec.Recover(ctx, r))
495 | ret = graphql.Null
496 | }
497 | ec.Tracer.EndFieldExecution(ctx)
498 | }()
499 | rctx := &graphql.ResolverContext{
500 | Object: "__Directive",
501 | Field: field,
502 | Args: nil,
503 | IsMethod: false,
504 | }
505 | ctx = graphql.WithResolverContext(ctx, rctx)
506 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
507 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
508 | ctx = rctx // use context from middleware stack in children
509 | return obj.Locations, nil
510 | })
511 | if err != nil {
512 | ec.Error(ctx, err)
513 | return graphql.Null
514 | }
515 | if resTmp == nil {
516 | if !ec.HasError(rctx) {
517 | ec.Errorf(ctx, "must not be null")
518 | }
519 | return graphql.Null
520 | }
521 | res := resTmp.([]string)
522 | rctx.Result = res
523 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
524 | return ec.marshalN__DirectiveLocation2ᚕstring(ctx, field.Selections, res)
525 | }
526 |
527 | func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
528 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
529 | defer func() {
530 | if r := recover(); r != nil {
531 | ec.Error(ctx, ec.Recover(ctx, r))
532 | ret = graphql.Null
533 | }
534 | ec.Tracer.EndFieldExecution(ctx)
535 | }()
536 | rctx := &graphql.ResolverContext{
537 | Object: "__Directive",
538 | Field: field,
539 | Args: nil,
540 | IsMethod: false,
541 | }
542 | ctx = graphql.WithResolverContext(ctx, rctx)
543 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
544 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
545 | ctx = rctx // use context from middleware stack in children
546 | return obj.Args, nil
547 | })
548 | if err != nil {
549 | ec.Error(ctx, err)
550 | return graphql.Null
551 | }
552 | if resTmp == nil {
553 | if !ec.HasError(rctx) {
554 | ec.Errorf(ctx, "must not be null")
555 | }
556 | return graphql.Null
557 | }
558 | res := resTmp.([]introspection.InputValue)
559 | rctx.Result = res
560 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
561 | return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
562 | }
563 |
564 | func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
565 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
566 | defer func() {
567 | if r := recover(); r != nil {
568 | ec.Error(ctx, ec.Recover(ctx, r))
569 | ret = graphql.Null
570 | }
571 | ec.Tracer.EndFieldExecution(ctx)
572 | }()
573 | rctx := &graphql.ResolverContext{
574 | Object: "__EnumValue",
575 | Field: field,
576 | Args: nil,
577 | IsMethod: false,
578 | }
579 | ctx = graphql.WithResolverContext(ctx, rctx)
580 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
581 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
582 | ctx = rctx // use context from middleware stack in children
583 | return obj.Name, nil
584 | })
585 | if err != nil {
586 | ec.Error(ctx, err)
587 | return graphql.Null
588 | }
589 | if resTmp == nil {
590 | if !ec.HasError(rctx) {
591 | ec.Errorf(ctx, "must not be null")
592 | }
593 | return graphql.Null
594 | }
595 | res := resTmp.(string)
596 | rctx.Result = res
597 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
598 | return ec.marshalNString2string(ctx, field.Selections, res)
599 | }
600 |
601 | func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
602 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
603 | defer func() {
604 | if r := recover(); r != nil {
605 | ec.Error(ctx, ec.Recover(ctx, r))
606 | ret = graphql.Null
607 | }
608 | ec.Tracer.EndFieldExecution(ctx)
609 | }()
610 | rctx := &graphql.ResolverContext{
611 | Object: "__EnumValue",
612 | Field: field,
613 | Args: nil,
614 | IsMethod: false,
615 | }
616 | ctx = graphql.WithResolverContext(ctx, rctx)
617 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
618 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
619 | ctx = rctx // use context from middleware stack in children
620 | return obj.Description, nil
621 | })
622 | if err != nil {
623 | ec.Error(ctx, err)
624 | return graphql.Null
625 | }
626 | if resTmp == nil {
627 | return graphql.Null
628 | }
629 | res := resTmp.(string)
630 | rctx.Result = res
631 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
632 | return ec.marshalOString2string(ctx, field.Selections, res)
633 | }
634 |
635 | func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
636 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
637 | defer func() {
638 | if r := recover(); r != nil {
639 | ec.Error(ctx, ec.Recover(ctx, r))
640 | ret = graphql.Null
641 | }
642 | ec.Tracer.EndFieldExecution(ctx)
643 | }()
644 | rctx := &graphql.ResolverContext{
645 | Object: "__EnumValue",
646 | Field: field,
647 | Args: nil,
648 | IsMethod: true,
649 | }
650 | ctx = graphql.WithResolverContext(ctx, rctx)
651 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
652 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
653 | ctx = rctx // use context from middleware stack in children
654 | return obj.IsDeprecated(), nil
655 | })
656 | if err != nil {
657 | ec.Error(ctx, err)
658 | return graphql.Null
659 | }
660 | if resTmp == nil {
661 | if !ec.HasError(rctx) {
662 | ec.Errorf(ctx, "must not be null")
663 | }
664 | return graphql.Null
665 | }
666 | res := resTmp.(bool)
667 | rctx.Result = res
668 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
669 | return ec.marshalNBoolean2bool(ctx, field.Selections, res)
670 | }
671 |
672 | func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
673 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
674 | defer func() {
675 | if r := recover(); r != nil {
676 | ec.Error(ctx, ec.Recover(ctx, r))
677 | ret = graphql.Null
678 | }
679 | ec.Tracer.EndFieldExecution(ctx)
680 | }()
681 | rctx := &graphql.ResolverContext{
682 | Object: "__EnumValue",
683 | Field: field,
684 | Args: nil,
685 | IsMethod: true,
686 | }
687 | ctx = graphql.WithResolverContext(ctx, rctx)
688 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
689 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
690 | ctx = rctx // use context from middleware stack in children
691 | return obj.DeprecationReason(), nil
692 | })
693 | if err != nil {
694 | ec.Error(ctx, err)
695 | return graphql.Null
696 | }
697 | if resTmp == nil {
698 | return graphql.Null
699 | }
700 | res := resTmp.(*string)
701 | rctx.Result = res
702 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
703 | return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
704 | }
705 |
706 | func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
707 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
708 | defer func() {
709 | if r := recover(); r != nil {
710 | ec.Error(ctx, ec.Recover(ctx, r))
711 | ret = graphql.Null
712 | }
713 | ec.Tracer.EndFieldExecution(ctx)
714 | }()
715 | rctx := &graphql.ResolverContext{
716 | Object: "__Field",
717 | Field: field,
718 | Args: nil,
719 | IsMethod: false,
720 | }
721 | ctx = graphql.WithResolverContext(ctx, rctx)
722 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
723 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
724 | ctx = rctx // use context from middleware stack in children
725 | return obj.Name, nil
726 | })
727 | if err != nil {
728 | ec.Error(ctx, err)
729 | return graphql.Null
730 | }
731 | if resTmp == nil {
732 | if !ec.HasError(rctx) {
733 | ec.Errorf(ctx, "must not be null")
734 | }
735 | return graphql.Null
736 | }
737 | res := resTmp.(string)
738 | rctx.Result = res
739 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
740 | return ec.marshalNString2string(ctx, field.Selections, res)
741 | }
742 |
743 | func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
744 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
745 | defer func() {
746 | if r := recover(); r != nil {
747 | ec.Error(ctx, ec.Recover(ctx, r))
748 | ret = graphql.Null
749 | }
750 | ec.Tracer.EndFieldExecution(ctx)
751 | }()
752 | rctx := &graphql.ResolverContext{
753 | Object: "__Field",
754 | Field: field,
755 | Args: nil,
756 | IsMethod: false,
757 | }
758 | ctx = graphql.WithResolverContext(ctx, rctx)
759 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
760 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
761 | ctx = rctx // use context from middleware stack in children
762 | return obj.Description, nil
763 | })
764 | if err != nil {
765 | ec.Error(ctx, err)
766 | return graphql.Null
767 | }
768 | if resTmp == nil {
769 | return graphql.Null
770 | }
771 | res := resTmp.(string)
772 | rctx.Result = res
773 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
774 | return ec.marshalOString2string(ctx, field.Selections, res)
775 | }
776 |
777 | func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
778 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
779 | defer func() {
780 | if r := recover(); r != nil {
781 | ec.Error(ctx, ec.Recover(ctx, r))
782 | ret = graphql.Null
783 | }
784 | ec.Tracer.EndFieldExecution(ctx)
785 | }()
786 | rctx := &graphql.ResolverContext{
787 | Object: "__Field",
788 | Field: field,
789 | Args: nil,
790 | IsMethod: false,
791 | }
792 | ctx = graphql.WithResolverContext(ctx, rctx)
793 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
794 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
795 | ctx = rctx // use context from middleware stack in children
796 | return obj.Args, nil
797 | })
798 | if err != nil {
799 | ec.Error(ctx, err)
800 | return graphql.Null
801 | }
802 | if resTmp == nil {
803 | if !ec.HasError(rctx) {
804 | ec.Errorf(ctx, "must not be null")
805 | }
806 | return graphql.Null
807 | }
808 | res := resTmp.([]introspection.InputValue)
809 | rctx.Result = res
810 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
811 | return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
812 | }
813 |
814 | func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
815 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
816 | defer func() {
817 | if r := recover(); r != nil {
818 | ec.Error(ctx, ec.Recover(ctx, r))
819 | ret = graphql.Null
820 | }
821 | ec.Tracer.EndFieldExecution(ctx)
822 | }()
823 | rctx := &graphql.ResolverContext{
824 | Object: "__Field",
825 | Field: field,
826 | Args: nil,
827 | IsMethod: false,
828 | }
829 | ctx = graphql.WithResolverContext(ctx, rctx)
830 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
831 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
832 | ctx = rctx // use context from middleware stack in children
833 | return obj.Type, nil
834 | })
835 | if err != nil {
836 | ec.Error(ctx, err)
837 | return graphql.Null
838 | }
839 | if resTmp == nil {
840 | if !ec.HasError(rctx) {
841 | ec.Errorf(ctx, "must not be null")
842 | }
843 | return graphql.Null
844 | }
845 | res := resTmp.(*introspection.Type)
846 | rctx.Result = res
847 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
848 | return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
849 | }
850 |
851 | func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
852 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
853 | defer func() {
854 | if r := recover(); r != nil {
855 | ec.Error(ctx, ec.Recover(ctx, r))
856 | ret = graphql.Null
857 | }
858 | ec.Tracer.EndFieldExecution(ctx)
859 | }()
860 | rctx := &graphql.ResolverContext{
861 | Object: "__Field",
862 | Field: field,
863 | Args: nil,
864 | IsMethod: true,
865 | }
866 | ctx = graphql.WithResolverContext(ctx, rctx)
867 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
868 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
869 | ctx = rctx // use context from middleware stack in children
870 | return obj.IsDeprecated(), nil
871 | })
872 | if err != nil {
873 | ec.Error(ctx, err)
874 | return graphql.Null
875 | }
876 | if resTmp == nil {
877 | if !ec.HasError(rctx) {
878 | ec.Errorf(ctx, "must not be null")
879 | }
880 | return graphql.Null
881 | }
882 | res := resTmp.(bool)
883 | rctx.Result = res
884 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
885 | return ec.marshalNBoolean2bool(ctx, field.Selections, res)
886 | }
887 |
888 | func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
889 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
890 | defer func() {
891 | if r := recover(); r != nil {
892 | ec.Error(ctx, ec.Recover(ctx, r))
893 | ret = graphql.Null
894 | }
895 | ec.Tracer.EndFieldExecution(ctx)
896 | }()
897 | rctx := &graphql.ResolverContext{
898 | Object: "__Field",
899 | Field: field,
900 | Args: nil,
901 | IsMethod: true,
902 | }
903 | ctx = graphql.WithResolverContext(ctx, rctx)
904 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
905 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
906 | ctx = rctx // use context from middleware stack in children
907 | return obj.DeprecationReason(), nil
908 | })
909 | if err != nil {
910 | ec.Error(ctx, err)
911 | return graphql.Null
912 | }
913 | if resTmp == nil {
914 | return graphql.Null
915 | }
916 | res := resTmp.(*string)
917 | rctx.Result = res
918 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
919 | return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
920 | }
921 |
922 | func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
923 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
924 | defer func() {
925 | if r := recover(); r != nil {
926 | ec.Error(ctx, ec.Recover(ctx, r))
927 | ret = graphql.Null
928 | }
929 | ec.Tracer.EndFieldExecution(ctx)
930 | }()
931 | rctx := &graphql.ResolverContext{
932 | Object: "__InputValue",
933 | Field: field,
934 | Args: nil,
935 | IsMethod: false,
936 | }
937 | ctx = graphql.WithResolverContext(ctx, rctx)
938 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
939 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
940 | ctx = rctx // use context from middleware stack in children
941 | return obj.Name, nil
942 | })
943 | if err != nil {
944 | ec.Error(ctx, err)
945 | return graphql.Null
946 | }
947 | if resTmp == nil {
948 | if !ec.HasError(rctx) {
949 | ec.Errorf(ctx, "must not be null")
950 | }
951 | return graphql.Null
952 | }
953 | res := resTmp.(string)
954 | rctx.Result = res
955 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
956 | return ec.marshalNString2string(ctx, field.Selections, res)
957 | }
958 |
959 | func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
960 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
961 | defer func() {
962 | if r := recover(); r != nil {
963 | ec.Error(ctx, ec.Recover(ctx, r))
964 | ret = graphql.Null
965 | }
966 | ec.Tracer.EndFieldExecution(ctx)
967 | }()
968 | rctx := &graphql.ResolverContext{
969 | Object: "__InputValue",
970 | Field: field,
971 | Args: nil,
972 | IsMethod: false,
973 | }
974 | ctx = graphql.WithResolverContext(ctx, rctx)
975 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
976 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
977 | ctx = rctx // use context from middleware stack in children
978 | return obj.Description, nil
979 | })
980 | if err != nil {
981 | ec.Error(ctx, err)
982 | return graphql.Null
983 | }
984 | if resTmp == nil {
985 | return graphql.Null
986 | }
987 | res := resTmp.(string)
988 | rctx.Result = res
989 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
990 | return ec.marshalOString2string(ctx, field.Selections, res)
991 | }
992 |
993 | func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
994 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
995 | defer func() {
996 | if r := recover(); r != nil {
997 | ec.Error(ctx, ec.Recover(ctx, r))
998 | ret = graphql.Null
999 | }
1000 | ec.Tracer.EndFieldExecution(ctx)
1001 | }()
1002 | rctx := &graphql.ResolverContext{
1003 | Object: "__InputValue",
1004 | Field: field,
1005 | Args: nil,
1006 | IsMethod: false,
1007 | }
1008 | ctx = graphql.WithResolverContext(ctx, rctx)
1009 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1010 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1011 | ctx = rctx // use context from middleware stack in children
1012 | return obj.Type, nil
1013 | })
1014 | if err != nil {
1015 | ec.Error(ctx, err)
1016 | return graphql.Null
1017 | }
1018 | if resTmp == nil {
1019 | if !ec.HasError(rctx) {
1020 | ec.Errorf(ctx, "must not be null")
1021 | }
1022 | return graphql.Null
1023 | }
1024 | res := resTmp.(*introspection.Type)
1025 | rctx.Result = res
1026 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1027 | return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1028 | }
1029 |
1030 | func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
1031 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1032 | defer func() {
1033 | if r := recover(); r != nil {
1034 | ec.Error(ctx, ec.Recover(ctx, r))
1035 | ret = graphql.Null
1036 | }
1037 | ec.Tracer.EndFieldExecution(ctx)
1038 | }()
1039 | rctx := &graphql.ResolverContext{
1040 | Object: "__InputValue",
1041 | Field: field,
1042 | Args: nil,
1043 | IsMethod: false,
1044 | }
1045 | ctx = graphql.WithResolverContext(ctx, rctx)
1046 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1047 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1048 | ctx = rctx // use context from middleware stack in children
1049 | return obj.DefaultValue, nil
1050 | })
1051 | if err != nil {
1052 | ec.Error(ctx, err)
1053 | return graphql.Null
1054 | }
1055 | if resTmp == nil {
1056 | return graphql.Null
1057 | }
1058 | res := resTmp.(*string)
1059 | rctx.Result = res
1060 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1061 | return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1062 | }
1063 |
1064 | func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1065 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1066 | defer func() {
1067 | if r := recover(); r != nil {
1068 | ec.Error(ctx, ec.Recover(ctx, r))
1069 | ret = graphql.Null
1070 | }
1071 | ec.Tracer.EndFieldExecution(ctx)
1072 | }()
1073 | rctx := &graphql.ResolverContext{
1074 | Object: "__Schema",
1075 | Field: field,
1076 | Args: nil,
1077 | IsMethod: true,
1078 | }
1079 | ctx = graphql.WithResolverContext(ctx, rctx)
1080 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1081 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1082 | ctx = rctx // use context from middleware stack in children
1083 | return obj.Types(), nil
1084 | })
1085 | if err != nil {
1086 | ec.Error(ctx, err)
1087 | return graphql.Null
1088 | }
1089 | if resTmp == nil {
1090 | if !ec.HasError(rctx) {
1091 | ec.Errorf(ctx, "must not be null")
1092 | }
1093 | return graphql.Null
1094 | }
1095 | res := resTmp.([]introspection.Type)
1096 | rctx.Result = res
1097 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1098 | return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1099 | }
1100 |
1101 | func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1102 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1103 | defer func() {
1104 | if r := recover(); r != nil {
1105 | ec.Error(ctx, ec.Recover(ctx, r))
1106 | ret = graphql.Null
1107 | }
1108 | ec.Tracer.EndFieldExecution(ctx)
1109 | }()
1110 | rctx := &graphql.ResolverContext{
1111 | Object: "__Schema",
1112 | Field: field,
1113 | Args: nil,
1114 | IsMethod: true,
1115 | }
1116 | ctx = graphql.WithResolverContext(ctx, rctx)
1117 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1118 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1119 | ctx = rctx // use context from middleware stack in children
1120 | return obj.QueryType(), nil
1121 | })
1122 | if err != nil {
1123 | ec.Error(ctx, err)
1124 | return graphql.Null
1125 | }
1126 | if resTmp == nil {
1127 | if !ec.HasError(rctx) {
1128 | ec.Errorf(ctx, "must not be null")
1129 | }
1130 | return graphql.Null
1131 | }
1132 | res := resTmp.(*introspection.Type)
1133 | rctx.Result = res
1134 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1135 | return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1136 | }
1137 |
1138 | func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1139 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1140 | defer func() {
1141 | if r := recover(); r != nil {
1142 | ec.Error(ctx, ec.Recover(ctx, r))
1143 | ret = graphql.Null
1144 | }
1145 | ec.Tracer.EndFieldExecution(ctx)
1146 | }()
1147 | rctx := &graphql.ResolverContext{
1148 | Object: "__Schema",
1149 | Field: field,
1150 | Args: nil,
1151 | IsMethod: true,
1152 | }
1153 | ctx = graphql.WithResolverContext(ctx, rctx)
1154 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1155 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1156 | ctx = rctx // use context from middleware stack in children
1157 | return obj.MutationType(), nil
1158 | })
1159 | if err != nil {
1160 | ec.Error(ctx, err)
1161 | return graphql.Null
1162 | }
1163 | if resTmp == nil {
1164 | return graphql.Null
1165 | }
1166 | res := resTmp.(*introspection.Type)
1167 | rctx.Result = res
1168 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1169 | return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1170 | }
1171 |
1172 | func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1173 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1174 | defer func() {
1175 | if r := recover(); r != nil {
1176 | ec.Error(ctx, ec.Recover(ctx, r))
1177 | ret = graphql.Null
1178 | }
1179 | ec.Tracer.EndFieldExecution(ctx)
1180 | }()
1181 | rctx := &graphql.ResolverContext{
1182 | Object: "__Schema",
1183 | Field: field,
1184 | Args: nil,
1185 | IsMethod: true,
1186 | }
1187 | ctx = graphql.WithResolverContext(ctx, rctx)
1188 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1189 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1190 | ctx = rctx // use context from middleware stack in children
1191 | return obj.SubscriptionType(), nil
1192 | })
1193 | if err != nil {
1194 | ec.Error(ctx, err)
1195 | return graphql.Null
1196 | }
1197 | if resTmp == nil {
1198 | return graphql.Null
1199 | }
1200 | res := resTmp.(*introspection.Type)
1201 | rctx.Result = res
1202 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1203 | return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1204 | }
1205 |
1206 | func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1207 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1208 | defer func() {
1209 | if r := recover(); r != nil {
1210 | ec.Error(ctx, ec.Recover(ctx, r))
1211 | ret = graphql.Null
1212 | }
1213 | ec.Tracer.EndFieldExecution(ctx)
1214 | }()
1215 | rctx := &graphql.ResolverContext{
1216 | Object: "__Schema",
1217 | Field: field,
1218 | Args: nil,
1219 | IsMethod: true,
1220 | }
1221 | ctx = graphql.WithResolverContext(ctx, rctx)
1222 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1223 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1224 | ctx = rctx // use context from middleware stack in children
1225 | return obj.Directives(), nil
1226 | })
1227 | if err != nil {
1228 | ec.Error(ctx, err)
1229 | return graphql.Null
1230 | }
1231 | if resTmp == nil {
1232 | if !ec.HasError(rctx) {
1233 | ec.Errorf(ctx, "must not be null")
1234 | }
1235 | return graphql.Null
1236 | }
1237 | res := resTmp.([]introspection.Directive)
1238 | rctx.Result = res
1239 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1240 | return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, field.Selections, res)
1241 | }
1242 |
1243 | func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1244 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1245 | defer func() {
1246 | if r := recover(); r != nil {
1247 | ec.Error(ctx, ec.Recover(ctx, r))
1248 | ret = graphql.Null
1249 | }
1250 | ec.Tracer.EndFieldExecution(ctx)
1251 | }()
1252 | rctx := &graphql.ResolverContext{
1253 | Object: "__Type",
1254 | Field: field,
1255 | Args: nil,
1256 | IsMethod: true,
1257 | }
1258 | ctx = graphql.WithResolverContext(ctx, rctx)
1259 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1260 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1261 | ctx = rctx // use context from middleware stack in children
1262 | return obj.Kind(), nil
1263 | })
1264 | if err != nil {
1265 | ec.Error(ctx, err)
1266 | return graphql.Null
1267 | }
1268 | if resTmp == nil {
1269 | if !ec.HasError(rctx) {
1270 | ec.Errorf(ctx, "must not be null")
1271 | }
1272 | return graphql.Null
1273 | }
1274 | res := resTmp.(string)
1275 | rctx.Result = res
1276 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1277 | return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
1278 | }
1279 |
1280 | func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1281 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1282 | defer func() {
1283 | if r := recover(); r != nil {
1284 | ec.Error(ctx, ec.Recover(ctx, r))
1285 | ret = graphql.Null
1286 | }
1287 | ec.Tracer.EndFieldExecution(ctx)
1288 | }()
1289 | rctx := &graphql.ResolverContext{
1290 | Object: "__Type",
1291 | Field: field,
1292 | Args: nil,
1293 | IsMethod: true,
1294 | }
1295 | ctx = graphql.WithResolverContext(ctx, rctx)
1296 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1297 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1298 | ctx = rctx // use context from middleware stack in children
1299 | return obj.Name(), nil
1300 | })
1301 | if err != nil {
1302 | ec.Error(ctx, err)
1303 | return graphql.Null
1304 | }
1305 | if resTmp == nil {
1306 | return graphql.Null
1307 | }
1308 | res := resTmp.(*string)
1309 | rctx.Result = res
1310 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1311 | return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1312 | }
1313 |
1314 | func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1315 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1316 | defer func() {
1317 | if r := recover(); r != nil {
1318 | ec.Error(ctx, ec.Recover(ctx, r))
1319 | ret = graphql.Null
1320 | }
1321 | ec.Tracer.EndFieldExecution(ctx)
1322 | }()
1323 | rctx := &graphql.ResolverContext{
1324 | Object: "__Type",
1325 | Field: field,
1326 | Args: nil,
1327 | IsMethod: true,
1328 | }
1329 | ctx = graphql.WithResolverContext(ctx, rctx)
1330 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1331 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1332 | ctx = rctx // use context from middleware stack in children
1333 | return obj.Description(), nil
1334 | })
1335 | if err != nil {
1336 | ec.Error(ctx, err)
1337 | return graphql.Null
1338 | }
1339 | if resTmp == nil {
1340 | return graphql.Null
1341 | }
1342 | res := resTmp.(string)
1343 | rctx.Result = res
1344 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1345 | return ec.marshalOString2string(ctx, field.Selections, res)
1346 | }
1347 |
1348 | func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1349 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1350 | defer func() {
1351 | if r := recover(); r != nil {
1352 | ec.Error(ctx, ec.Recover(ctx, r))
1353 | ret = graphql.Null
1354 | }
1355 | ec.Tracer.EndFieldExecution(ctx)
1356 | }()
1357 | rctx := &graphql.ResolverContext{
1358 | Object: "__Type",
1359 | Field: field,
1360 | Args: nil,
1361 | IsMethod: true,
1362 | }
1363 | ctx = graphql.WithResolverContext(ctx, rctx)
1364 | rawArgs := field.ArgumentMap(ec.Variables)
1365 | args, err := ec.field___Type_fields_args(ctx, rawArgs)
1366 | if err != nil {
1367 | ec.Error(ctx, err)
1368 | return graphql.Null
1369 | }
1370 | rctx.Args = args
1371 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1372 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1373 | ctx = rctx // use context from middleware stack in children
1374 | return obj.Fields(args["includeDeprecated"].(bool)), nil
1375 | })
1376 | if err != nil {
1377 | ec.Error(ctx, err)
1378 | return graphql.Null
1379 | }
1380 | if resTmp == nil {
1381 | return graphql.Null
1382 | }
1383 | res := resTmp.([]introspection.Field)
1384 | rctx.Result = res
1385 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1386 | return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, field.Selections, res)
1387 | }
1388 |
1389 | func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1390 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1391 | defer func() {
1392 | if r := recover(); r != nil {
1393 | ec.Error(ctx, ec.Recover(ctx, r))
1394 | ret = graphql.Null
1395 | }
1396 | ec.Tracer.EndFieldExecution(ctx)
1397 | }()
1398 | rctx := &graphql.ResolverContext{
1399 | Object: "__Type",
1400 | Field: field,
1401 | Args: nil,
1402 | IsMethod: true,
1403 | }
1404 | ctx = graphql.WithResolverContext(ctx, rctx)
1405 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1406 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1407 | ctx = rctx // use context from middleware stack in children
1408 | return obj.Interfaces(), nil
1409 | })
1410 | if err != nil {
1411 | ec.Error(ctx, err)
1412 | return graphql.Null
1413 | }
1414 | if resTmp == nil {
1415 | return graphql.Null
1416 | }
1417 | res := resTmp.([]introspection.Type)
1418 | rctx.Result = res
1419 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1420 | return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1421 | }
1422 |
1423 | func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1424 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1425 | defer func() {
1426 | if r := recover(); r != nil {
1427 | ec.Error(ctx, ec.Recover(ctx, r))
1428 | ret = graphql.Null
1429 | }
1430 | ec.Tracer.EndFieldExecution(ctx)
1431 | }()
1432 | rctx := &graphql.ResolverContext{
1433 | Object: "__Type",
1434 | Field: field,
1435 | Args: nil,
1436 | IsMethod: true,
1437 | }
1438 | ctx = graphql.WithResolverContext(ctx, rctx)
1439 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1440 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1441 | ctx = rctx // use context from middleware stack in children
1442 | return obj.PossibleTypes(), nil
1443 | })
1444 | if err != nil {
1445 | ec.Error(ctx, err)
1446 | return graphql.Null
1447 | }
1448 | if resTmp == nil {
1449 | return graphql.Null
1450 | }
1451 | res := resTmp.([]introspection.Type)
1452 | rctx.Result = res
1453 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1454 | return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1455 | }
1456 |
1457 | func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1458 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1459 | defer func() {
1460 | if r := recover(); r != nil {
1461 | ec.Error(ctx, ec.Recover(ctx, r))
1462 | ret = graphql.Null
1463 | }
1464 | ec.Tracer.EndFieldExecution(ctx)
1465 | }()
1466 | rctx := &graphql.ResolverContext{
1467 | Object: "__Type",
1468 | Field: field,
1469 | Args: nil,
1470 | IsMethod: true,
1471 | }
1472 | ctx = graphql.WithResolverContext(ctx, rctx)
1473 | rawArgs := field.ArgumentMap(ec.Variables)
1474 | args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
1475 | if err != nil {
1476 | ec.Error(ctx, err)
1477 | return graphql.Null
1478 | }
1479 | rctx.Args = args
1480 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1481 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1482 | ctx = rctx // use context from middleware stack in children
1483 | return obj.EnumValues(args["includeDeprecated"].(bool)), nil
1484 | })
1485 | if err != nil {
1486 | ec.Error(ctx, err)
1487 | return graphql.Null
1488 | }
1489 | if resTmp == nil {
1490 | return graphql.Null
1491 | }
1492 | res := resTmp.([]introspection.EnumValue)
1493 | rctx.Result = res
1494 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1495 | return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, field.Selections, res)
1496 | }
1497 |
1498 | func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1499 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1500 | defer func() {
1501 | if r := recover(); r != nil {
1502 | ec.Error(ctx, ec.Recover(ctx, r))
1503 | ret = graphql.Null
1504 | }
1505 | ec.Tracer.EndFieldExecution(ctx)
1506 | }()
1507 | rctx := &graphql.ResolverContext{
1508 | Object: "__Type",
1509 | Field: field,
1510 | Args: nil,
1511 | IsMethod: true,
1512 | }
1513 | ctx = graphql.WithResolverContext(ctx, rctx)
1514 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1515 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1516 | ctx = rctx // use context from middleware stack in children
1517 | return obj.InputFields(), nil
1518 | })
1519 | if err != nil {
1520 | ec.Error(ctx, err)
1521 | return graphql.Null
1522 | }
1523 | if resTmp == nil {
1524 | return graphql.Null
1525 | }
1526 | res := resTmp.([]introspection.InputValue)
1527 | rctx.Result = res
1528 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1529 | return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
1530 | }
1531 |
1532 | func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1533 | ctx = ec.Tracer.StartFieldExecution(ctx, field)
1534 | defer func() {
1535 | if r := recover(); r != nil {
1536 | ec.Error(ctx, ec.Recover(ctx, r))
1537 | ret = graphql.Null
1538 | }
1539 | ec.Tracer.EndFieldExecution(ctx)
1540 | }()
1541 | rctx := &graphql.ResolverContext{
1542 | Object: "__Type",
1543 | Field: field,
1544 | Args: nil,
1545 | IsMethod: true,
1546 | }
1547 | ctx = graphql.WithResolverContext(ctx, rctx)
1548 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
1549 | resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1550 | ctx = rctx // use context from middleware stack in children
1551 | return obj.OfType(), nil
1552 | })
1553 | if err != nil {
1554 | ec.Error(ctx, err)
1555 | return graphql.Null
1556 | }
1557 | if resTmp == nil {
1558 | return graphql.Null
1559 | }
1560 | res := resTmp.(*introspection.Type)
1561 | rctx.Result = res
1562 | ctx = ec.Tracer.StartFieldChildExecution(ctx)
1563 | return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1564 | }
1565 |
1566 | // endregion **************************** field.gotpl *****************************
1567 |
1568 | // region **************************** input.gotpl *****************************
1569 |
1570 | // endregion **************************** input.gotpl *****************************
1571 |
1572 | // region ************************** interface.gotpl ***************************
1573 |
1574 | // endregion ************************** interface.gotpl ***************************
1575 |
1576 | // region **************************** object.gotpl ****************************
1577 |
1578 | var mutationImplementors = []string{"Mutation"}
1579 |
1580 | func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
1581 | fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
1582 |
1583 | ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
1584 | Object: "Mutation",
1585 | })
1586 |
1587 | out := graphql.NewFieldSet(fields)
1588 | var invalids uint32
1589 | for i, field := range fields {
1590 | switch field.Name {
1591 | case "__typename":
1592 | out.Values[i] = graphql.MarshalString("Mutation")
1593 | case "upload":
1594 | out.Values[i] = ec._Mutation_upload(ctx, field)
1595 | if out.Values[i] == graphql.Null {
1596 | invalids++
1597 | }
1598 | default:
1599 | panic("unknown field " + strconv.Quote(field.Name))
1600 | }
1601 | }
1602 | out.Dispatch()
1603 | if invalids > 0 {
1604 | return graphql.Null
1605 | }
1606 | return out
1607 | }
1608 |
1609 | var queryImplementors = []string{"Query"}
1610 |
1611 | func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
1612 | fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
1613 |
1614 | ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
1615 | Object: "Query",
1616 | })
1617 |
1618 | out := graphql.NewFieldSet(fields)
1619 | var invalids uint32
1620 | for i, field := range fields {
1621 | switch field.Name {
1622 | case "__typename":
1623 | out.Values[i] = graphql.MarshalString("Query")
1624 | case "hello":
1625 | field := field
1626 | out.Concurrently(i, func() (res graphql.Marshaler) {
1627 | defer func() {
1628 | if r := recover(); r != nil {
1629 | ec.Error(ctx, ec.Recover(ctx, r))
1630 | }
1631 | }()
1632 | res = ec._Query_hello(ctx, field)
1633 | if res == graphql.Null {
1634 | atomic.AddUint32(&invalids, 1)
1635 | }
1636 | return res
1637 | })
1638 | case "__type":
1639 | out.Values[i] = ec._Query___type(ctx, field)
1640 | case "__schema":
1641 | out.Values[i] = ec._Query___schema(ctx, field)
1642 | default:
1643 | panic("unknown field " + strconv.Quote(field.Name))
1644 | }
1645 | }
1646 | out.Dispatch()
1647 | if invalids > 0 {
1648 | return graphql.Null
1649 | }
1650 | return out
1651 | }
1652 |
1653 | var __DirectiveImplementors = []string{"__Directive"}
1654 |
1655 | func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
1656 | fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
1657 |
1658 | out := graphql.NewFieldSet(fields)
1659 | var invalids uint32
1660 | for i, field := range fields {
1661 | switch field.Name {
1662 | case "__typename":
1663 | out.Values[i] = graphql.MarshalString("__Directive")
1664 | case "name":
1665 | out.Values[i] = ec.___Directive_name(ctx, field, obj)
1666 | if out.Values[i] == graphql.Null {
1667 | invalids++
1668 | }
1669 | case "description":
1670 | out.Values[i] = ec.___Directive_description(ctx, field, obj)
1671 | case "locations":
1672 | out.Values[i] = ec.___Directive_locations(ctx, field, obj)
1673 | if out.Values[i] == graphql.Null {
1674 | invalids++
1675 | }
1676 | case "args":
1677 | out.Values[i] = ec.___Directive_args(ctx, field, obj)
1678 | if out.Values[i] == graphql.Null {
1679 | invalids++
1680 | }
1681 | default:
1682 | panic("unknown field " + strconv.Quote(field.Name))
1683 | }
1684 | }
1685 | out.Dispatch()
1686 | if invalids > 0 {
1687 | return graphql.Null
1688 | }
1689 | return out
1690 | }
1691 |
1692 | var __EnumValueImplementors = []string{"__EnumValue"}
1693 |
1694 | func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
1695 | fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
1696 |
1697 | out := graphql.NewFieldSet(fields)
1698 | var invalids uint32
1699 | for i, field := range fields {
1700 | switch field.Name {
1701 | case "__typename":
1702 | out.Values[i] = graphql.MarshalString("__EnumValue")
1703 | case "name":
1704 | out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
1705 | if out.Values[i] == graphql.Null {
1706 | invalids++
1707 | }
1708 | case "description":
1709 | out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
1710 | case "isDeprecated":
1711 | out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
1712 | if out.Values[i] == graphql.Null {
1713 | invalids++
1714 | }
1715 | case "deprecationReason":
1716 | out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
1717 | default:
1718 | panic("unknown field " + strconv.Quote(field.Name))
1719 | }
1720 | }
1721 | out.Dispatch()
1722 | if invalids > 0 {
1723 | return graphql.Null
1724 | }
1725 | return out
1726 | }
1727 |
1728 | var __FieldImplementors = []string{"__Field"}
1729 |
1730 | func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
1731 | fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
1732 |
1733 | out := graphql.NewFieldSet(fields)
1734 | var invalids uint32
1735 | for i, field := range fields {
1736 | switch field.Name {
1737 | case "__typename":
1738 | out.Values[i] = graphql.MarshalString("__Field")
1739 | case "name":
1740 | out.Values[i] = ec.___Field_name(ctx, field, obj)
1741 | if out.Values[i] == graphql.Null {
1742 | invalids++
1743 | }
1744 | case "description":
1745 | out.Values[i] = ec.___Field_description(ctx, field, obj)
1746 | case "args":
1747 | out.Values[i] = ec.___Field_args(ctx, field, obj)
1748 | if out.Values[i] == graphql.Null {
1749 | invalids++
1750 | }
1751 | case "type":
1752 | out.Values[i] = ec.___Field_type(ctx, field, obj)
1753 | if out.Values[i] == graphql.Null {
1754 | invalids++
1755 | }
1756 | case "isDeprecated":
1757 | out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
1758 | if out.Values[i] == graphql.Null {
1759 | invalids++
1760 | }
1761 | case "deprecationReason":
1762 | out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
1763 | default:
1764 | panic("unknown field " + strconv.Quote(field.Name))
1765 | }
1766 | }
1767 | out.Dispatch()
1768 | if invalids > 0 {
1769 | return graphql.Null
1770 | }
1771 | return out
1772 | }
1773 |
1774 | var __InputValueImplementors = []string{"__InputValue"}
1775 |
1776 | func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
1777 | fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
1778 |
1779 | out := graphql.NewFieldSet(fields)
1780 | var invalids uint32
1781 | for i, field := range fields {
1782 | switch field.Name {
1783 | case "__typename":
1784 | out.Values[i] = graphql.MarshalString("__InputValue")
1785 | case "name":
1786 | out.Values[i] = ec.___InputValue_name(ctx, field, obj)
1787 | if out.Values[i] == graphql.Null {
1788 | invalids++
1789 | }
1790 | case "description":
1791 | out.Values[i] = ec.___InputValue_description(ctx, field, obj)
1792 | case "type":
1793 | out.Values[i] = ec.___InputValue_type(ctx, field, obj)
1794 | if out.Values[i] == graphql.Null {
1795 | invalids++
1796 | }
1797 | case "defaultValue":
1798 | out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
1799 | default:
1800 | panic("unknown field " + strconv.Quote(field.Name))
1801 | }
1802 | }
1803 | out.Dispatch()
1804 | if invalids > 0 {
1805 | return graphql.Null
1806 | }
1807 | return out
1808 | }
1809 |
1810 | var __SchemaImplementors = []string{"__Schema"}
1811 |
1812 | func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
1813 | fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
1814 |
1815 | out := graphql.NewFieldSet(fields)
1816 | var invalids uint32
1817 | for i, field := range fields {
1818 | switch field.Name {
1819 | case "__typename":
1820 | out.Values[i] = graphql.MarshalString("__Schema")
1821 | case "types":
1822 | out.Values[i] = ec.___Schema_types(ctx, field, obj)
1823 | if out.Values[i] == graphql.Null {
1824 | invalids++
1825 | }
1826 | case "queryType":
1827 | out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
1828 | if out.Values[i] == graphql.Null {
1829 | invalids++
1830 | }
1831 | case "mutationType":
1832 | out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
1833 | case "subscriptionType":
1834 | out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
1835 | case "directives":
1836 | out.Values[i] = ec.___Schema_directives(ctx, field, obj)
1837 | if out.Values[i] == graphql.Null {
1838 | invalids++
1839 | }
1840 | default:
1841 | panic("unknown field " + strconv.Quote(field.Name))
1842 | }
1843 | }
1844 | out.Dispatch()
1845 | if invalids > 0 {
1846 | return graphql.Null
1847 | }
1848 | return out
1849 | }
1850 |
1851 | var __TypeImplementors = []string{"__Type"}
1852 |
1853 | func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
1854 | fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
1855 |
1856 | out := graphql.NewFieldSet(fields)
1857 | var invalids uint32
1858 | for i, field := range fields {
1859 | switch field.Name {
1860 | case "__typename":
1861 | out.Values[i] = graphql.MarshalString("__Type")
1862 | case "kind":
1863 | out.Values[i] = ec.___Type_kind(ctx, field, obj)
1864 | if out.Values[i] == graphql.Null {
1865 | invalids++
1866 | }
1867 | case "name":
1868 | out.Values[i] = ec.___Type_name(ctx, field, obj)
1869 | case "description":
1870 | out.Values[i] = ec.___Type_description(ctx, field, obj)
1871 | case "fields":
1872 | out.Values[i] = ec.___Type_fields(ctx, field, obj)
1873 | case "interfaces":
1874 | out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
1875 | case "possibleTypes":
1876 | out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
1877 | case "enumValues":
1878 | out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
1879 | case "inputFields":
1880 | out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
1881 | case "ofType":
1882 | out.Values[i] = ec.___Type_ofType(ctx, field, obj)
1883 | default:
1884 | panic("unknown field " + strconv.Quote(field.Name))
1885 | }
1886 | }
1887 | out.Dispatch()
1888 | if invalids > 0 {
1889 | return graphql.Null
1890 | }
1891 | return out
1892 | }
1893 |
1894 | // endregion **************************** object.gotpl ****************************
1895 |
1896 | // region ***************************** type.gotpl *****************************
1897 |
1898 | func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
1899 | return graphql.UnmarshalBoolean(v)
1900 | }
1901 |
1902 | func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
1903 | res := graphql.MarshalBoolean(v)
1904 | if res == graphql.Null {
1905 | if !ec.HasError(graphql.GetResolverContext(ctx)) {
1906 | ec.Errorf(ctx, "must not be null")
1907 | }
1908 | }
1909 | return res
1910 | }
1911 |
1912 | func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
1913 | return graphql.UnmarshalString(v)
1914 | }
1915 |
1916 | func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
1917 | res := graphql.MarshalString(v)
1918 | if res == graphql.Null {
1919 | if !ec.HasError(graphql.GetResolverContext(ctx)) {
1920 | ec.Errorf(ctx, "must not be null")
1921 | }
1922 | }
1923 | return res
1924 | }
1925 |
1926 | func (ec *executionContext) unmarshalNUpload2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx context.Context, v interface{}) (graphql.Upload, error) {
1927 | return graphql.UnmarshalUpload(v)
1928 | }
1929 |
1930 | func (ec *executionContext) marshalNUpload2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx context.Context, sel ast.SelectionSet, v graphql.Upload) graphql.Marshaler {
1931 | res := graphql.MarshalUpload(v)
1932 | if res == graphql.Null {
1933 | if !ec.HasError(graphql.GetResolverContext(ctx)) {
1934 | ec.Errorf(ctx, "must not be null")
1935 | }
1936 | }
1937 | return res
1938 | }
1939 |
1940 | func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
1941 | return ec.___Directive(ctx, sel, &v)
1942 | }
1943 |
1944 | func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
1945 | ret := make(graphql.Array, len(v))
1946 | var wg sync.WaitGroup
1947 | isLen1 := len(v) == 1
1948 | if !isLen1 {
1949 | wg.Add(len(v))
1950 | }
1951 | for i := range v {
1952 | i := i
1953 | rctx := &graphql.ResolverContext{
1954 | Index: &i,
1955 | Result: &v[i],
1956 | }
1957 | ctx := graphql.WithResolverContext(ctx, rctx)
1958 | f := func(i int) {
1959 | defer func() {
1960 | if r := recover(); r != nil {
1961 | ec.Error(ctx, ec.Recover(ctx, r))
1962 | ret = nil
1963 | }
1964 | }()
1965 | if !isLen1 {
1966 | defer wg.Done()
1967 | }
1968 | ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
1969 | }
1970 | if isLen1 {
1971 | f(i)
1972 | } else {
1973 | go f(i)
1974 | }
1975 |
1976 | }
1977 | wg.Wait()
1978 | return ret
1979 | }
1980 |
1981 | func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
1982 | return graphql.UnmarshalString(v)
1983 | }
1984 |
1985 | func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
1986 | res := graphql.MarshalString(v)
1987 | if res == graphql.Null {
1988 | if !ec.HasError(graphql.GetResolverContext(ctx)) {
1989 | ec.Errorf(ctx, "must not be null")
1990 | }
1991 | }
1992 | return res
1993 | }
1994 |
1995 | func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
1996 | var vSlice []interface{}
1997 | if v != nil {
1998 | if tmp1, ok := v.([]interface{}); ok {
1999 | vSlice = tmp1
2000 | } else {
2001 | vSlice = []interface{}{v}
2002 | }
2003 | }
2004 | var err error
2005 | res := make([]string, len(vSlice))
2006 | for i := range vSlice {
2007 | res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
2008 | if err != nil {
2009 | return nil, err
2010 | }
2011 | }
2012 | return res, nil
2013 | }
2014 |
2015 | func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2016 | ret := make(graphql.Array, len(v))
2017 | var wg sync.WaitGroup
2018 | isLen1 := len(v) == 1
2019 | if !isLen1 {
2020 | wg.Add(len(v))
2021 | }
2022 | for i := range v {
2023 | i := i
2024 | rctx := &graphql.ResolverContext{
2025 | Index: &i,
2026 | Result: &v[i],
2027 | }
2028 | ctx := graphql.WithResolverContext(ctx, rctx)
2029 | f := func(i int) {
2030 | defer func() {
2031 | if r := recover(); r != nil {
2032 | ec.Error(ctx, ec.Recover(ctx, r))
2033 | ret = nil
2034 | }
2035 | }()
2036 | if !isLen1 {
2037 | defer wg.Done()
2038 | }
2039 | ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
2040 | }
2041 | if isLen1 {
2042 | f(i)
2043 | } else {
2044 | go f(i)
2045 | }
2046 |
2047 | }
2048 | wg.Wait()
2049 | return ret
2050 | }
2051 |
2052 | func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
2053 | return ec.___EnumValue(ctx, sel, &v)
2054 | }
2055 |
2056 | func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
2057 | return ec.___Field(ctx, sel, &v)
2058 | }
2059 |
2060 | func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
2061 | return ec.___InputValue(ctx, sel, &v)
2062 | }
2063 |
2064 | func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2065 | ret := make(graphql.Array, len(v))
2066 | var wg sync.WaitGroup
2067 | isLen1 := len(v) == 1
2068 | if !isLen1 {
2069 | wg.Add(len(v))
2070 | }
2071 | for i := range v {
2072 | i := i
2073 | rctx := &graphql.ResolverContext{
2074 | Index: &i,
2075 | Result: &v[i],
2076 | }
2077 | ctx := graphql.WithResolverContext(ctx, rctx)
2078 | f := func(i int) {
2079 | defer func() {
2080 | if r := recover(); r != nil {
2081 | ec.Error(ctx, ec.Recover(ctx, r))
2082 | ret = nil
2083 | }
2084 | }()
2085 | if !isLen1 {
2086 | defer wg.Done()
2087 | }
2088 | ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2089 | }
2090 | if isLen1 {
2091 | f(i)
2092 | } else {
2093 | go f(i)
2094 | }
2095 |
2096 | }
2097 | wg.Wait()
2098 | return ret
2099 | }
2100 |
2101 | func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
2102 | return ec.___Type(ctx, sel, &v)
2103 | }
2104 |
2105 | func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2106 | ret := make(graphql.Array, len(v))
2107 | var wg sync.WaitGroup
2108 | isLen1 := len(v) == 1
2109 | if !isLen1 {
2110 | wg.Add(len(v))
2111 | }
2112 | for i := range v {
2113 | i := i
2114 | rctx := &graphql.ResolverContext{
2115 | Index: &i,
2116 | Result: &v[i],
2117 | }
2118 | ctx := graphql.WithResolverContext(ctx, rctx)
2119 | f := func(i int) {
2120 | defer func() {
2121 | if r := recover(); r != nil {
2122 | ec.Error(ctx, ec.Recover(ctx, r))
2123 | ret = nil
2124 | }
2125 | }()
2126 | if !isLen1 {
2127 | defer wg.Done()
2128 | }
2129 | ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2130 | }
2131 | if isLen1 {
2132 | f(i)
2133 | } else {
2134 | go f(i)
2135 | }
2136 |
2137 | }
2138 | wg.Wait()
2139 | return ret
2140 | }
2141 |
2142 | func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2143 | if v == nil {
2144 | if !ec.HasError(graphql.GetResolverContext(ctx)) {
2145 | ec.Errorf(ctx, "must not be null")
2146 | }
2147 | return graphql.Null
2148 | }
2149 | return ec.___Type(ctx, sel, v)
2150 | }
2151 |
2152 | func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
2153 | return graphql.UnmarshalString(v)
2154 | }
2155 |
2156 | func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2157 | res := graphql.MarshalString(v)
2158 | if res == graphql.Null {
2159 | if !ec.HasError(graphql.GetResolverContext(ctx)) {
2160 | ec.Errorf(ctx, "must not be null")
2161 | }
2162 | }
2163 | return res
2164 | }
2165 |
2166 | func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
2167 | return graphql.UnmarshalBoolean(v)
2168 | }
2169 |
2170 | func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
2171 | return graphql.MarshalBoolean(v)
2172 | }
2173 |
2174 | func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
2175 | if v == nil {
2176 | return nil, nil
2177 | }
2178 | res, err := ec.unmarshalOBoolean2bool(ctx, v)
2179 | return &res, err
2180 | }
2181 |
2182 | func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
2183 | if v == nil {
2184 | return graphql.Null
2185 | }
2186 | return ec.marshalOBoolean2bool(ctx, sel, *v)
2187 | }
2188 |
2189 | func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
2190 | return graphql.UnmarshalString(v)
2191 | }
2192 |
2193 | func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2194 | return graphql.MarshalString(v)
2195 | }
2196 |
2197 | func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
2198 | if v == nil {
2199 | return nil, nil
2200 | }
2201 | res, err := ec.unmarshalOString2string(ctx, v)
2202 | return &res, err
2203 | }
2204 |
2205 | func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
2206 | if v == nil {
2207 | return graphql.Null
2208 | }
2209 | return ec.marshalOString2string(ctx, sel, *v)
2210 | }
2211 |
2212 | func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
2213 | if v == nil {
2214 | return graphql.Null
2215 | }
2216 | ret := make(graphql.Array, len(v))
2217 | var wg sync.WaitGroup
2218 | isLen1 := len(v) == 1
2219 | if !isLen1 {
2220 | wg.Add(len(v))
2221 | }
2222 | for i := range v {
2223 | i := i
2224 | rctx := &graphql.ResolverContext{
2225 | Index: &i,
2226 | Result: &v[i],
2227 | }
2228 | ctx := graphql.WithResolverContext(ctx, rctx)
2229 | f := func(i int) {
2230 | defer func() {
2231 | if r := recover(); r != nil {
2232 | ec.Error(ctx, ec.Recover(ctx, r))
2233 | ret = nil
2234 | }
2235 | }()
2236 | if !isLen1 {
2237 | defer wg.Done()
2238 | }
2239 | ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
2240 | }
2241 | if isLen1 {
2242 | f(i)
2243 | } else {
2244 | go f(i)
2245 | }
2246 |
2247 | }
2248 | wg.Wait()
2249 | return ret
2250 | }
2251 |
2252 | func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
2253 | if v == nil {
2254 | return graphql.Null
2255 | }
2256 | ret := make(graphql.Array, len(v))
2257 | var wg sync.WaitGroup
2258 | isLen1 := len(v) == 1
2259 | if !isLen1 {
2260 | wg.Add(len(v))
2261 | }
2262 | for i := range v {
2263 | i := i
2264 | rctx := &graphql.ResolverContext{
2265 | Index: &i,
2266 | Result: &v[i],
2267 | }
2268 | ctx := graphql.WithResolverContext(ctx, rctx)
2269 | f := func(i int) {
2270 | defer func() {
2271 | if r := recover(); r != nil {
2272 | ec.Error(ctx, ec.Recover(ctx, r))
2273 | ret = nil
2274 | }
2275 | }()
2276 | if !isLen1 {
2277 | defer wg.Done()
2278 | }
2279 | ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
2280 | }
2281 | if isLen1 {
2282 | f(i)
2283 | } else {
2284 | go f(i)
2285 | }
2286 |
2287 | }
2288 | wg.Wait()
2289 | return ret
2290 | }
2291 |
2292 | func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2293 | if v == nil {
2294 | return graphql.Null
2295 | }
2296 | ret := make(graphql.Array, len(v))
2297 | var wg sync.WaitGroup
2298 | isLen1 := len(v) == 1
2299 | if !isLen1 {
2300 | wg.Add(len(v))
2301 | }
2302 | for i := range v {
2303 | i := i
2304 | rctx := &graphql.ResolverContext{
2305 | Index: &i,
2306 | Result: &v[i],
2307 | }
2308 | ctx := graphql.WithResolverContext(ctx, rctx)
2309 | f := func(i int) {
2310 | defer func() {
2311 | if r := recover(); r != nil {
2312 | ec.Error(ctx, ec.Recover(ctx, r))
2313 | ret = nil
2314 | }
2315 | }()
2316 | if !isLen1 {
2317 | defer wg.Done()
2318 | }
2319 | ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2320 | }
2321 | if isLen1 {
2322 | f(i)
2323 | } else {
2324 | go f(i)
2325 | }
2326 |
2327 | }
2328 | wg.Wait()
2329 | return ret
2330 | }
2331 |
2332 | func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
2333 | return ec.___Schema(ctx, sel, &v)
2334 | }
2335 |
2336 | func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
2337 | if v == nil {
2338 | return graphql.Null
2339 | }
2340 | return ec.___Schema(ctx, sel, v)
2341 | }
2342 |
2343 | func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
2344 | return ec.___Type(ctx, sel, &v)
2345 | }
2346 |
2347 | func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2348 | if v == nil {
2349 | return graphql.Null
2350 | }
2351 | ret := make(graphql.Array, len(v))
2352 | var wg sync.WaitGroup
2353 | isLen1 := len(v) == 1
2354 | if !isLen1 {
2355 | wg.Add(len(v))
2356 | }
2357 | for i := range v {
2358 | i := i
2359 | rctx := &graphql.ResolverContext{
2360 | Index: &i,
2361 | Result: &v[i],
2362 | }
2363 | ctx := graphql.WithResolverContext(ctx, rctx)
2364 | f := func(i int) {
2365 | defer func() {
2366 | if r := recover(); r != nil {
2367 | ec.Error(ctx, ec.Recover(ctx, r))
2368 | ret = nil
2369 | }
2370 | }()
2371 | if !isLen1 {
2372 | defer wg.Done()
2373 | }
2374 | ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2375 | }
2376 | if isLen1 {
2377 | f(i)
2378 | } else {
2379 | go f(i)
2380 | }
2381 |
2382 | }
2383 | wg.Wait()
2384 | return ret
2385 | }
2386 |
2387 | func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2388 | if v == nil {
2389 | return graphql.Null
2390 | }
2391 | return ec.___Type(ctx, sel, v)
2392 | }
2393 |
2394 | // endregion ***************************** type.gotpl *****************************
2395 |
--------------------------------------------------------------------------------
/backend/gqlgen.yml:
--------------------------------------------------------------------------------
1 | # .gqlgen.yml example
2 | #
3 | # Refer to https://gqlgen.com/config/
4 | # for detailed .gqlgen.yml documentation.
5 |
6 | schema:
7 | - schema.graphql
8 | exec:
9 | filename: generated.go
10 | model:
11 | filename: models_gen.go
12 | resolver:
13 | filename: resolver.go
14 | type: Resolver
15 | autobind: []
16 |
17 |
--------------------------------------------------------------------------------
/backend/resolver.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "io/ioutil"
7 | "log"
8 | "math/rand"
9 | "os"
10 | "path/filepath"
11 | "time"
12 |
13 | "github.com/99designs/gqlgen/graphql"
14 | ) // THIS CODE IS A STARTING POINT ONLY. IT WILL NOT BE UPDATED WITH SCHEMA CHANGES.
15 |
16 | type Resolver struct{}
17 |
18 | func (r *Resolver) Mutation() MutationResolver {
19 | return &mutationResolver{r}
20 | }
21 | func (r *Resolver) Query() QueryResolver {
22 | return &queryResolver{r}
23 | }
24 |
25 | type mutationResolver struct{ *Resolver }
26 |
27 | func (r *mutationResolver) Upload(ctx context.Context, input graphql.Upload) (string, error) {
28 |
29 | ext := filepath.Ext(input.Filename)
30 | filename := fmt.Sprintf("%s%s", randString(10), ext)
31 |
32 | f, err := os.Create(fmt.Sprintf("temp/%s", filename))
33 |
34 | if err != nil {
35 | log.Printf("Error: %v", err)
36 | return "", err
37 | }
38 |
39 | content, err := ioutil.ReadAll(input.File)
40 |
41 | if err != nil {
42 | log.Printf("Error: %v", err)
43 | return "", err
44 | }
45 |
46 | _, err = f.Write(content)
47 |
48 | if err != nil {
49 | log.Printf("Error: %v", err)
50 | return "", err
51 | }
52 |
53 | time.Sleep(2 * time.Second)
54 |
55 | return fmt.Sprintf("http://localhost:8080/temp/%s", filename), nil
56 | }
57 |
58 | type queryResolver struct{ *Resolver }
59 |
60 | func (r *queryResolver) Hello(ctx context.Context, name string) (string, error) {
61 | return fmt.Sprintf("Hello, %s", name), nil
62 | }
63 |
64 | var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
65 |
66 | func randString(n int) string {
67 | b := make([]rune, n)
68 | for i := range b {
69 | b[i] = letterRunes[rand.Intn(len(letterRunes))]
70 | }
71 | return string(b)
72 | }
73 |
--------------------------------------------------------------------------------
/backend/schema.graphql:
--------------------------------------------------------------------------------
1 | scalar Upload
2 |
3 | type Query {
4 | hello(name: String!): String!
5 | }
6 |
7 | type Mutation {
8 | upload(file: Upload!): String!
9 | }
10 |
--------------------------------------------------------------------------------
/backend/server/server.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | "os"
7 |
8 | "github.com/99designs/gqlgen/handler"
9 | "github.com/mainawycliffe/golang-gqlgen-graphql-upload-example/backend"
10 | )
11 |
12 | const defaultPort = "8080"
13 |
14 | func main() {
15 | port := os.Getenv("PORT")
16 | if port == "" {
17 | port = defaultPort
18 | }
19 |
20 | http.Handle("/temp/", http.StripPrefix("/temp/", http.FileServer(http.Dir("temp"))))
21 | http.Handle("/", handler.Playground("GraphQL playground", "/query"))
22 | http.Handle("/query", handler.GraphQL(backend.NewExecutableSchema(backend.Config{Resolvers: &backend.Resolver{}})))
23 |
24 | log.Printf("connect to http://localhost:%s/ for GraphQL playground", port)
25 | log.Fatal(http.ListenAndServe(":"+port, nil))
26 | }
27 |
--------------------------------------------------------------------------------
/backend/server/temp/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mainawycliffe/flutter-graphql-upload-example/687b45e889eafbed8b7a658769c5741f97f6b02c/backend/server/temp/.gitkeep
--------------------------------------------------------------------------------
/demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mainawycliffe/flutter-graphql-upload-example/687b45e889eafbed8b7a658769c5741f97f6b02c/demo.gif
--------------------------------------------------------------------------------
/docker-compose.debug.yml:
--------------------------------------------------------------------------------
1 | version: '2.1'
2 |
3 | services:
4 | golang-gqlgen-graphql-upload-example:
5 | image: golang-gqlgen-graphql-upload-example
6 | build:
7 | context: .
8 | dockerfile: Dockerfile
9 | ports:
10 | - 8080:8080
11 |
--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '2.1'
2 |
3 | services:
4 | golang-gqlgen-graphql-upload-example:
5 | image: golang-gqlgen-graphql-upload-example
6 | build: .
7 | ports:
8 | - 8080:8080
--------------------------------------------------------------------------------
/flutter/.gitignore:
--------------------------------------------------------------------------------
1 | # Miscellaneous
2 | *.class
3 | *.log
4 | *.pyc
5 | *.swp
6 | .DS_Store
7 | .atom/
8 | .buildlog/
9 | .history
10 | .svn/
11 |
12 | # IntelliJ related
13 | *.iml
14 | *.ipr
15 | *.iws
16 | .idea/
17 |
18 | # The .vscode folder contains launch configuration and tasks you configure in
19 | # VS Code which you may wish to be included in version control, so this line
20 | # is commented out by default.
21 | #.vscode/
22 |
23 | # Flutter/Dart/Pub related
24 | **/doc/api/
25 | .dart_tool/
26 | .flutter-plugins
27 | .packages
28 | .pub-cache/
29 | .pub/
30 | /build/
31 |
32 | # Android related
33 | **/android/**/gradle-wrapper.jar
34 | **/android/.gradle
35 | **/android/captures/
36 | **/android/gradlew
37 | **/android/gradlew.bat
38 | **/android/local.properties
39 | **/android/**/GeneratedPluginRegistrant.java
40 |
41 | # iOS/XCode related
42 | **/ios/**/*.mode1v3
43 | **/ios/**/*.mode2v3
44 | **/ios/**/*.moved-aside
45 | **/ios/**/*.pbxuser
46 | **/ios/**/*.perspectivev3
47 | **/ios/**/*sync/
48 | **/ios/**/.sconsign.dblite
49 | **/ios/**/.tags*
50 | **/ios/**/.vagrant/
51 | **/ios/**/DerivedData/
52 | **/ios/**/Icon?
53 | **/ios/**/Pods/
54 | **/ios/**/.symlinks/
55 | **/ios/**/profile
56 | **/ios/**/xcuserdata
57 | **/ios/.generated/
58 | **/ios/Flutter/App.framework
59 | **/ios/Flutter/Flutter.framework
60 | **/ios/Flutter/Generated.xcconfig
61 | **/ios/Flutter/app.flx
62 | **/ios/Flutter/app.zip
63 | **/ios/Flutter/flutter_assets/
64 | **/ios/ServiceDefinitions.json
65 | **/ios/Runner/GeneratedPluginRegistrant.*
66 |
67 | # Exceptions to above rules.
68 | !**/ios/**/default.mode1v3
69 | !**/ios/**/default.mode2v3
70 | !**/ios/**/default.pbxuser
71 | !**/ios/**/default.perspectivev3
72 | !/packages/flutter_tools/test/data/dart_dependencies_test/**/.packages
73 |
--------------------------------------------------------------------------------
/flutter/.metadata:
--------------------------------------------------------------------------------
1 | # This file tracks properties of this Flutter project.
2 | # Used by Flutter tool to assess capabilities and perform upgrades etc.
3 | #
4 | # This file should be version controlled and should not be manually edited.
5 |
6 | version:
7 | revision: 20e59316b8b8474554b38493b8ca888794b0234a
8 | channel: stable
9 |
10 | project_type: app
11 |
--------------------------------------------------------------------------------
/flutter/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "workbench.colorCustomizations": {}
3 | }
--------------------------------------------------------------------------------
/flutter/README.md:
--------------------------------------------------------------------------------
1 | # flutter_graphql_upload
2 |
3 | A new Flutter project.
4 |
5 | ## Getting Started
6 |
7 | This project is a starting point for a Flutter application.
8 |
9 | A few resources to get you started if this is your first Flutter project:
10 |
11 | - [Lab: Write your first Flutter app](https://flutter.dev/docs/get-started/codelab)
12 | - [Cookbook: Useful Flutter samples](https://flutter.dev/docs/cookbook)
13 |
14 | For help getting started with Flutter, view our
15 | [online documentation](https://flutter.dev/docs), which offers tutorials,
16 | samples, guidance on mobile development, and a full API reference.
17 |
--------------------------------------------------------------------------------
/flutter/android/app/build.gradle:
--------------------------------------------------------------------------------
1 | def localProperties = new Properties()
2 | def localPropertiesFile = rootProject.file('local.properties')
3 | if (localPropertiesFile.exists()) {
4 | localPropertiesFile.withReader('UTF-8') { reader ->
5 | localProperties.load(reader)
6 | }
7 | }
8 |
9 | def flutterRoot = localProperties.getProperty('flutter.sdk')
10 | if (flutterRoot == null) {
11 | throw new GradleException("Flutter SDK not found. Define location with flutter.sdk in the local.properties file.")
12 | }
13 |
14 | def flutterVersionCode = localProperties.getProperty('flutter.versionCode')
15 | if (flutterVersionCode == null) {
16 | flutterVersionCode = '1'
17 | }
18 |
19 | def flutterVersionName = localProperties.getProperty('flutter.versionName')
20 | if (flutterVersionName == null) {
21 | flutterVersionName = '1.0'
22 | }
23 |
24 | apply plugin: 'com.android.application'
25 | apply from: "$flutterRoot/packages/flutter_tools/gradle/flutter.gradle"
26 |
27 | android {
28 | compileSdkVersion 28
29 |
30 | lintOptions {
31 | disable 'InvalidPackage'
32 | }
33 |
34 | defaultConfig {
35 | // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
36 | applicationId "com.example.flutter_graphql_upload"
37 | minSdkVersion 19
38 | targetSdkVersion 28
39 | versionCode flutterVersionCode.toInteger()
40 | versionName flutterVersionName
41 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
42 | }
43 |
44 | buildTypes {
45 | release {
46 | // TODO: Add your own signing config for the release build.
47 | // Signing with the debug keys for now, so `flutter run --release` works.
48 | signingConfig signingConfigs.debug
49 | }
50 | }
51 | }
52 |
53 | flutter {
54 | source '../..'
55 | }
56 |
57 | dependencies {
58 | testImplementation 'junit:junit:4.12'
59 | androidTestImplementation 'com.android.support.test:runner:1.0.2'
60 | androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
61 | }
62 |
--------------------------------------------------------------------------------
/flutter/android/app/src/debug/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
3 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/flutter/android/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
3 |
4 |
9 |
13 |
20 |
24 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/flutter/android/app/src/main/java/com/example/flutter_graphql_upload/MainActivity.java:
--------------------------------------------------------------------------------
1 | package com.example.flutter_graphql_upload;
2 |
3 | import android.os.Bundle;
4 | import io.flutter.app.FlutterActivity;
5 | import io.flutter.plugins.GeneratedPluginRegistrant;
6 |
7 | public class MainActivity extends FlutterActivity {
8 | @Override
9 | protected void onCreate(Bundle savedInstanceState) {
10 | super.onCreate(savedInstanceState);
11 | GeneratedPluginRegistrant.registerWith(this);
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/flutter/android/app/src/main/res/drawable/launch_background.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |