1{{- range $object := .Objects }}{{- range $field := $object.Fields }}
2
3func (ec *executionContext) _{{$object.Name}}_{{$field.Name}}(ctx context.Context, field graphql.CollectedField{{ if not $object.Root }}, obj {{$object.Reference | ref}}{{end}}) (ret {{ if $object.Stream }}func(ctx context.Context){{ end }}graphql.Marshaler) {
4 {{- $null := "graphql.Null" }}
5 {{- if $object.Stream }}
6 {{- $null = "nil" }}
7 {{- end }}
8 fc, err := ec.{{ $field.FieldContextFunc }}(ctx, field)
9 if err != nil {
10 return {{ $null }}
11 }
12 ctx = graphql.WithFieldContext(ctx, fc)
13 defer func () {
14 if r := recover(); r != nil {
15 ec.Error(ctx, ec.Recover(ctx, r))
16 ret = {{ $null }}
17 }
18 }()
19 {{- if $field.TypeReference.IsRoot }}
20 {{- if $field.TypeReference.IsPtr }}
21 res := &{{ $field.TypeReference.Elem.GO | ref }}{}
22 {{- else }}
23 res := {{ $field.TypeReference.GO | ref }}{}
24 {{- end }}
25 fc.Result = res
26 return ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res)
27 {{- else}}
28 {{- if $.AllDirectives.LocationDirectives "FIELD" }}
29 resTmp := ec._fieldMiddleware(ctx, {{if $object.Root}}nil{{else}}obj{{end}}, func(rctx context.Context) (interface{}, error) {
30 {{ template "field" $field }}
31 })
32 {{ else }}
33 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
34 {{ template "field" $field }}
35 })
36 if err != nil {
37 ec.Error(ctx, err)
38 return {{ $null }}
39 }
40 {{- end }}
41 if resTmp == nil {
42 {{- if $field.TypeReference.GQL.NonNull }}
43 if !graphql.HasFieldError(ctx, fc) {
44 ec.Errorf(ctx, "must not be null")
45 }
46 {{- end }}
47 return {{ $null }}
48 }
49 {{- if $object.Stream }}
50 return func(ctx context.Context) graphql.Marshaler {
51 select {
52 case res, ok := <-resTmp.(<-chan {{$field.TypeReference.GO | ref}}):
53 if !ok {
54 return nil
55 }
56 return graphql.WriterFunc(func(w io.Writer) {
57 w.Write([]byte{'{'})
58 graphql.MarshalString(field.Alias).MarshalGQL(w)
59 w.Write([]byte{':'})
60 ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res).MarshalGQL(w)
61 w.Write([]byte{'}'})
62 })
63 case <-ctx.Done():
64 return nil
65 }
66 }
67 {{- else }}
68 res := resTmp.({{$field.TypeReference.GO | ref}})
69 fc.Result = res
70 return ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res)
71 {{- end }}
72 {{- end }}
73}
74
75func (ec *executionContext) {{ $field.FieldContextFunc }}(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
76 fc = &graphql.FieldContext{
77 Object: {{quote $field.Object.Name}},
78 Field: field,
79 IsMethod: {{or $field.IsMethod $field.IsResolver}},
80 IsResolver: {{ $field.IsResolver }},
81 Child: func (ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
82 {{- if not $field.TypeReference.Definition.Fields }}
83 return nil, errors.New("field of type {{ $field.TypeReference.Definition.Name }} does not have child fields")
84 {{- else if ne $field.TypeReference.Definition.Kind "OBJECT" }}
85 return nil, errors.New("FieldContext.Child cannot be called on type {{ $field.TypeReference.Definition.Kind }}")
86 {{- else }}
87 switch field.Name {
88 {{- range $f := $field.TypeReference.Definition.Fields }}
89 case "{{ $f.Name }}":
90 return ec.{{ $field.ChildFieldContextFunc $f.Name }}(ctx, field)
91 {{- end }}
92 }
93 return nil, fmt.Errorf("no field named %q was found under type {{ $field.TypeReference.Definition.Name }}", field.Name)
94 {{- end }}
95 },
96 }
97 {{- if $field.Args }}
98 defer func () {
99 if r := recover(); r != nil {
100 err = ec.Recover(ctx, r)
101 ec.Error(ctx, err)
102 }
103 }()
104 ctx = graphql.WithFieldContext(ctx, fc)
105 if fc.Args, err = ec.{{ $field.ArgsFunc }}(ctx, field.ArgumentMap(ec.Variables)); err != nil {
106 ec.Error(ctx, err)
107 return fc, err
108 }
109 {{- end }}
110 return fc, nil
111}
112
113{{- end }}{{- end}}
114
115{{ define "field" }}
116 {{- if .HasDirectives -}}
117 directive0 := func(rctx context.Context) (interface{}, error) {
118 ctx = rctx // use context from middleware stack in children
119 {{ template "fieldDefinition" . }}
120 }
121 {{ template "implDirectives" . }}
122 tmp, err := directive{{.ImplDirectives|len}}(rctx)
123 if err != nil {
124 return nil, graphql.ErrorOnPath(ctx, err)
125 }
126 if tmp == nil {
127 return nil, nil
128 }
129 if data, ok := tmp.({{if .Stream}}<-chan {{end}}{{ .TypeReference.GO | ref }}) ; ok {
130 return data, nil
131 }
132 return nil, fmt.Errorf(`unexpected type %T from directive, should be {{if .Stream}}<-chan {{end}}{{ .TypeReference.GO }}`, tmp)
133 {{- else -}}
134 ctx = rctx // use context from middleware stack in children
135 {{ template "fieldDefinition" . }}
136 {{- end -}}
137{{ end }}
138
139{{ define "fieldDefinition" }}
140 {{- if .IsResolver -}}
141 return ec.resolvers.{{ .ShortInvocation }}
142 {{- else if .IsMap -}}
143 switch v := {{.GoReceiverName}}[{{.Name|quote}}].(type) {
144 case {{if .Stream}}<-chan {{end}}{{.TypeReference.GO | ref}}:
145 return v, nil
146 case {{if .Stream}}<-chan {{end}}{{.TypeReference.Elem.GO | ref}}:
147 return &v, nil
148 case nil:
149 return ({{.TypeReference.GO | ref}})(nil), nil
150 default:
151 return nil, fmt.Errorf("unexpected type %T for field %s", v, {{ .Name | quote}})
152 }
153 {{- else if .IsMethod -}}
154 {{- if .VOkFunc -}}
155 v, ok := {{.GoReceiverName}}.{{.GoFieldName}}({{ .CallArgs }})
156 if !ok {
157 return nil, nil
158 }
159 return v, nil
160 {{- else if .NoErr -}}
161 return {{.GoReceiverName}}.{{.GoFieldName}}({{ .CallArgs }}), nil
162 {{- else -}}
163 return {{.GoReceiverName}}.{{.GoFieldName}}({{ .CallArgs }})
164 {{- end -}}
165 {{- else if .IsVariable -}}
166 return {{.GoReceiverName}}.{{.GoFieldName}}, nil
167 {{- end }}
168{{- end }}
View as plain text