|
|
|
// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
|
|
|
|
|
|
|
|
package generated
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"context"
|
|
|
|
"errors"
|
|
|
|
"strconv"
|
|
|
|
"sync"
|
|
|
|
"sync/atomic"
|
|
|
|
|
|
|
|
"github.com/99designs/gqlgen/graphql"
|
|
|
|
"github.com/99designs/gqlgen/graphql/introspection"
|
|
|
|
"github.com/tiptok/godevp/pkg/port/graphql/graph/model"
|
|
|
|
gqlparser "github.com/vektah/gqlparser/v2"
|
|
|
|
"github.com/vektah/gqlparser/v2/ast"
|
|
|
|
)
|
|
|
|
|
|
|
|
// region ************************** generated!.gotpl **************************
|
|
|
|
|
|
|
|
// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
|
|
|
|
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
|
|
|
|
return &executableSchema{
|
|
|
|
resolvers: cfg.Resolvers,
|
|
|
|
directives: cfg.Directives,
|
|
|
|
complexity: cfg.Complexity,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type Config struct {
|
|
|
|
Resolvers ResolverRoot
|
|
|
|
Directives DirectiveRoot
|
|
|
|
Complexity ComplexityRoot
|
|
|
|
}
|
|
|
|
|
|
|
|
type ResolverRoot interface {
|
|
|
|
Mutation() MutationResolver
|
|
|
|
Query() QueryResolver
|
|
|
|
Users() UsersResolver
|
|
|
|
}
|
|
|
|
|
|
|
|
type DirectiveRoot struct {
|
|
|
|
}
|
|
|
|
|
|
|
|
type ComplexityRoot struct {
|
|
|
|
Mutation struct {
|
|
|
|
CreateUsers func(childComplexity int, input model.CreateUsersInput) int
|
|
|
|
RemoveUsers func(childComplexity int, input model.RemoveUsersInput) int
|
|
|
|
UpdateUsers func(childComplexity int, input model.UpdateUsersInput) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Query struct {
|
|
|
|
FindUsers func(childComplexity int, input model.ListUsersInput) int
|
|
|
|
GetUsers func(childComplexity int, input model.GetUsersInput) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Role struct {
|
|
|
|
CreateTime func(childComplexity int) int
|
|
|
|
ID func(childComplexity int) int
|
|
|
|
ParentID func(childComplexity int) int
|
|
|
|
RoleName func(childComplexity int) int
|
|
|
|
UpdateTime func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Users struct {
|
|
|
|
AdminType func(childComplexity int) int
|
|
|
|
CreateTime func(childComplexity int) int
|
|
|
|
Name func(childComplexity int) int
|
|
|
|
Phone func(childComplexity int) int
|
|
|
|
Roles func(childComplexity int) int
|
|
|
|
Status func(childComplexity int) int
|
|
|
|
UpdateTime func(childComplexity int) int
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type MutationResolver interface {
|
|
|
|
CreateUsers(ctx context.Context, input model.CreateUsersInput) (*model.Users, error)
|
|
|
|
RemoveUsers(ctx context.Context, input model.RemoveUsersInput) (*model.Users, error)
|
|
|
|
UpdateUsers(ctx context.Context, input model.UpdateUsersInput) (*model.Users, error)
|
|
|
|
}
|
|
|
|
type QueryResolver interface {
|
|
|
|
GetUsers(ctx context.Context, input model.GetUsersInput) (*model.Users, error)
|
|
|
|
FindUsers(ctx context.Context, input model.ListUsersInput) ([]*model.Users, error)
|
|
|
|
}
|
|
|
|
type UsersResolver interface {
|
|
|
|
Roles(ctx context.Context, obj *model.Users) ([]*model.Role, error)
|
|
|
|
}
|
|
|
|
|
|
|
|
type executableSchema struct {
|
|
|
|
resolvers ResolverRoot
|
|
|
|
directives DirectiveRoot
|
|
|
|
complexity ComplexityRoot
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *executableSchema) Schema() *ast.Schema {
|
|
|
|
return parsedSchema
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
|
|
|
|
ec := executionContext{nil, e}
|
|
|
|
_ = ec
|
|
|
|
switch typeName + "." + field {
|
|
|
|
|
|
|
|
case "Mutation.createUsers":
|
|
|
|
if e.complexity.Mutation.CreateUsers == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createUsers_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateUsers(childComplexity, args["input"].(model.CreateUsersInput)), true
|
|
|
|
|
|
|
|
case "Mutation.removeUsers":
|
|
|
|
if e.complexity.Mutation.RemoveUsers == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_removeUsers_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.RemoveUsers(childComplexity, args["input"].(model.RemoveUsersInput)), true
|
|
|
|
|
|
|
|
case "Mutation.updateUsers":
|
|
|
|
if e.complexity.Mutation.UpdateUsers == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_updateUsers_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.UpdateUsers(childComplexity, args["input"].(model.UpdateUsersInput)), true
|
|
|
|
|
|
|
|
case "Query.findUsers":
|
|
|
|
if e.complexity.Query.FindUsers == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Query_findUsers_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.FindUsers(childComplexity, args["input"].(model.ListUsersInput)), true
|
|
|
|
|
|
|
|
case "Query.getUsers":
|
|
|
|
if e.complexity.Query.GetUsers == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Query_getUsers_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.GetUsers(childComplexity, args["input"].(model.GetUsersInput)), true
|
|
|
|
|
|
|
|
case "Role.createTime":
|
|
|
|
if e.complexity.Role.CreateTime == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Role.CreateTime(childComplexity), true
|
|
|
|
|
|
|
|
case "Role.id":
|
|
|
|
if e.complexity.Role.ID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Role.ID(childComplexity), true
|
|
|
|
|
|
|
|
case "Role.parentId":
|
|
|
|
if e.complexity.Role.ParentID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Role.ParentID(childComplexity), true
|
|
|
|
|
|
|
|
case "Role.roleName":
|
|
|
|
if e.complexity.Role.RoleName == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Role.RoleName(childComplexity), true
|
|
|
|
|
|
|
|
case "Role.updateTime":
|
|
|
|
if e.complexity.Role.UpdateTime == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Role.UpdateTime(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.adminType":
|
|
|
|
if e.complexity.Users.AdminType == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.AdminType(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.createTime":
|
|
|
|
if e.complexity.Users.CreateTime == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.CreateTime(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.name":
|
|
|
|
if e.complexity.Users.Name == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.Name(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.phone":
|
|
|
|
if e.complexity.Users.Phone == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.Phone(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.roles":
|
|
|
|
if e.complexity.Users.Roles == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.Roles(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.status":
|
|
|
|
if e.complexity.Users.Status == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.Status(childComplexity), true
|
|
|
|
|
|
|
|
case "Users.updateTime":
|
|
|
|
if e.complexity.Users.UpdateTime == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Users.UpdateTime(childComplexity), true
|
|
|
|
|
|
|
|
}
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
|
|
|
|
rc := graphql.GetOperationContext(ctx)
|
|
|
|
ec := executionContext{rc, e}
|
|
|
|
first := true
|
|
|
|
|
|
|
|
switch rc.Operation.Operation {
|
|
|
|
case ast.Query:
|
|
|
|
return func(ctx context.Context) *graphql.Response {
|
|
|
|
if !first {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
data := ec._Query(ctx, rc.Operation.SelectionSet)
|
|
|
|
var buf bytes.Buffer
|
|
|
|
data.MarshalGQL(&buf)
|
|
|
|
|
|
|
|
return &graphql.Response{
|
|
|
|
Data: buf.Bytes(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case ast.Mutation:
|
|
|
|
return func(ctx context.Context) *graphql.Response {
|
|
|
|
if !first {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
data := ec._Mutation(ctx, rc.Operation.SelectionSet)
|
|
|
|
var buf bytes.Buffer
|
|
|
|
data.MarshalGQL(&buf)
|
|
|
|
|
|
|
|
return &graphql.Response{
|
|
|
|
Data: buf.Bytes(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type executionContext struct {
|
|
|
|
*graphql.OperationContext
|
|
|
|
*executableSchema
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
|
|
|
|
if ec.DisableIntrospection {
|
|
|
|
return nil, errors.New("introspection disabled")
|
|
|
|
}
|
|
|
|
return introspection.WrapSchema(parsedSchema), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
|
|
|
|
if ec.DisableIntrospection {
|
|
|
|
return nil, errors.New("introspection disabled")
|
|
|
|
}
|
|
|
|
return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var sources = []*ast.Source{
|
|
|
|
{Name: "graph/schema.graphqls", Input: `## type
|
|
|
|
type Users{
|
|
|
|
name: String
|
|
|
|
phone: String
|
|
|
|
roles: [Role!]
|
|
|
|
status: Int
|
|
|
|
adminType: Int
|
|
|
|
createTime: String
|
|
|
|
updateTime: String
|
|
|
|
}
|
|
|
|
type Role{
|
|
|
|
id: Int
|
|
|
|
roleName: String
|
|
|
|
parentId: Int
|
|
|
|
createTime: String
|
|
|
|
updateTime: String
|
|
|
|
}
|
|
|
|
|
|
|
|
## user input
|
|
|
|
input createUsersInput{
|
|
|
|
name: String!
|
|
|
|
phone: String!
|
|
|
|
}
|
|
|
|
input updateUsersInput{
|
|
|
|
id: Int!
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
input removeUsersInput{
|
|
|
|
id: Int!
|
|
|
|
}
|
|
|
|
input getUsersInput{
|
|
|
|
id: Int!
|
|
|
|
}
|
|
|
|
input listUsersInput{
|
|
|
|
offset: Int!
|
|
|
|
limit: Int!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Query {
|
|
|
|
getUsers(input : getUsersInput!): Users!
|
|
|
|
findUsers(input : listUsersInput!): [Users!]
|
|
|
|
}
|
|
|
|
|
|
|
|
type Mutation{
|
|
|
|
createUsers(input : createUsersInput!): Users!
|
|
|
|
removeUsers(input : removeUsersInput!): Users!
|
|
|
|
updateUsers(input : updateUsersInput!): Users!
|
|
|
|
}`, BuiltIn: false},
|
|
|
|
}
|
|
|
|
var parsedSchema = gqlparser.MustLoadSchema(sources...)
|
|
|
|
|
|
|
|
// endregion ************************** generated!.gotpl **************************
|
|
|
|
|
|
|
|
// region ***************************** args.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createUsers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 model.CreateUsersInput
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
|
|
|
|
arg0, err = ec.unmarshalNcreateUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐCreateUsersInput(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_removeUsers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 model.RemoveUsersInput
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
|
|
|
|
arg0, err = ec.unmarshalNremoveUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐRemoveUsersInput(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_updateUsers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 model.UpdateUsersInput
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
|
|
|
|
arg0, err = ec.unmarshalNupdateUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUpdateUsersInput(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 string
|
|
|
|
if tmp, ok := rawArgs["name"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
|
|
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["name"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query_findUsers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 model.ListUsersInput
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
|
|
|
|
arg0, err = ec.unmarshalNlistUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐListUsersInput(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query_getUsers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 model.GetUsersInput
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
|
|
|
|
arg0, err = ec.unmarshalNgetUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐGetUsersInput(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 bool
|
|
|
|
if tmp, ok := rawArgs["includeDeprecated"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
|
|
|
|
arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["includeDeprecated"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 bool
|
|
|
|
if tmp, ok := rawArgs["includeDeprecated"]; ok {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
|
|
|
|
arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["includeDeprecated"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion ***************************** args.gotpl *****************************
|
|
|
|
|
|
|
|
// region ************************** directives.gotpl **************************
|
|
|
|
|
|
|
|
// endregion ************************** directives.gotpl **************************
|
|
|
|
|
|
|
|
// region **************************** field.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createUsers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createUsers_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Mutation().CreateUsers(rctx, args["input"].(model.CreateUsersInput))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*model.Users)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUsers2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_removeUsers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_removeUsers_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Mutation().RemoveUsers(rctx, args["input"].(model.RemoveUsersInput))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*model.Users)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUsers2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_updateUsers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_updateUsers_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Mutation().UpdateUsers(rctx, args["input"].(model.UpdateUsersInput))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*model.Users)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUsers2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_getUsers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Query",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Query_getUsers_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Query().GetUsers(rctx, args["input"].(model.GetUsersInput))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*model.Users)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUsers2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_findUsers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Query",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Query_findUsers_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Query().FindUsers(rctx, args["input"].(model.ListUsersInput))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]*model.Users)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOUsers2ᚕᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsersᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Query",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Query___type_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.introspectType(args["name"].(string))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Query",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.introspectSchema()
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Schema)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Role_id(ctx context.Context, field graphql.CollectedField, obj *model.Role) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Role",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.ID, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*int)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Role_roleName(ctx context.Context, field graphql.CollectedField, obj *model.Role) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Role",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.RoleName, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Role_parentId(ctx context.Context, field graphql.CollectedField, obj *model.Role) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Role",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.ParentID, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*int)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Role_createTime(ctx context.Context, field graphql.CollectedField, obj *model.Role) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Role",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.CreateTime, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Role_updateTime(ctx context.Context, field graphql.CollectedField, obj *model.Role) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Role",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.UpdateTime, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_name(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Name, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_phone(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Phone, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_roles(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Users().Roles(rctx, obj)
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]*model.Role)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalORole2ᚕᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐRoleᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_status(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Status, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*int)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_adminType(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.AdminType, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*int)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_createTime(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.CreateTime, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users_updateTime(ctx context.Context, field graphql.CollectedField, obj *model.Users) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Users",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.UpdateTime, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Name, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Locations, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Args, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.InputValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Name, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.IsDeprecated(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(bool)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.DeprecationReason(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Name, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Args, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.InputValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Type, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.IsDeprecated(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(bool)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.DeprecationReason(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Name, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Type, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: false,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.DefaultValue, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Types(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.QueryType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.MutationType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.SubscriptionType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Directives(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Directive)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Kind(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, fc) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Name(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Description(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field___Type_fields_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Fields(args["includeDeprecated"].(bool)), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Field)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.Interfaces(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.PossibleTypes(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
fc.Args = args
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.EnumValues(args["includeDeprecated"].(bool)), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.EnumValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.InputFields(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.InputValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
IsResolver: false,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return obj.OfType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion **************************** field.gotpl *****************************
|
|
|
|
|
|
|
|
// region **************************** input.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputcreateUsersInput(ctx context.Context, obj interface{}) (model.CreateUsersInput, error) {
|
|
|
|
var it model.CreateUsersInput
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "phone":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("phone"))
|
|
|
|
it.Phone, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputgetUsersInput(ctx context.Context, obj interface{}) (model.GetUsersInput, error) {
|
|
|
|
var it model.GetUsersInput
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "id":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
|
|
|
|
it.ID, err = ec.unmarshalNInt2int(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputlistUsersInput(ctx context.Context, obj interface{}) (model.ListUsersInput, error) {
|
|
|
|
var it model.ListUsersInput
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "offset":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
|
|
|
|
it.Offset, err = ec.unmarshalNInt2int(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "limit":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
|
|
|
|
it.Limit, err = ec.unmarshalNInt2int(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputremoveUsersInput(ctx context.Context, obj interface{}) (model.RemoveUsersInput, error) {
|
|
|
|
var it model.RemoveUsersInput
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "id":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
|
|
|
|
it.ID, err = ec.unmarshalNInt2int(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputupdateUsersInput(ctx context.Context, obj interface{}) (model.UpdateUsersInput, error) {
|
|
|
|
var it model.UpdateUsersInput
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "id":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
|
|
|
|
it.ID, err = ec.unmarshalNInt2int(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
|
|
|
|
it.Name, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion **************************** input.gotpl *****************************
|
|
|
|
|
|
|
|
// region ************************** interface.gotpl ***************************
|
|
|
|
|
|
|
|
// endregion ************************** interface.gotpl ***************************
|
|
|
|
|
|
|
|
// region **************************** object.gotpl ****************************
|
|
|
|
|
|
|
|
var mutationImplementors = []string{"Mutation"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
|
|
|
|
Object: "Mutation",
|
|
|
|
})
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Mutation")
|
|
|
|
case "createUsers":
|
|
|
|
out.Values[i] = ec._Mutation_createUsers(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "removeUsers":
|
|
|
|
out.Values[i] = ec._Mutation_removeUsers(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "updateUsers":
|
|
|
|
out.Values[i] = ec._Mutation_updateUsers(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var queryImplementors = []string{"Query"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
|
|
|
|
Object: "Query",
|
|
|
|
})
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Query")
|
|
|
|
case "getUsers":
|
|
|
|
field := field
|
|
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
res = ec._Query_getUsers(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "findUsers":
|
|
|
|
field := field
|
|
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
res = ec._Query_findUsers(ctx, field)
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "__type":
|
|
|
|
out.Values[i] = ec._Query___type(ctx, field)
|
|
|
|
case "__schema":
|
|
|
|
out.Values[i] = ec._Query___schema(ctx, field)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var roleImplementors = []string{"Role"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Role(ctx context.Context, sel ast.SelectionSet, obj *model.Role) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, roleImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Role")
|
|
|
|
case "id":
|
|
|
|
out.Values[i] = ec._Role_id(ctx, field, obj)
|
|
|
|
case "roleName":
|
|
|
|
out.Values[i] = ec._Role_roleName(ctx, field, obj)
|
|
|
|
case "parentId":
|
|
|
|
out.Values[i] = ec._Role_parentId(ctx, field, obj)
|
|
|
|
case "createTime":
|
|
|
|
out.Values[i] = ec._Role_createTime(ctx, field, obj)
|
|
|
|
case "updateTime":
|
|
|
|
out.Values[i] = ec._Role_updateTime(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var usersImplementors = []string{"Users"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Users(ctx context.Context, sel ast.SelectionSet, obj *model.Users) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, usersImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Users")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec._Users_name(ctx, field, obj)
|
|
|
|
case "phone":
|
|
|
|
out.Values[i] = ec._Users_phone(ctx, field, obj)
|
|
|
|
case "roles":
|
|
|
|
field := field
|
|
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
res = ec._Users_roles(ctx, field, obj)
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "status":
|
|
|
|
out.Values[i] = ec._Users_status(ctx, field, obj)
|
|
|
|
case "adminType":
|
|
|
|
out.Values[i] = ec._Users_adminType(ctx, field, obj)
|
|
|
|
case "createTime":
|
|
|
|
out.Values[i] = ec._Users_createTime(ctx, field, obj)
|
|
|
|
case "updateTime":
|
|
|
|
out.Values[i] = ec._Users_updateTime(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __DirectiveImplementors = []string{"__Directive"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Directive")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___Directive_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___Directive_description(ctx, field, obj)
|
|
|
|
case "locations":
|
|
|
|
out.Values[i] = ec.___Directive_locations(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "args":
|
|
|
|
out.Values[i] = ec.___Directive_args(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __EnumValueImplementors = []string{"__EnumValue"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__EnumValue")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
|
|
|
|
case "isDeprecated":
|
|
|
|
out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "deprecationReason":
|
|
|
|
out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __FieldImplementors = []string{"__Field"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Field")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___Field_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___Field_description(ctx, field, obj)
|
|
|
|
case "args":
|
|
|
|
out.Values[i] = ec.___Field_args(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "type":
|
|
|
|
out.Values[i] = ec.___Field_type(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "isDeprecated":
|
|
|
|
out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "deprecationReason":
|
|
|
|
out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __InputValueImplementors = []string{"__InputValue"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__InputValue")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___InputValue_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___InputValue_description(ctx, field, obj)
|
|
|
|
case "type":
|
|
|
|
out.Values[i] = ec.___InputValue_type(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "defaultValue":
|
|
|
|
out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __SchemaImplementors = []string{"__Schema"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Schema")
|
|
|
|
case "types":
|
|
|
|
out.Values[i] = ec.___Schema_types(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "queryType":
|
|
|
|
out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "mutationType":
|
|
|
|
out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
|
|
|
|
case "subscriptionType":
|
|
|
|
out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
|
|
|
|
case "directives":
|
|
|
|
out.Values[i] = ec.___Schema_directives(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __TypeImplementors = []string{"__Type"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Type")
|
|
|
|
case "kind":
|
|
|
|
out.Values[i] = ec.___Type_kind(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___Type_name(ctx, field, obj)
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___Type_description(ctx, field, obj)
|
|
|
|
case "fields":
|
|
|
|
out.Values[i] = ec.___Type_fields(ctx, field, obj)
|
|
|
|
case "interfaces":
|
|
|
|
out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
|
|
|
|
case "possibleTypes":
|
|
|
|
out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
|
|
|
|
case "enumValues":
|
|
|
|
out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
|
|
|
|
case "inputFields":
|
|
|
|
out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
|
|
|
|
case "ofType":
|
|
|
|
out.Values[i] = ec.___Type_ofType(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion **************************** object.gotpl ****************************
|
|
|
|
|
|
|
|
// region ***************************** type.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
|
|
|
|
res, err := graphql.UnmarshalBoolean(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalBoolean(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
|
|
|
|
res, err := graphql.UnmarshalInt(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalInt(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNRole2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐRole(ctx context.Context, sel ast.SelectionSet, v *model.Role) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._Role(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
res, err := graphql.UnmarshalString(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalString(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNUsers2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx context.Context, sel ast.SelectionSet, v model.Users) graphql.Marshaler {
|
|
|
|
return ec._Users(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNUsers2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx context.Context, sel ast.SelectionSet, v *model.Users) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._Users(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
|
|
|
|
return ec.___Directive(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
res, err := graphql.UnmarshalString(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalString(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
|
|
|
|
var vSlice []interface{}
|
|
|
|
if v != nil {
|
|
|
|
if tmp1, ok := v.([]interface{}); ok {
|
|
|
|
vSlice = tmp1
|
|
|
|
} else {
|
|
|
|
vSlice = []interface{}{v}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var err error
|
|
|
|
res := make([]string, len(vSlice))
|
|
|
|
for i := range vSlice {
|
|
|
|
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
|
|
|
|
res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
|
|
|
|
return ec.___EnumValue(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
|
|
|
|
return ec.___Field(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
|
|
|
|
return ec.___InputValue(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
|
|
|
|
return ec.___Type(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.___Type(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
res, err := graphql.UnmarshalString(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalString(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNcreateUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐCreateUsersInput(ctx context.Context, v interface{}) (model.CreateUsersInput, error) {
|
|
|
|
res, err := ec.unmarshalInputcreateUsersInput(ctx, v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNgetUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐGetUsersInput(ctx context.Context, v interface{}) (model.GetUsersInput, error) {
|
|
|
|
res, err := ec.unmarshalInputgetUsersInput(ctx, v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNlistUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐListUsersInput(ctx context.Context, v interface{}) (model.ListUsersInput, error) {
|
|
|
|
res, err := ec.unmarshalInputlistUsersInput(ctx, v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNremoveUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐRemoveUsersInput(ctx context.Context, v interface{}) (model.RemoveUsersInput, error) {
|
|
|
|
res, err := ec.unmarshalInputremoveUsersInput(ctx, v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNupdateUsersInput2githubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUpdateUsersInput(ctx context.Context, v interface{}) (model.UpdateUsersInput, error) {
|
|
|
|
res, err := ec.unmarshalInputupdateUsersInput(ctx, v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
|
|
|
|
res, err := graphql.UnmarshalBoolean(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
|
|
|
|
return graphql.MarshalBoolean(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
|
|
|
|
if v == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
res, err := graphql.UnmarshalBoolean(v)
|
|
|
|
return &res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return graphql.MarshalBoolean(*v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
|
|
|
|
if v == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
res, err := graphql.UnmarshalInt(v)
|
|
|
|
return &res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return graphql.MarshalInt(*v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalORole2ᚕᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐRoleᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Role) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalNRole2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐRole(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
res, err := graphql.UnmarshalString(v)
|
|
|
|
return res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
return graphql.MarshalString(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
|
|
|
|
if v == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
res, err := graphql.UnmarshalString(v)
|
|
|
|
return &res, graphql.ErrorOnPath(ctx, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return graphql.MarshalString(*v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOUsers2ᚕᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsersᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Users) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalNUsers2ᚖgithubᚗcomᚋtiptokᚋgodevpᚋpkgᚋportᚋgraphqlᚋgraphᚋmodelᚐUsers(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.___Schema(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
ret := make(graphql.Array, len(v))
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
isLen1 := len(v) == 1
|
|
|
|
if !isLen1 {
|
|
|
|
wg.Add(len(v))
|
|
|
|
}
|
|
|
|
for i := range v {
|
|
|
|
i := i
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Index: &i,
|
|
|
|
Result: &v[i],
|
|
|
|
}
|
|
|
|
ctx := graphql.WithFieldContext(ctx, fc)
|
|
|
|
f := func(i int) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = nil
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if !isLen1 {
|
|
|
|
defer wg.Done()
|
|
|
|
}
|
|
|
|
ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.___Type(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion ***************************** type.gotpl ***************************** |
...
|
...
|
|
