github.com/operandinc/gqlgen@v0.16.1/codegen/generated!.gotpl (about) 1 {{ reserveImport "context" }} 2 {{ reserveImport "fmt" }} 3 {{ reserveImport "io" }} 4 {{ reserveImport "strconv" }} 5 {{ reserveImport "time" }} 6 {{ reserveImport "sync" }} 7 {{ reserveImport "sync/atomic" }} 8 {{ reserveImport "errors" }} 9 {{ reserveImport "bytes" }} 10 11 {{ reserveImport "github.com/vektah/gqlparser/v2" "gqlparser" }} 12 {{ reserveImport "github.com/vektah/gqlparser/v2/ast" }} 13 {{ reserveImport "github.com/operandinc/gqlgen/graphql" }} 14 {{ reserveImport "github.com/operandinc/gqlgen/graphql/introspection" }} 15 16 17 {{ if eq .Config.Exec.Layout "single-file" }} 18 // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface. 19 func NewExecutableSchema(cfg Config) graphql.ExecutableSchema { 20 return &executableSchema{ 21 resolvers: cfg.Resolvers, 22 directives: cfg.Directives, 23 complexity: cfg.Complexity, 24 } 25 } 26 27 type Config struct { 28 Resolvers ResolverRoot 29 Directives DirectiveRoot 30 Complexity ComplexityRoot 31 } 32 33 type ResolverRoot interface { 34 {{- range $object := .Objects -}} 35 {{ if $object.HasResolvers -}} 36 {{ucFirst $object.Name}}() {{ucFirst $object.Name}}Resolver 37 {{ end }} 38 {{- end }} 39 {{- range $object := .Inputs -}} 40 {{ if $object.HasResolvers -}} 41 {{ucFirst $object.Name}}() {{ucFirst $object.Name}}Resolver 42 {{ end }} 43 {{- end }} 44 } 45 46 type DirectiveRoot struct { 47 {{ range $directive := .Directives }} 48 {{- $directive.Declaration }} 49 {{ end }} 50 } 51 52 type ComplexityRoot struct { 53 {{ range $object := .Objects }} 54 {{ if not $object.IsReserved -}} 55 {{ ucFirst $object.Name }} struct { 56 {{ range $_, $fields := $object.UniqueFields }} 57 {{- $field := index $fields 0 -}} 58 {{ if not $field.IsReserved -}} 59 {{ $field.GoFieldName }} {{ $field.ComplexitySignature }} 60 {{ end }} 61 {{- end }} 62 } 63 {{- end }} 64 {{ end }} 65 } 66 {{ end }} 67 68 {{ range $object := .Objects -}} 69 {{ if $object.HasResolvers }} 70 type {{ucFirst $object.Name}}Resolver interface { 71 {{ range $field := $object.Fields -}} 72 {{- if $field.IsResolver }} 73 {{- $field.GoFieldName}}{{ $field.ShortResolverDeclaration }} 74 {{- end }} 75 {{ end }} 76 } 77 {{- end }} 78 {{- end }} 79 80 {{ range $object := .Inputs -}} 81 {{ if $object.HasResolvers }} 82 type {{$object.Name}}Resolver interface { 83 {{ range $field := $object.Fields -}} 84 {{- if $field.IsResolver }} 85 {{- $field.GoFieldName}}{{ $field.ShortResolverDeclaration }} 86 {{- end }} 87 {{ end }} 88 } 89 {{- end }} 90 {{- end }} 91 92 {{ if eq .Config.Exec.Layout "single-file" }} 93 type executableSchema struct { 94 resolvers ResolverRoot 95 directives DirectiveRoot 96 complexity ComplexityRoot 97 } 98 99 func (e *executableSchema) Schema() *ast.Schema { 100 return parsedSchema 101 } 102 103 func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) { 104 ec := executionContext{nil, e} 105 _ = ec 106 switch typeName + "." + field { 107 {{ range $object := .Objects }} 108 {{ if not $object.IsReserved }} 109 {{ range $_, $fields := $object.UniqueFields }} 110 {{- $len := len $fields }} 111 {{- range $i, $field := $fields }} 112 {{- $last := eq (add $i 1) $len }} 113 {{- if not $field.IsReserved }} 114 {{- if eq $i 0 }}case {{ end }}"{{$object.Name}}.{{$field.Name}}"{{ if not $last }},{{ else }}: 115 if e.complexity.{{ucFirst $object.Name}}.{{$field.GoFieldName}} == nil { 116 break 117 } 118 {{ if $field.Args }} 119 args, err := ec.{{ $field.ArgsFunc }}(context.TODO(),rawArgs) 120 if err != nil { 121 return 0, false 122 } 123 {{ end }} 124 return e.complexity.{{ucFirst $object.Name}}.{{$field.GoFieldName}}(childComplexity{{if $field.Args}}, {{$field.ComplexityArgs}} {{ end }}), true 125 {{ end }} 126 {{- end }} 127 {{- end }} 128 {{ end }} 129 {{ end }} 130 {{ end }} 131 } 132 return 0, false 133 } 134 135 func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { 136 rc := graphql.GetOperationContext(ctx) 137 ec := executionContext{rc, e} 138 first := true 139 140 switch rc.Operation.Operation { 141 {{- if .QueryRoot }} case ast.Query: 142 return func(ctx context.Context) *graphql.Response { 143 if !first { return nil } 144 first = false 145 {{ if .Directives.LocationDirectives "QUERY" -}} 146 data := ec._queryMiddleware(ctx, rc.Operation, func(ctx context.Context) (interface{}, error){ 147 return ec._{{.QueryRoot.Name}}(ctx, rc.Operation.SelectionSet), nil 148 }) 149 {{- else -}} 150 data := ec._{{.QueryRoot.Name}}(ctx, rc.Operation.SelectionSet) 151 {{- end }} 152 var buf bytes.Buffer 153 data.MarshalGQL(&buf) 154 155 return &graphql.Response{ 156 Data: buf.Bytes(), 157 } 158 } 159 {{ end }} 160 161 {{- if .MutationRoot }} case ast.Mutation: 162 return func(ctx context.Context) *graphql.Response { 163 if !first { return nil } 164 first = false 165 {{ if .Directives.LocationDirectives "MUTATION" -}} 166 data := ec._mutationMiddleware(ctx, rc.Operation, func(ctx context.Context) (interface{}, error){ 167 return ec._{{.MutationRoot.Name}}(ctx, rc.Operation.SelectionSet), nil 168 }) 169 {{- else -}} 170 data := ec._{{.MutationRoot.Name}}(ctx, rc.Operation.SelectionSet) 171 {{- end }} 172 var buf bytes.Buffer 173 data.MarshalGQL(&buf) 174 175 return &graphql.Response{ 176 Data: buf.Bytes(), 177 } 178 } 179 {{ end }} 180 181 {{- if .SubscriptionRoot }} case ast.Subscription: 182 {{ if .Directives.LocationDirectives "SUBSCRIPTION" -}} 183 next := ec._subscriptionMiddleware(ctx, rc.Operation, func(ctx context.Context) (interface{}, error){ 184 return ec._{{.SubscriptionRoot.Name}}(ctx, rc.Operation.SelectionSet),nil 185 }) 186 {{- else -}} 187 next := ec._{{.SubscriptionRoot.Name}}(ctx, rc.Operation.SelectionSet) 188 {{- end }} 189 190 var buf bytes.Buffer 191 return func(ctx context.Context) *graphql.Response { 192 buf.Reset() 193 data := next() 194 195 if data == nil { 196 return nil 197 } 198 data.MarshalGQL(&buf) 199 200 return &graphql.Response{ 201 Data: buf.Bytes(), 202 } 203 } 204 {{ end }} 205 default: 206 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) 207 } 208 } 209 210 type executionContext struct { 211 *graphql.OperationContext 212 *executableSchema 213 } 214 215 func (ec *executionContext) introspectSchema() (*introspection.Schema, error) { 216 if ec.DisableIntrospection { 217 return nil, errors.New("introspection disabled") 218 } 219 return introspection.WrapSchema(parsedSchema), nil 220 } 221 222 func (ec *executionContext) introspectType(name string) (*introspection.Type, error) { 223 if ec.DisableIntrospection { 224 return nil, errors.New("introspection disabled") 225 } 226 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil 227 } 228 229 var sources = []*ast.Source{ 230 {{- range $source := .Config.Sources }} 231 {Name: {{$source.Name|quote}}, Input: {{$source.Input|rawQuote}}, BuiltIn: {{$source.BuiltIn}}}, 232 {{- end }} 233 } 234 var parsedSchema = gqlparser.MustLoadSchema(sources...) 235 {{ end }}