1{{ reserveImport "context" }}
2{{ reserveImport "fmt" }}
3{{ reserveImport "io" }}
4{{ reserveImport "strconv" }}
5{{ reserveImport "time" }}
6{{ reserveImport "sync" }}
7{{ reserveImport "errors" }}
8{{ reserveImport "bytes" }}
9
10{{ reserveImport "github.com/vektah/gqlparser" }}
11{{ reserveImport "github.com/vektah/gqlparser/ast" }}
12{{ reserveImport "github.com/99designs/gqlgen/graphql" }}
13{{ reserveImport "github.com/99designs/gqlgen/graphql/introspection" }}
14
15
16// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
17func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
18 return &executableSchema{
19 resolvers: cfg.Resolvers,
20 directives: cfg.Directives,
21 complexity: cfg.Complexity,
22 }
23}
24
25type Config struct {
26 Resolvers ResolverRoot
27 Directives DirectiveRoot
28 Complexity ComplexityRoot
29}
30
31type ResolverRoot interface {
32{{- range $object := .Objects -}}
33 {{ if $object.HasResolvers -}}
34 {{$object.Name}}() {{$object.Name}}Resolver
35 {{ end }}
36{{- end }}
37}
38
39type DirectiveRoot struct {
40{{ range $directive := .Directives }}
41 {{ $directive.Declaration }}
42{{ end }}
43}
44
45type ComplexityRoot struct {
46{{ range $object := .Objects }}
47 {{ if not $object.IsReserved -}}
48 {{ $object.Name|go }} struct {
49 {{ range $field := $object.UniqueFields -}}
50 {{ if not $field.IsReserved -}}
51 {{ $field.GoFieldName }} {{ $field.ComplexitySignature }}
52 {{ end }}
53 {{- end }}
54 }
55 {{- end }}
56{{ end }}
57}
58
59{{ range $object := .Objects -}}
60 {{ if $object.HasResolvers }}
61 type {{$object.Name}}Resolver interface {
62 {{ range $field := $object.Fields -}}
63 {{- if $field.IsResolver }}
64 {{- $field.GoFieldName}}{{ $field.ShortResolverDeclaration }}
65 {{- end }}
66 {{ end }}
67 }
68 {{- end }}
69{{- end }}
70
71type executableSchema struct {
72 resolvers ResolverRoot
73 directives DirectiveRoot
74 complexity ComplexityRoot
75}
76
77func (e *executableSchema) Schema() *ast.Schema {
78 return parsedSchema
79}
80
81func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
82 ec := executionContext{nil, e}
83 _ = ec
84 switch typeName + "." + field {
85 {{ range $object := .Objects }}
86 {{ if not $object.IsReserved }}
87 {{ range $field := $object.UniqueFields }}
88 {{ if not $field.IsReserved }}
89 case "{{$object.Name}}.{{$field.GoFieldName}}":
90 if e.complexity.{{$object.Name|go}}.{{$field.GoFieldName}} == nil {
91 break
92 }
93 {{ if $field.Args }}
94 args, err := ec.{{ $field.ArgsFunc }}(context.TODO(),rawArgs)
95 if err != nil {
96 return 0, false
97 }
98 {{ end }}
99 return e.complexity.{{$object.Name|go}}.{{$field.GoFieldName}}(childComplexity{{if $field.Args}}, {{$field.ComplexityArgs}} {{end}}), true
100 {{ end }}
101 {{ end }}
102 {{ end }}
103 {{ end }}
104 }
105 return 0, false
106}
107
108func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
109 {{- if .QueryRoot }}
110 ec := executionContext{graphql.GetRequestContext(ctx), e}
111
112 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
113 data := ec._{{.QueryRoot.Name}}(ctx, op.SelectionSet)
114 var buf bytes.Buffer
115 data.MarshalGQL(&buf)
116 return buf.Bytes()
117 })
118
119 return &graphql.Response{
120 Data: buf,
121 Errors: ec.Errors,
122 Extensions: ec.Extensions,
123 }
124 {{- else }}
125 return graphql.ErrorResponse(ctx, "queries are not supported")
126 {{- end }}
127}
128
129func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
130 {{- if .MutationRoot }}
131 ec := executionContext{graphql.GetRequestContext(ctx), e}
132
133 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
134 data := ec._{{.MutationRoot.Name}}(ctx, op.SelectionSet)
135 var buf bytes.Buffer
136 data.MarshalGQL(&buf)
137 return buf.Bytes()
138 })
139
140 return &graphql.Response{
141 Data: buf,
142 Errors: ec.Errors,
143 Extensions: ec.Extensions,
144 }
145 {{- else }}
146 return graphql.ErrorResponse(ctx, "mutations are not supported")
147 {{- end }}
148}
149
150func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
151 {{- if .SubscriptionRoot }}
152 ec := executionContext{graphql.GetRequestContext(ctx), e}
153
154 next := ec._{{.SubscriptionRoot.Name}}(ctx, op.SelectionSet)
155 if ec.Errors != nil {
156 return graphql.OneShot(&graphql.Response{Data: []byte("null"), Errors: ec.Errors})
157 }
158
159 var buf bytes.Buffer
160 return func() *graphql.Response {
161 buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
162 buf.Reset()
163 data := next()
164
165 if data == nil {
166 return nil
167 }
168 data.MarshalGQL(&buf)
169 return buf.Bytes()
170 })
171
172 if buf == nil {
173 return nil
174 }
175
176 return &graphql.Response{
177 Data: buf,
178 Errors: ec.Errors,
179 Extensions: ec.Extensions,
180 }
181 }
182 {{- else }}
183 return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
184 {{- end }}
185}
186
187type executionContext struct {
188 *graphql.RequestContext
189 *executableSchema
190}
191
192func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
193 defer func() {
194 if r := recover(); r != nil {
195 ec.Error(ctx, ec.Recover(ctx, r))
196 ret = nil
197 }
198 }()
199 {{- if .Directives }}
200 rctx := graphql.GetResolverContext(ctx)
201 for _, d := range rctx.Field.Definition.Directives {
202 switch d.Name {
203 {{- range $directive := .Directives }}
204 case "{{$directive.Name}}":
205 if ec.directives.{{$directive.Name|ucFirst}} != nil {
206 {{- if $directive.Args }}
207 rawArgs := d.ArgumentMap(ec.Variables)
208 args, err := ec.{{ $directive.ArgsFunc }}(ctx,rawArgs)
209 if err != nil {
210 ec.Error(ctx, err)
211 return nil
212 }
213 {{- end }}
214 n := next
215 next = func(ctx context.Context) (interface{}, error) {
216 return ec.directives.{{$directive.Name|ucFirst}}({{$directive.CallArgs}})
217 }
218 }
219 {{- end }}
220 }
221 }
222 {{- end }}
223 res, err := ec.ResolverMiddleware(ctx, next)
224 if err != nil {
225 ec.Error(ctx, err)
226 return nil
227 }
228 return res
229}
230
231func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
232 if ec.DisableIntrospection {
233 return nil, errors.New("introspection disabled")
234 }
235 return introspection.WrapSchema(parsedSchema), nil
236}
237
238func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
239 if ec.DisableIntrospection {
240 return nil, errors.New("introspection disabled")
241 }
242 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
243}
244
245var parsedSchema = gqlparser.MustLoadSchema(
246 {{- range $filename, $schema := .SchemaStr }}
247 &ast.Source{Name: {{$filename|quote}}, Input: {{$schema|rawQuote}}},
248 {{- end }}
249)