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