github.com/HaswinVidanage/gqlgen@v0.8.1-0.20220609041233-69528c1bf712/codegen/generated!.gotpl (about) 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/HaswinVidanage/gqlgen/graphql" }} 13 {{ reserveImport "github.com/HaswinVidanage/gqlgen/graphql/introspection" }} 14 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 {{$object.Name}}() {{$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 {{ $object.Name|toCamel }} struct { 49 {{ range $field := $object.Fields -}} 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 71 type executableSchema struct { 72 resolvers ResolverRoot 73 directives DirectiveRoot 74 complexity ComplexityRoot 75 } 76 77 func (e *executableSchema) Schema() *ast.Schema { 78 return parsedSchema 79 } 80 81 func (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.Fields }} 88 {{ if not $field.IsReserved }} 89 case "{{$object.Name}}.{{$field.GoFieldName}}": 90 if e.complexity.{{$object.Name|toCamel}}.{{$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|toCamel}}.{{$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 108 func (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 129 func (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 150 func (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 187 type executionContext struct { 188 *graphql.RequestContext 189 *executableSchema 190 } 191 192 func (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 231 func (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 238 func (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 245 var parsedSchema = gqlparser.MustLoadSchema( 246 {{- range $filename, $schema := .SchemaStr }} 247 &ast.Source{Name: {{$filename|quote}}, Input: {{$schema|rawQuote}}}, 248 {{- end }} 249 )