├── .gitignore ├── Gopkg.lock ├── Gopkg.toml ├── README.md ├── api ├── auth │ └── midleware.go ├── dal │ └── db.go ├── dataloaders │ ├── dataloader.go │ └── userloader_gen.go ├── errors │ └── error.go └── models.go ├── generated.go ├── gqlgen.yml ├── models_gen.go ├── resolver.go ├── schema.graphql ├── scripts └── gqlgen.go └── server └── server.go /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | vendor/ 3 | -------------------------------------------------------------------------------- /Gopkg.lock: -------------------------------------------------------------------------------- 1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. 2 | 3 | 4 | [[projects]] 5 | digest = "1:cc0bbbf01f9f639555f9a9d4d5ff9c72da4c4c4bfe71f02fd318d37498270d80" 6 | name = "github.com/99designs/gqlgen" 7 | packages = [ 8 | "cmd", 9 | "codegen", 10 | "codegen/templates", 11 | "complexity", 12 | "graphql", 13 | "graphql/introspection", 14 | "handler", 15 | "internal/gopath", 16 | "internal/imports", 17 | ] 18 | pruneopts = "UT" 19 | revision = "3a7f37c7e22a8fedce430c4d340ad5c1351198f4" 20 | version = "v0.7.1" 21 | 22 | [[projects]] 23 | digest = "1:cc306cae16c310ca360eaee3e563109e251832a3f6a13b26bf39cc6a43c7c9f6" 24 | name = "github.com/agnivade/levenshtein" 25 | packages = ["."] 26 | pruneopts = "UT" 27 | revision = "834b435c3df04fba060c8d74a40d849ab2c4a090" 28 | version = "v1.0.1" 29 | 30 | [[projects]] 31 | digest = "1:7b5c6e2eeaa9ae5907c391a91c132abfd5c9e8a784a341b5625e750c67e6825d" 32 | name = "github.com/gorilla/websocket" 33 | packages = ["."] 34 | pruneopts = "UT" 35 | revision = "66b9c49e59c6c48f0ffce28c2d8b8a5678502c6d" 36 | version = "v1.4.0" 37 | 38 | [[projects]] 39 | digest = "1:8ec8d88c248041a6df5f6574b87bc00e7e0b493881dad2e7ef47b11dc69093b5" 40 | name = "github.com/hashicorp/golang-lru" 41 | packages = [ 42 | ".", 43 | "simplelru", 44 | ] 45 | pruneopts = "UT" 46 | revision = "20f1fb78b0740ba8c3cb143a61e86ba5c8669768" 47 | version = "v0.5.0" 48 | 49 | [[projects]] 50 | digest = "1:cf31692c14422fa27c83a05292eb5cbe0fb2775972e8f1f8446a71549bd8980b" 51 | name = "github.com/pkg/errors" 52 | packages = ["."] 53 | pruneopts = "UT" 54 | revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4" 55 | version = "v0.8.1" 56 | 57 | [[projects]] 58 | digest = "1:b24d38b282bacf9791408a080f606370efa3d364e4b5fd9ba0f7b87786d3b679" 59 | name = "github.com/urfave/cli" 60 | packages = ["."] 61 | pruneopts = "UT" 62 | revision = "cfb38830724cc34fedffe9a2a29fb54fa9169cd1" 63 | version = "v1.20.0" 64 | 65 | [[projects]] 66 | digest = "1:df1733adbff537430f4b3179ee1c22cb5fb7160913b9f1e7858afd6348499878" 67 | name = "github.com/vektah/gqlparser" 68 | packages = [ 69 | ".", 70 | "ast", 71 | "gqlerror", 72 | "lexer", 73 | "parser", 74 | "validator", 75 | "validator/rules", 76 | ] 77 | pruneopts = "UT" 78 | revision = "b850e94a0bf8eab2820054638d96def671b7ae4e" 79 | version = "v1.1.0" 80 | 81 | [[projects]] 82 | branch = "master" 83 | digest = "1:bcc7ca488b127d6dfd829f57a5091c88cc68c81bf249fd342144ce2076706823" 84 | name = "golang.org/x/tools" 85 | packages = [ 86 | "go/ast/astutil", 87 | "go/buildutil", 88 | "go/gcexportdata", 89 | "go/internal/cgo", 90 | "go/internal/gcimporter", 91 | "go/internal/packagesdriver", 92 | "go/loader", 93 | "go/packages", 94 | "go/types/typeutil", 95 | "imports", 96 | "internal/fastwalk", 97 | "internal/gopathwalk", 98 | "internal/module", 99 | "internal/semver", 100 | ] 101 | pruneopts = "UT" 102 | revision = "51e363b66d25e28ae79d34610901114c8df309ee" 103 | 104 | [[projects]] 105 | digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96" 106 | name = "gopkg.in/yaml.v2" 107 | packages = ["."] 108 | pruneopts = "UT" 109 | revision = "51d6538a90f86fe93ac480b35f37b2be17fef232" 110 | version = "v2.2.2" 111 | 112 | [solve-meta] 113 | analyzer-name = "dep" 114 | analyzer-version = 1 115 | input-imports = [ 116 | "github.com/99designs/gqlgen/cmd", 117 | "github.com/99designs/gqlgen/graphql", 118 | "github.com/99designs/gqlgen/graphql/introspection", 119 | "github.com/99designs/gqlgen/handler", 120 | "github.com/vektah/gqlparser", 121 | "github.com/vektah/gqlparser/ast", 122 | ] 123 | solver-name = "gps-cdcl" 124 | solver-version = 1 125 | -------------------------------------------------------------------------------- /Gopkg.toml: -------------------------------------------------------------------------------- 1 | # Gopkg.toml example 2 | # 3 | # Refer to https://golang.github.io/dep/docs/Gopkg.toml.html 4 | # for detailed Gopkg.toml documentation. 5 | # 6 | # required = ["github.com/user/thing/cmd/thing"] 7 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] 8 | # 9 | # [[constraint]] 10 | # name = "github.com/user/project" 11 | # version = "1.0.0" 12 | # 13 | # [[constraint]] 14 | # name = "github.com/user/project2" 15 | # branch = "dev" 16 | # source = "github.com/myfork/project2" 17 | # 18 | # [[override]] 19 | # name = "github.com/x/y" 20 | # version = "2.4.0" 21 | # 22 | # [prune] 23 | # non-go = false 24 | # go-tests = true 25 | # unused-packages = true 26 | 27 | 28 | [[constraint]] 29 | name = "github.com/99designs/gqlgen" 30 | version = "0.7.1" 31 | 32 | [prune] 33 | go-tests = true 34 | unused-packages = true 35 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # go-graphql-example 2 | 3 | Read more at: 4 | 1. [Deep Dive Into GraphQL With Golang](https://medium.freecodecamp.org/deep-dive-into-graphql-with-golang-d3e02a429ac3) 5 | 6 | #### Getting Started 7 | 1. Clone the repo `git clone https://github.com/ridhamtarpara/go-graphql-demo.git` 8 | 2. Run `dep ensure` or ([Install dep](https://github.com/golang/dep)) 9 | 3. Update your postgres credential in `api/dal/db.go`. 10 | 3. Run `go run server/server.go` 11 | 4. Open `http://localhost:8080/` for GraphQL Playground 12 | 13 | #### Pending tasks 14 | 1. toml or env config 15 | 2. update gqlgen version 16 | 3. Doc update 17 | -------------------------------------------------------------------------------- /api/auth/midleware.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | import ( 4 | "context" 5 | "github.com/ridhamtarpara/go-graphql-demo" 6 | "net/http" 7 | ) 8 | 9 | func AuthMiddleware(next http.Handler) http.Handler { 10 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 11 | ctx := r.Context() 12 | auth := r.Header.Get("Authorization") 13 | if auth != "" { 14 | // Write your fancy token introspection logic here and if valid user then pass appropriate key in header 15 | // IMPORTANT: DO NOT HANDLE UNAUTHORISED USER HERE 16 | ctx = context.WithValue(ctx,go_graphql_demo.UserIDCtxKey, auth) 17 | } 18 | next.ServeHTTP(w, r.WithContext(ctx)) 19 | }) 20 | } -------------------------------------------------------------------------------- /api/dal/db.go: -------------------------------------------------------------------------------- 1 | package dal 2 | 3 | import ( 4 | "database/sql" 5 | "fmt" 6 | _ "github.com/lib/pq" 7 | "sync" 8 | ) 9 | 10 | const ( 11 | DB_USER = "postgres" 12 | DB_PASSWORD = "docker" 13 | DB_NAME = "gqldemo" 14 | SSL_MODE = "disable" 15 | ) 16 | 17 | var once sync.Once 18 | 19 | func Connect() (*sql.DB, error){ 20 | var db *sql.DB 21 | var err error 22 | once.Do(func() { 23 | dbinfo := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=%s", 24 | DB_USER, DB_PASSWORD, DB_NAME, SSL_MODE) 25 | db, _ = sql.Open("postgres", dbinfo) 26 | err = db.Ping() 27 | }) 28 | return db, err 29 | } 30 | 31 | func LogAndQuery(db *sql.DB, query string, args ...interface{}) (*sql.Rows, error) { 32 | fmt.Println(query) 33 | return db.Query(query, args...) 34 | } 35 | 36 | func MustExec(db *sql.DB, query string, args ...interface{}) { 37 | _, err := db.Exec(query, args...) 38 | if err != nil { 39 | panic(err) 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /api/dataloaders/dataloader.go: -------------------------------------------------------------------------------- 1 | package dataloaders 2 | 3 | import ( 4 | "context" 5 | "database/sql" 6 | "github.com/jmoiron/sqlx" 7 | "github.com/ridhamtarpara/go-graphql-demo/api" 8 | "github.com/ridhamtarpara/go-graphql-demo/api/dal" 9 | "github.com/ridhamtarpara/go-graphql-demo/api/errors" 10 | "log" 11 | "net/http" 12 | "time" 13 | ) 14 | 15 | type ctxKeyType struct { name string } 16 | 17 | var CtxKey = ctxKeyType{"dataloaderctx"} 18 | 19 | type Loaders struct { 20 | UserByID *UserLoader 21 | } 22 | 23 | func DataloaderMiddleware(db *sql.DB, next http.Handler) http.Handler { 24 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 25 | userloader := UserLoader{ 26 | wait : 1 * time.Millisecond, 27 | maxBatch: 100, 28 | fetch: func(ids []int) ([]*api.User, []error) { 29 | var sqlQuery string 30 | if len(ids) == 1 { 31 | sqlQuery = "SELECT id, name, email from users WHERE id = ?" 32 | } else { 33 | sqlQuery = "SELECT id, name, email from users WHERE id IN (?)" 34 | } 35 | sqlQuery, arguments, err := sqlx.In(sqlQuery, ids) 36 | if err != nil { 37 | log.Println(err) 38 | } 39 | sqlQuery = sqlx.Rebind(sqlx.DOLLAR, sqlQuery) 40 | rows, err := dal.LogAndQuery(db, sqlQuery, arguments...) 41 | defer rows.Close(); 42 | if err != nil { 43 | log.Println(err) 44 | } 45 | userById := map[int]*api.User{} 46 | 47 | for rows.Next() { 48 | user:= api.User{} 49 | if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil { 50 | errors.DebugPrintf(err) 51 | return nil, []error{errors.InternalServerError} 52 | } 53 | userById[user.ID] = &user 54 | } 55 | 56 | users := make([]*api.User, len(ids)) 57 | for i, id := range ids { 58 | users[i] = userById[id] 59 | i++ 60 | } 61 | 62 | return users, nil 63 | }, 64 | } 65 | ctx := context.WithValue(r.Context(), CtxKey, &userloader) 66 | r = r.WithContext(ctx) 67 | next.ServeHTTP(w, r) 68 | }) 69 | } 70 | 71 | //func DataloaderMiddleware(db *sql.DB, next http.Handler) http.Handler { 72 | // return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 73 | // ctx := r.Context() 74 | // loader := Loaders{} 75 | // 76 | // wait := 1 * time.Millisecond 77 | // 78 | // loader.UserByID = &UserLoader{ 79 | // wait : wait, 80 | // maxBatch: 100, 81 | // fetch: func(ids []int) ([]*api.User, []error) { 82 | // placeholders := make([]string, len(ids)) 83 | // args := make([]interface{}, len(ids)) 84 | // for i := 0; i < len(ids); i++ { 85 | // placeholders[i] = "?" 86 | // args[i] = i 87 | // } 88 | // 89 | // res,err := dal.LogAndQuery(db, "SELECT id, name from user WHERE id IN ("+ 90 | // strings.Join(placeholders, ",")+")", 91 | // args..., 92 | // ) 93 | // defer res.Close() 94 | // 95 | // if err!= nil { 96 | // return nil, nil 97 | // } 98 | // 99 | // users := make([]*api.User, len(ids)) 100 | // i := 0 101 | // for res.Next() { 102 | // users[i] = &api.User{} 103 | // err := res.Scan(&users[i].ID, &users[i].Name) 104 | // if err != nil { 105 | // panic(err) 106 | // } 107 | // i++ 108 | // } 109 | // 110 | // return users, nil 111 | // }, 112 | // } 113 | // ctx = context.WithValue(ctx, CtxKey, loader) 114 | // next.ServeHTTP(w, r.WithContext(ctx)) 115 | // }) 116 | //} 117 | // 118 | //func CtxLoaders(ctx context.Context) Loaders { 119 | // return ctx.Value(CtxKey).(Loaders) 120 | //} -------------------------------------------------------------------------------- /api/dataloaders/userloader_gen.go: -------------------------------------------------------------------------------- 1 | // Code generated by github.com/vektah/dataloaden, DO NOT EDIT. 2 | 3 | package dataloaders 4 | 5 | import ( 6 | "sync" 7 | "time" 8 | 9 | "github.com/ridhamtarpara/go-graphql-demo/api" 10 | ) 11 | 12 | // UserLoaderConfig captures the config to create a new UserLoader 13 | type UserLoaderConfig struct { 14 | // Fetch is a method that provides the data for the loader 15 | Fetch func(keys []int) ([]*api.User, []error) 16 | 17 | // Wait is how long wait before sending a batch 18 | Wait time.Duration 19 | 20 | // MaxBatch will limit the maximum number of keys to send in one batch, 0 = not limit 21 | MaxBatch int 22 | } 23 | 24 | // NewUserLoader creates a new UserLoader given a fetch, wait, and maxBatch 25 | func NewUserLoader(config UserLoaderConfig) *UserLoader { 26 | return &UserLoader{ 27 | fetch: config.Fetch, 28 | wait: config.Wait, 29 | maxBatch: config.MaxBatch, 30 | } 31 | } 32 | 33 | // UserLoader batches and caches requests 34 | type UserLoader struct { 35 | // this method provides the data for the loader 36 | fetch func(keys []int) ([]*api.User, []error) 37 | 38 | // how long to done before sending a batch 39 | wait time.Duration 40 | 41 | // this will limit the maximum number of keys to send in one batch, 0 = no limit 42 | maxBatch int 43 | 44 | // INTERNAL 45 | 46 | // lazily created cache 47 | cache map[int]*api.User 48 | 49 | // the current batch. keys will continue to be collected until timeout is hit, 50 | // then everything will be sent to the fetch method and out to the listeners 51 | batch *userBatch 52 | 53 | // mutex to prevent races 54 | mu sync.Mutex 55 | } 56 | 57 | type userBatch struct { 58 | keys []int 59 | data []*api.User 60 | error []error 61 | closing bool 62 | done chan struct{} 63 | } 64 | 65 | // Load a user by key, batching and caching will be applied automatically 66 | func (l *UserLoader) Load(key int) (*api.User, error) { 67 | return l.LoadThunk(key)() 68 | } 69 | 70 | // LoadThunk returns a function that when called will block waiting for a user. 71 | // This method should be used if you want one goroutine to make requests to many 72 | // different data loaders without blocking until the thunk is called. 73 | func (l *UserLoader) LoadThunk(key int) func() (*api.User, error) { 74 | l.mu.Lock() 75 | if it, ok := l.cache[key]; ok { 76 | l.mu.Unlock() 77 | return func() (*api.User, error) { 78 | return it, nil 79 | } 80 | } 81 | if l.batch == nil { 82 | l.batch = &userBatch{done: make(chan struct{})} 83 | } 84 | batch := l.batch 85 | pos := batch.keyIndex(l, key) 86 | l.mu.Unlock() 87 | 88 | return func() (*api.User, error) { 89 | <-batch.done 90 | 91 | var data *api.User 92 | if pos < len(batch.data) { 93 | data = batch.data[pos] 94 | } 95 | 96 | var err error 97 | // its convenient to be able to return a single error for everything 98 | if len(batch.error) == 1 { 99 | err = batch.error[0] 100 | } else if batch.error != nil { 101 | err = batch.error[pos] 102 | } 103 | 104 | if err == nil { 105 | l.mu.Lock() 106 | l.unsafeSet(key, data) 107 | l.mu.Unlock() 108 | } 109 | 110 | return data, err 111 | } 112 | } 113 | 114 | // LoadAll fetches many keys at once. It will be broken into appropriate sized 115 | // sub batches depending on how the loader is configured 116 | func (l *UserLoader) LoadAll(keys []int) ([]*api.User, []error) { 117 | results := make([]func() (*api.User, error), len(keys)) 118 | 119 | for i, key := range keys { 120 | results[i] = l.LoadThunk(key) 121 | } 122 | 123 | users := make([]*api.User, len(keys)) 124 | errors := make([]error, len(keys)) 125 | for i, thunk := range results { 126 | users[i], errors[i] = thunk() 127 | } 128 | return users, errors 129 | } 130 | 131 | // Prime the cache with the provided key and value. If the key already exists, no change is made 132 | // and false is returned. 133 | // (To forcefully prime the cache, clear the key first with loader.clear(key).prime(key, value).) 134 | func (l *UserLoader) Prime(key int, value *api.User) bool { 135 | l.mu.Lock() 136 | var found bool 137 | if _, found = l.cache[key]; !found { 138 | // make a copy when writing to the cache, its easy to pass a pointer in from a loop var 139 | // and end up with the whole cache pointing to the same value. 140 | cpy := *value 141 | l.unsafeSet(key, &cpy) 142 | } 143 | l.mu.Unlock() 144 | return !found 145 | } 146 | 147 | // Clear the value at key from the cache, if it exists 148 | func (l *UserLoader) Clear(key int) { 149 | l.mu.Lock() 150 | delete(l.cache, key) 151 | l.mu.Unlock() 152 | } 153 | 154 | func (l *UserLoader) unsafeSet(key int, value *api.User) { 155 | if l.cache == nil { 156 | l.cache = map[int]*api.User{} 157 | } 158 | l.cache[key] = value 159 | } 160 | 161 | // keyIndex will return the location of the key in the batch, if its not found 162 | // it will add the key to the batch 163 | func (b *userBatch) keyIndex(l *UserLoader, key int) int { 164 | for i, existingKey := range b.keys { 165 | if key == existingKey { 166 | return i 167 | } 168 | } 169 | 170 | pos := len(b.keys) 171 | b.keys = append(b.keys, key) 172 | if pos == 0 { 173 | go b.startTimer(l) 174 | } 175 | 176 | if l.maxBatch != 0 && pos >= l.maxBatch-1 { 177 | if !b.closing { 178 | b.closing = true 179 | l.batch = nil 180 | go b.end(l) 181 | } 182 | } 183 | 184 | return pos 185 | } 186 | 187 | func (b *userBatch) startTimer(l *UserLoader) { 188 | time.Sleep(l.wait) 189 | l.mu.Lock() 190 | 191 | // we must have hit a batch limit and are already finalizing this batch 192 | if b.closing { 193 | l.mu.Unlock() 194 | return 195 | } 196 | 197 | l.batch = nil 198 | l.mu.Unlock() 199 | 200 | b.end(l) 201 | } 202 | 203 | func (b *userBatch) end(l *UserLoader) { 204 | b.data, b.error = l.fetch(b.keys) 205 | close(b.done) 206 | } 207 | -------------------------------------------------------------------------------- /api/errors/error.go: -------------------------------------------------------------------------------- 1 | package errors 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | "github.com/lib/pq" 7 | "log" 8 | "runtime" 9 | ) 10 | 11 | var ( 12 | ServerError = GenerateError("Something went wrong! Please try again later") 13 | UserNotExist = GenerateError("User not exists") 14 | UnauthorisedError = GenerateError("You are not authorised to perform this action") 15 | TimeStampError = GenerateError("time should be a unix timestamp") 16 | InternalServerError = GenerateError("internal server error") 17 | ) 18 | 19 | func GenerateError(err string) error { 20 | return errors.New(err) 21 | } 22 | func IsForeignKeyError(err error) bool { 23 | pgErr := err.(*pq.Error); 24 | if pgErr.Code == "23503" { 25 | return true 26 | } 27 | return false 28 | } 29 | 30 | func DebugPrintf(err_ error, args ...interface{}) string { 31 | programCounter, file, line, _ := runtime.Caller(1) 32 | fn := runtime.FuncForPC(programCounter) 33 | msg := fmt.Sprintf("[%s: %s %d] %s, %s", file, fn.Name(), line, err_, args) 34 | log.Println(msg) 35 | return msg 36 | } 37 | -------------------------------------------------------------------------------- /api/models.go: -------------------------------------------------------------------------------- 1 | package api 2 | 3 | import ( 4 | "fmt" 5 | "github.com/99designs/gqlgen/graphql" 6 | "github.com/ridhamtarpara/go-graphql-demo/api/errors" 7 | "io" 8 | "strconv" 9 | "time" 10 | ) 11 | 12 | type Review struct { 13 | ID int `json:"id"` 14 | VideoID int `json:"videoId"` 15 | Description string `json:"description"` 16 | Rating int `json:"rating"` 17 | CreatedAt time.Time `json:"createdAt"` 18 | } 19 | 20 | type Screenshot struct { 21 | ID int `json:"id"` 22 | VideoID int `json:"videoId"` 23 | URL string `json:"url"` 24 | } 25 | 26 | type User struct { 27 | ID int `json:"id"` 28 | Name string `json:"name"` 29 | Email string `json:"email"` 30 | } 31 | 32 | type Video struct { 33 | ID int `json:"id"` 34 | Name string `json:"name"` 35 | Description string `json:"description"` 36 | UserID int `json:"-"` 37 | URL string `json:"url"` 38 | CreatedAt time.Time `json:"createdAt"` 39 | } 40 | 41 | // Lets redefine the base ID type to use an id from an external library 42 | func MarshalID(id int) graphql.Marshaler { 43 | return graphql.WriterFunc(func(w io.Writer) { 44 | io.WriteString(w, strconv.Quote(fmt.Sprintf("%d", id))) 45 | }) 46 | } 47 | 48 | // And the same for the unmarshaler 49 | func UnmarshalID(v interface{}) (int, error) { 50 | id, ok := v.(string) 51 | if !ok { 52 | return 0, fmt.Errorf("ids must be strings") 53 | } 54 | i, e := strconv.Atoi(id) 55 | return int(i), e 56 | } 57 | 58 | func MarshalTimestamp(t time.Time) graphql.Marshaler { 59 | timestamp := t.Unix() * 1000 60 | 61 | return graphql.WriterFunc(func(w io.Writer) { 62 | io.WriteString(w, strconv.FormatInt(timestamp, 10)) 63 | }) 64 | } 65 | 66 | func UnmarshalTimestamp(v interface{}) (time.Time, error) { 67 | if tmpStr, ok := v.(int); ok { 68 | return time.Unix(int64(tmpStr), 0), nil 69 | } 70 | return time.Time{}, errors.TimeStampError 71 | } 72 | -------------------------------------------------------------------------------- /generated.go: -------------------------------------------------------------------------------- 1 | // Code generated by github.com/99designs/gqlgen, DO NOT EDIT. 2 | 3 | package go_graphql_demo 4 | 5 | import ( 6 | "bytes" 7 | "context" 8 | "errors" 9 | "strconv" 10 | "sync" 11 | "time" 12 | 13 | "github.com/99designs/gqlgen/graphql" 14 | "github.com/99designs/gqlgen/graphql/introspection" 15 | "github.com/ridhamtarpara/go-graphql-demo/api" 16 | "github.com/vektah/gqlparser" 17 | "github.com/vektah/gqlparser/ast" 18 | ) 19 | 20 | // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface. 21 | func NewExecutableSchema(cfg Config) graphql.ExecutableSchema { 22 | return &executableSchema{ 23 | resolvers: cfg.Resolvers, 24 | directives: cfg.Directives, 25 | complexity: cfg.Complexity, 26 | } 27 | } 28 | 29 | type Config struct { 30 | Resolvers ResolverRoot 31 | Directives DirectiveRoot 32 | Complexity ComplexityRoot 33 | } 34 | 35 | type ResolverRoot interface { 36 | Mutation() MutationResolver 37 | Query() QueryResolver 38 | Review() ReviewResolver 39 | Subscription() SubscriptionResolver 40 | Video() VideoResolver 41 | } 42 | 43 | type DirectiveRoot struct { 44 | IsAuthenticated func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error) 45 | } 46 | 47 | type ComplexityRoot struct { 48 | Mutation struct { 49 | CreateVideo func(childComplexity int, input NewVideo) int 50 | } 51 | 52 | Query struct { 53 | Videos func(childComplexity int, limit *int, offset *int) int 54 | } 55 | 56 | Review struct { 57 | Id func(childComplexity int) int 58 | VideoId func(childComplexity int) int 59 | User func(childComplexity int) int 60 | Description func(childComplexity int) int 61 | Rating func(childComplexity int) int 62 | CreatedAt func(childComplexity int) int 63 | } 64 | 65 | Screenshot struct { 66 | Id func(childComplexity int) int 67 | VideoId func(childComplexity int) int 68 | Url func(childComplexity int) int 69 | } 70 | 71 | Subscription struct { 72 | VideoPublished func(childComplexity int) int 73 | } 74 | 75 | User struct { 76 | Id func(childComplexity int) int 77 | Name func(childComplexity int) int 78 | Email func(childComplexity int) int 79 | } 80 | 81 | Video struct { 82 | Id func(childComplexity int) int 83 | Name func(childComplexity int) int 84 | Description func(childComplexity int) int 85 | User func(childComplexity int) int 86 | Url func(childComplexity int) int 87 | CreatedAt func(childComplexity int) int 88 | Screenshots func(childComplexity int) int 89 | Related func(childComplexity int, limit *int, offset *int) int 90 | } 91 | } 92 | 93 | type MutationResolver interface { 94 | CreateVideo(ctx context.Context, input NewVideo) (api.Video, error) 95 | } 96 | type QueryResolver interface { 97 | Videos(ctx context.Context, limit *int, offset *int) ([]api.Video, error) 98 | } 99 | type ReviewResolver interface { 100 | User(ctx context.Context, obj *api.Review) (api.User, error) 101 | } 102 | type SubscriptionResolver interface { 103 | VideoPublished(ctx context.Context) (<-chan api.Video, error) 104 | } 105 | type VideoResolver interface { 106 | User(ctx context.Context, obj *api.Video) (api.User, error) 107 | 108 | Screenshots(ctx context.Context, obj *api.Video) ([]*api.Screenshot, error) 109 | Related(ctx context.Context, obj *api.Video, limit *int, offset *int) ([]api.Video, error) 110 | } 111 | 112 | func field_Mutation_createVideo_args(rawArgs map[string]interface{}) (map[string]interface{}, error) { 113 | args := map[string]interface{}{} 114 | var arg0 NewVideo 115 | if tmp, ok := rawArgs["input"]; ok { 116 | var err error 117 | arg0, err = UnmarshalNewVideo(tmp) 118 | if err != nil { 119 | return nil, err 120 | } 121 | } 122 | args["input"] = arg0 123 | return args, nil 124 | 125 | } 126 | 127 | func field_Query_Videos_args(rawArgs map[string]interface{}) (map[string]interface{}, error) { 128 | args := map[string]interface{}{} 129 | var arg0 *int 130 | if tmp, ok := rawArgs["limit"]; ok { 131 | var err error 132 | var ptr1 int 133 | if tmp != nil { 134 | ptr1, err = graphql.UnmarshalInt(tmp) 135 | arg0 = &ptr1 136 | } 137 | 138 | if err != nil { 139 | return nil, err 140 | } 141 | } 142 | args["limit"] = arg0 143 | var arg1 *int 144 | if tmp, ok := rawArgs["offset"]; ok { 145 | var err error 146 | var ptr1 int 147 | if tmp != nil { 148 | ptr1, err = graphql.UnmarshalInt(tmp) 149 | arg1 = &ptr1 150 | } 151 | 152 | if err != nil { 153 | return nil, err 154 | } 155 | } 156 | args["offset"] = arg1 157 | return args, nil 158 | 159 | } 160 | 161 | func field_Query___type_args(rawArgs map[string]interface{}) (map[string]interface{}, error) { 162 | args := map[string]interface{}{} 163 | var arg0 string 164 | if tmp, ok := rawArgs["name"]; ok { 165 | var err error 166 | arg0, err = graphql.UnmarshalString(tmp) 167 | if err != nil { 168 | return nil, err 169 | } 170 | } 171 | args["name"] = arg0 172 | return args, nil 173 | 174 | } 175 | 176 | func field_Video_related_args(rawArgs map[string]interface{}) (map[string]interface{}, error) { 177 | args := map[string]interface{}{} 178 | var arg0 *int 179 | if tmp, ok := rawArgs["limit"]; ok { 180 | var err error 181 | var ptr1 int 182 | if tmp != nil { 183 | ptr1, err = graphql.UnmarshalInt(tmp) 184 | arg0 = &ptr1 185 | } 186 | 187 | if err != nil { 188 | return nil, err 189 | } 190 | } 191 | args["limit"] = arg0 192 | var arg1 *int 193 | if tmp, ok := rawArgs["offset"]; ok { 194 | var err error 195 | var ptr1 int 196 | if tmp != nil { 197 | ptr1, err = graphql.UnmarshalInt(tmp) 198 | arg1 = &ptr1 199 | } 200 | 201 | if err != nil { 202 | return nil, err 203 | } 204 | } 205 | args["offset"] = arg1 206 | return args, nil 207 | 208 | } 209 | 210 | func field___Type_fields_args(rawArgs map[string]interface{}) (map[string]interface{}, error) { 211 | args := map[string]interface{}{} 212 | var arg0 bool 213 | if tmp, ok := rawArgs["includeDeprecated"]; ok { 214 | var err error 215 | arg0, err = graphql.UnmarshalBoolean(tmp) 216 | if err != nil { 217 | return nil, err 218 | } 219 | } 220 | args["includeDeprecated"] = arg0 221 | return args, nil 222 | 223 | } 224 | 225 | func field___Type_enumValues_args(rawArgs map[string]interface{}) (map[string]interface{}, error) { 226 | args := map[string]interface{}{} 227 | var arg0 bool 228 | if tmp, ok := rawArgs["includeDeprecated"]; ok { 229 | var err error 230 | arg0, err = graphql.UnmarshalBoolean(tmp) 231 | if err != nil { 232 | return nil, err 233 | } 234 | } 235 | args["includeDeprecated"] = arg0 236 | return args, nil 237 | 238 | } 239 | 240 | type executableSchema struct { 241 | resolvers ResolverRoot 242 | directives DirectiveRoot 243 | complexity ComplexityRoot 244 | } 245 | 246 | func (e *executableSchema) Schema() *ast.Schema { 247 | return parsedSchema 248 | } 249 | 250 | func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) { 251 | switch typeName + "." + field { 252 | 253 | case "Mutation.createVideo": 254 | if e.complexity.Mutation.CreateVideo == nil { 255 | break 256 | } 257 | 258 | args, err := field_Mutation_createVideo_args(rawArgs) 259 | if err != nil { 260 | return 0, false 261 | } 262 | 263 | return e.complexity.Mutation.CreateVideo(childComplexity, args["input"].(NewVideo)), true 264 | 265 | case "Query.Videos": 266 | if e.complexity.Query.Videos == nil { 267 | break 268 | } 269 | 270 | args, err := field_Query_Videos_args(rawArgs) 271 | if err != nil { 272 | return 0, false 273 | } 274 | 275 | return e.complexity.Query.Videos(childComplexity, args["limit"].(*int), args["offset"].(*int)), true 276 | 277 | case "Review.id": 278 | if e.complexity.Review.Id == nil { 279 | break 280 | } 281 | 282 | return e.complexity.Review.Id(childComplexity), true 283 | 284 | case "Review.videoId": 285 | if e.complexity.Review.VideoId == nil { 286 | break 287 | } 288 | 289 | return e.complexity.Review.VideoId(childComplexity), true 290 | 291 | case "Review.user": 292 | if e.complexity.Review.User == nil { 293 | break 294 | } 295 | 296 | return e.complexity.Review.User(childComplexity), true 297 | 298 | case "Review.description": 299 | if e.complexity.Review.Description == nil { 300 | break 301 | } 302 | 303 | return e.complexity.Review.Description(childComplexity), true 304 | 305 | case "Review.rating": 306 | if e.complexity.Review.Rating == nil { 307 | break 308 | } 309 | 310 | return e.complexity.Review.Rating(childComplexity), true 311 | 312 | case "Review.createdAt": 313 | if e.complexity.Review.CreatedAt == nil { 314 | break 315 | } 316 | 317 | return e.complexity.Review.CreatedAt(childComplexity), true 318 | 319 | case "Screenshot.id": 320 | if e.complexity.Screenshot.Id == nil { 321 | break 322 | } 323 | 324 | return e.complexity.Screenshot.Id(childComplexity), true 325 | 326 | case "Screenshot.videoId": 327 | if e.complexity.Screenshot.VideoId == nil { 328 | break 329 | } 330 | 331 | return e.complexity.Screenshot.VideoId(childComplexity), true 332 | 333 | case "Screenshot.url": 334 | if e.complexity.Screenshot.Url == nil { 335 | break 336 | } 337 | 338 | return e.complexity.Screenshot.Url(childComplexity), true 339 | 340 | case "Subscription.videoPublished": 341 | if e.complexity.Subscription.VideoPublished == nil { 342 | break 343 | } 344 | 345 | return e.complexity.Subscription.VideoPublished(childComplexity), true 346 | 347 | case "User.id": 348 | if e.complexity.User.Id == nil { 349 | break 350 | } 351 | 352 | return e.complexity.User.Id(childComplexity), true 353 | 354 | case "User.name": 355 | if e.complexity.User.Name == nil { 356 | break 357 | } 358 | 359 | return e.complexity.User.Name(childComplexity), true 360 | 361 | case "User.email": 362 | if e.complexity.User.Email == nil { 363 | break 364 | } 365 | 366 | return e.complexity.User.Email(childComplexity), true 367 | 368 | case "Video.id": 369 | if e.complexity.Video.Id == nil { 370 | break 371 | } 372 | 373 | return e.complexity.Video.Id(childComplexity), true 374 | 375 | case "Video.name": 376 | if e.complexity.Video.Name == nil { 377 | break 378 | } 379 | 380 | return e.complexity.Video.Name(childComplexity), true 381 | 382 | case "Video.description": 383 | if e.complexity.Video.Description == nil { 384 | break 385 | } 386 | 387 | return e.complexity.Video.Description(childComplexity), true 388 | 389 | case "Video.user": 390 | if e.complexity.Video.User == nil { 391 | break 392 | } 393 | 394 | return e.complexity.Video.User(childComplexity), true 395 | 396 | case "Video.url": 397 | if e.complexity.Video.Url == nil { 398 | break 399 | } 400 | 401 | return e.complexity.Video.Url(childComplexity), true 402 | 403 | case "Video.createdAt": 404 | if e.complexity.Video.CreatedAt == nil { 405 | break 406 | } 407 | 408 | return e.complexity.Video.CreatedAt(childComplexity), true 409 | 410 | case "Video.screenshots": 411 | if e.complexity.Video.Screenshots == nil { 412 | break 413 | } 414 | 415 | return e.complexity.Video.Screenshots(childComplexity), true 416 | 417 | case "Video.related": 418 | if e.complexity.Video.Related == nil { 419 | break 420 | } 421 | 422 | args, err := field_Video_related_args(rawArgs) 423 | if err != nil { 424 | return 0, false 425 | } 426 | 427 | return e.complexity.Video.Related(childComplexity, args["limit"].(*int), args["offset"].(*int)), true 428 | 429 | } 430 | return 0, false 431 | } 432 | 433 | func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response { 434 | ec := executionContext{graphql.GetRequestContext(ctx), e} 435 | 436 | buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte { 437 | data := ec._Query(ctx, op.SelectionSet) 438 | var buf bytes.Buffer 439 | data.MarshalGQL(&buf) 440 | return buf.Bytes() 441 | }) 442 | 443 | return &graphql.Response{ 444 | Data: buf, 445 | Errors: ec.Errors, 446 | Extensions: ec.Extensions} 447 | } 448 | 449 | func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response { 450 | ec := executionContext{graphql.GetRequestContext(ctx), e} 451 | 452 | buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte { 453 | data := ec._Mutation(ctx, op.SelectionSet) 454 | var buf bytes.Buffer 455 | data.MarshalGQL(&buf) 456 | return buf.Bytes() 457 | }) 458 | 459 | return &graphql.Response{ 460 | Data: buf, 461 | Errors: ec.Errors, 462 | Extensions: ec.Extensions, 463 | } 464 | } 465 | 466 | func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response { 467 | ec := executionContext{graphql.GetRequestContext(ctx), e} 468 | 469 | next := ec._Subscription(ctx, op.SelectionSet) 470 | if ec.Errors != nil { 471 | return graphql.OneShot(&graphql.Response{Data: []byte("null"), Errors: ec.Errors}) 472 | } 473 | 474 | var buf bytes.Buffer 475 | return func() *graphql.Response { 476 | buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte { 477 | buf.Reset() 478 | data := next() 479 | 480 | if data == nil { 481 | return nil 482 | } 483 | data.MarshalGQL(&buf) 484 | return buf.Bytes() 485 | }) 486 | 487 | if buf == nil { 488 | return nil 489 | } 490 | 491 | return &graphql.Response{ 492 | Data: buf, 493 | Errors: ec.Errors, 494 | Extensions: ec.Extensions, 495 | } 496 | } 497 | } 498 | 499 | type executionContext struct { 500 | *graphql.RequestContext 501 | *executableSchema 502 | } 503 | 504 | var mutationImplementors = []string{"Mutation"} 505 | 506 | // nolint: gocyclo, errcheck, gas, goconst 507 | func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler { 508 | fields := graphql.CollectFields(ctx, sel, mutationImplementors) 509 | 510 | ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{ 511 | Object: "Mutation", 512 | }) 513 | 514 | out := graphql.NewOrderedMap(len(fields)) 515 | invalid := false 516 | for i, field := range fields { 517 | out.Keys[i] = field.Alias 518 | 519 | switch field.Name { 520 | case "__typename": 521 | out.Values[i] = graphql.MarshalString("Mutation") 522 | case "createVideo": 523 | out.Values[i] = ec._Mutation_createVideo(ctx, field) 524 | if out.Values[i] == graphql.Null { 525 | invalid = true 526 | } 527 | default: 528 | panic("unknown field " + strconv.Quote(field.Name)) 529 | } 530 | } 531 | 532 | if invalid { 533 | return graphql.Null 534 | } 535 | return out 536 | } 537 | 538 | // nolint: vetshadow 539 | func (ec *executionContext) _Mutation_createVideo(ctx context.Context, field graphql.CollectedField) graphql.Marshaler { 540 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 541 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 542 | rawArgs := field.ArgumentMap(ec.Variables) 543 | args, err := field_Mutation_createVideo_args(rawArgs) 544 | if err != nil { 545 | ec.Error(ctx, err) 546 | return graphql.Null 547 | } 548 | rctx := &graphql.ResolverContext{ 549 | Object: "Mutation", 550 | Args: args, 551 | Field: field, 552 | } 553 | ctx = graphql.WithResolverContext(ctx, rctx) 554 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 555 | resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 556 | ctx = rctx // use context from middleware stack in children 557 | return ec.resolvers.Mutation().CreateVideo(rctx, args["input"].(NewVideo)) 558 | }) 559 | if resTmp == nil { 560 | if !ec.HasError(rctx) { 561 | ec.Errorf(ctx, "must not be null") 562 | } 563 | return graphql.Null 564 | } 565 | res := resTmp.(api.Video) 566 | rctx.Result = res 567 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 568 | 569 | return ec._Video(ctx, field.Selections, &res) 570 | } 571 | 572 | var queryImplementors = []string{"Query"} 573 | 574 | // nolint: gocyclo, errcheck, gas, goconst 575 | func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler { 576 | fields := graphql.CollectFields(ctx, sel, queryImplementors) 577 | 578 | ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{ 579 | Object: "Query", 580 | }) 581 | 582 | var wg sync.WaitGroup 583 | out := graphql.NewOrderedMap(len(fields)) 584 | invalid := false 585 | for i, field := range fields { 586 | out.Keys[i] = field.Alias 587 | 588 | switch field.Name { 589 | case "__typename": 590 | out.Values[i] = graphql.MarshalString("Query") 591 | case "Videos": 592 | wg.Add(1) 593 | go func(i int, field graphql.CollectedField) { 594 | out.Values[i] = ec._Query_Videos(ctx, field) 595 | if out.Values[i] == graphql.Null { 596 | invalid = true 597 | } 598 | wg.Done() 599 | }(i, field) 600 | case "__type": 601 | out.Values[i] = ec._Query___type(ctx, field) 602 | case "__schema": 603 | out.Values[i] = ec._Query___schema(ctx, field) 604 | default: 605 | panic("unknown field " + strconv.Quote(field.Name)) 606 | } 607 | } 608 | wg.Wait() 609 | if invalid { 610 | return graphql.Null 611 | } 612 | return out 613 | } 614 | 615 | // nolint: vetshadow 616 | func (ec *executionContext) _Query_Videos(ctx context.Context, field graphql.CollectedField) graphql.Marshaler { 617 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 618 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 619 | rawArgs := field.ArgumentMap(ec.Variables) 620 | args, err := field_Query_Videos_args(rawArgs) 621 | if err != nil { 622 | ec.Error(ctx, err) 623 | return graphql.Null 624 | } 625 | rctx := &graphql.ResolverContext{ 626 | Object: "Query", 627 | Args: args, 628 | Field: field, 629 | } 630 | ctx = graphql.WithResolverContext(ctx, rctx) 631 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 632 | resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 633 | ctx = rctx // use context from middleware stack in children 634 | return ec.resolvers.Query().Videos(rctx, args["limit"].(*int), args["offset"].(*int)) 635 | }) 636 | if resTmp == nil { 637 | if !ec.HasError(rctx) { 638 | ec.Errorf(ctx, "must not be null") 639 | } 640 | return graphql.Null 641 | } 642 | res := resTmp.([]api.Video) 643 | rctx.Result = res 644 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 645 | 646 | arr1 := make(graphql.Array, len(res)) 647 | var wg sync.WaitGroup 648 | 649 | isLen1 := len(res) == 1 650 | if !isLen1 { 651 | wg.Add(len(res)) 652 | } 653 | 654 | for idx1 := range res { 655 | idx1 := idx1 656 | rctx := &graphql.ResolverContext{ 657 | Index: &idx1, 658 | Result: &res[idx1], 659 | } 660 | ctx := graphql.WithResolverContext(ctx, rctx) 661 | f := func(idx1 int) { 662 | if !isLen1 { 663 | defer wg.Done() 664 | } 665 | arr1[idx1] = func() graphql.Marshaler { 666 | 667 | return ec._Video(ctx, field.Selections, &res[idx1]) 668 | }() 669 | } 670 | if isLen1 { 671 | f(idx1) 672 | } else { 673 | go f(idx1) 674 | } 675 | 676 | } 677 | wg.Wait() 678 | return arr1 679 | } 680 | 681 | // nolint: vetshadow 682 | func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler { 683 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 684 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 685 | rawArgs := field.ArgumentMap(ec.Variables) 686 | args, err := field_Query___type_args(rawArgs) 687 | if err != nil { 688 | ec.Error(ctx, err) 689 | return graphql.Null 690 | } 691 | rctx := &graphql.ResolverContext{ 692 | Object: "Query", 693 | Args: args, 694 | Field: field, 695 | } 696 | ctx = graphql.WithResolverContext(ctx, rctx) 697 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 698 | resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 699 | ctx = rctx // use context from middleware stack in children 700 | return ec.introspectType(args["name"].(string)) 701 | }) 702 | if resTmp == nil { 703 | return graphql.Null 704 | } 705 | res := resTmp.(*introspection.Type) 706 | rctx.Result = res 707 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 708 | 709 | if res == nil { 710 | return graphql.Null 711 | } 712 | 713 | return ec.___Type(ctx, field.Selections, res) 714 | } 715 | 716 | // nolint: vetshadow 717 | func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler { 718 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 719 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 720 | rctx := &graphql.ResolverContext{ 721 | Object: "Query", 722 | Args: nil, 723 | Field: field, 724 | } 725 | ctx = graphql.WithResolverContext(ctx, rctx) 726 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 727 | resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 728 | ctx = rctx // use context from middleware stack in children 729 | return ec.introspectSchema() 730 | }) 731 | if resTmp == nil { 732 | return graphql.Null 733 | } 734 | res := resTmp.(*introspection.Schema) 735 | rctx.Result = res 736 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 737 | 738 | if res == nil { 739 | return graphql.Null 740 | } 741 | 742 | return ec.___Schema(ctx, field.Selections, res) 743 | } 744 | 745 | var reviewImplementors = []string{"Review"} 746 | 747 | // nolint: gocyclo, errcheck, gas, goconst 748 | func (ec *executionContext) _Review(ctx context.Context, sel ast.SelectionSet, obj *api.Review) graphql.Marshaler { 749 | fields := graphql.CollectFields(ctx, sel, reviewImplementors) 750 | 751 | var wg sync.WaitGroup 752 | out := graphql.NewOrderedMap(len(fields)) 753 | invalid := false 754 | for i, field := range fields { 755 | out.Keys[i] = field.Alias 756 | 757 | switch field.Name { 758 | case "__typename": 759 | out.Values[i] = graphql.MarshalString("Review") 760 | case "id": 761 | out.Values[i] = ec._Review_id(ctx, field, obj) 762 | if out.Values[i] == graphql.Null { 763 | invalid = true 764 | } 765 | case "videoId": 766 | out.Values[i] = ec._Review_videoId(ctx, field, obj) 767 | if out.Values[i] == graphql.Null { 768 | invalid = true 769 | } 770 | case "user": 771 | wg.Add(1) 772 | go func(i int, field graphql.CollectedField) { 773 | out.Values[i] = ec._Review_user(ctx, field, obj) 774 | if out.Values[i] == graphql.Null { 775 | invalid = true 776 | } 777 | wg.Done() 778 | }(i, field) 779 | case "description": 780 | out.Values[i] = ec._Review_description(ctx, field, obj) 781 | if out.Values[i] == graphql.Null { 782 | invalid = true 783 | } 784 | case "rating": 785 | out.Values[i] = ec._Review_rating(ctx, field, obj) 786 | if out.Values[i] == graphql.Null { 787 | invalid = true 788 | } 789 | case "createdAt": 790 | out.Values[i] = ec._Review_createdAt(ctx, field, obj) 791 | if out.Values[i] == graphql.Null { 792 | invalid = true 793 | } 794 | default: 795 | panic("unknown field " + strconv.Quote(field.Name)) 796 | } 797 | } 798 | wg.Wait() 799 | if invalid { 800 | return graphql.Null 801 | } 802 | return out 803 | } 804 | 805 | // nolint: vetshadow 806 | func (ec *executionContext) _Review_id(ctx context.Context, field graphql.CollectedField, obj *api.Review) graphql.Marshaler { 807 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 808 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 809 | rctx := &graphql.ResolverContext{ 810 | Object: "Review", 811 | Args: nil, 812 | Field: field, 813 | } 814 | ctx = graphql.WithResolverContext(ctx, rctx) 815 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 816 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 817 | ctx = rctx // use context from middleware stack in children 818 | return obj.ID, nil 819 | }) 820 | if resTmp == nil { 821 | if !ec.HasError(rctx) { 822 | ec.Errorf(ctx, "must not be null") 823 | } 824 | return graphql.Null 825 | } 826 | res := resTmp.(int) 827 | rctx.Result = res 828 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 829 | return api.MarshalID(res) 830 | } 831 | 832 | // nolint: vetshadow 833 | func (ec *executionContext) _Review_videoId(ctx context.Context, field graphql.CollectedField, obj *api.Review) graphql.Marshaler { 834 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 835 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 836 | rctx := &graphql.ResolverContext{ 837 | Object: "Review", 838 | Args: nil, 839 | Field: field, 840 | } 841 | ctx = graphql.WithResolverContext(ctx, rctx) 842 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 843 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 844 | ctx = rctx // use context from middleware stack in children 845 | return obj.VideoID, nil 846 | }) 847 | if resTmp == nil { 848 | if !ec.HasError(rctx) { 849 | ec.Errorf(ctx, "must not be null") 850 | } 851 | return graphql.Null 852 | } 853 | res := resTmp.(int) 854 | rctx.Result = res 855 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 856 | return api.MarshalID(res) 857 | } 858 | 859 | // nolint: vetshadow 860 | func (ec *executionContext) _Review_user(ctx context.Context, field graphql.CollectedField, obj *api.Review) graphql.Marshaler { 861 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 862 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 863 | rctx := &graphql.ResolverContext{ 864 | Object: "Review", 865 | Args: nil, 866 | Field: field, 867 | } 868 | ctx = graphql.WithResolverContext(ctx, rctx) 869 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 870 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 871 | ctx = rctx // use context from middleware stack in children 872 | return ec.resolvers.Review().User(rctx, obj) 873 | }) 874 | if resTmp == nil { 875 | if !ec.HasError(rctx) { 876 | ec.Errorf(ctx, "must not be null") 877 | } 878 | return graphql.Null 879 | } 880 | res := resTmp.(api.User) 881 | rctx.Result = res 882 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 883 | 884 | return ec._User(ctx, field.Selections, &res) 885 | } 886 | 887 | // nolint: vetshadow 888 | func (ec *executionContext) _Review_description(ctx context.Context, field graphql.CollectedField, obj *api.Review) graphql.Marshaler { 889 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 890 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 891 | rctx := &graphql.ResolverContext{ 892 | Object: "Review", 893 | Args: nil, 894 | Field: field, 895 | } 896 | ctx = graphql.WithResolverContext(ctx, rctx) 897 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 898 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 899 | ctx = rctx // use context from middleware stack in children 900 | return obj.Description, nil 901 | }) 902 | if resTmp == nil { 903 | if !ec.HasError(rctx) { 904 | ec.Errorf(ctx, "must not be null") 905 | } 906 | return graphql.Null 907 | } 908 | res := resTmp.(string) 909 | rctx.Result = res 910 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 911 | return graphql.MarshalString(res) 912 | } 913 | 914 | // nolint: vetshadow 915 | func (ec *executionContext) _Review_rating(ctx context.Context, field graphql.CollectedField, obj *api.Review) graphql.Marshaler { 916 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 917 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 918 | rctx := &graphql.ResolverContext{ 919 | Object: "Review", 920 | Args: nil, 921 | Field: field, 922 | } 923 | ctx = graphql.WithResolverContext(ctx, rctx) 924 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 925 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 926 | ctx = rctx // use context from middleware stack in children 927 | return obj.Rating, nil 928 | }) 929 | if resTmp == nil { 930 | if !ec.HasError(rctx) { 931 | ec.Errorf(ctx, "must not be null") 932 | } 933 | return graphql.Null 934 | } 935 | res := resTmp.(int) 936 | rctx.Result = res 937 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 938 | return graphql.MarshalInt(res) 939 | } 940 | 941 | // nolint: vetshadow 942 | func (ec *executionContext) _Review_createdAt(ctx context.Context, field graphql.CollectedField, obj *api.Review) graphql.Marshaler { 943 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 944 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 945 | rctx := &graphql.ResolverContext{ 946 | Object: "Review", 947 | Args: nil, 948 | Field: field, 949 | } 950 | ctx = graphql.WithResolverContext(ctx, rctx) 951 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 952 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 953 | ctx = rctx // use context from middleware stack in children 954 | return obj.CreatedAt, nil 955 | }) 956 | if resTmp == nil { 957 | if !ec.HasError(rctx) { 958 | ec.Errorf(ctx, "must not be null") 959 | } 960 | return graphql.Null 961 | } 962 | res := resTmp.(time.Time) 963 | rctx.Result = res 964 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 965 | return api.MarshalTimestamp(res) 966 | } 967 | 968 | var screenshotImplementors = []string{"Screenshot"} 969 | 970 | // nolint: gocyclo, errcheck, gas, goconst 971 | func (ec *executionContext) _Screenshot(ctx context.Context, sel ast.SelectionSet, obj *api.Screenshot) graphql.Marshaler { 972 | fields := graphql.CollectFields(ctx, sel, screenshotImplementors) 973 | 974 | out := graphql.NewOrderedMap(len(fields)) 975 | invalid := false 976 | for i, field := range fields { 977 | out.Keys[i] = field.Alias 978 | 979 | switch field.Name { 980 | case "__typename": 981 | out.Values[i] = graphql.MarshalString("Screenshot") 982 | case "id": 983 | out.Values[i] = ec._Screenshot_id(ctx, field, obj) 984 | if out.Values[i] == graphql.Null { 985 | invalid = true 986 | } 987 | case "videoId": 988 | out.Values[i] = ec._Screenshot_videoId(ctx, field, obj) 989 | if out.Values[i] == graphql.Null { 990 | invalid = true 991 | } 992 | case "url": 993 | out.Values[i] = ec._Screenshot_url(ctx, field, obj) 994 | if out.Values[i] == graphql.Null { 995 | invalid = true 996 | } 997 | default: 998 | panic("unknown field " + strconv.Quote(field.Name)) 999 | } 1000 | } 1001 | 1002 | if invalid { 1003 | return graphql.Null 1004 | } 1005 | return out 1006 | } 1007 | 1008 | // nolint: vetshadow 1009 | func (ec *executionContext) _Screenshot_id(ctx context.Context, field graphql.CollectedField, obj *api.Screenshot) graphql.Marshaler { 1010 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1011 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1012 | rctx := &graphql.ResolverContext{ 1013 | Object: "Screenshot", 1014 | Args: nil, 1015 | Field: field, 1016 | } 1017 | ctx = graphql.WithResolverContext(ctx, rctx) 1018 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1019 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1020 | ctx = rctx // use context from middleware stack in children 1021 | return obj.ID, nil 1022 | }) 1023 | if resTmp == nil { 1024 | if !ec.HasError(rctx) { 1025 | ec.Errorf(ctx, "must not be null") 1026 | } 1027 | return graphql.Null 1028 | } 1029 | res := resTmp.(int) 1030 | rctx.Result = res 1031 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1032 | return api.MarshalID(res) 1033 | } 1034 | 1035 | // nolint: vetshadow 1036 | func (ec *executionContext) _Screenshot_videoId(ctx context.Context, field graphql.CollectedField, obj *api.Screenshot) graphql.Marshaler { 1037 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1038 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1039 | rctx := &graphql.ResolverContext{ 1040 | Object: "Screenshot", 1041 | Args: nil, 1042 | Field: field, 1043 | } 1044 | ctx = graphql.WithResolverContext(ctx, rctx) 1045 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1046 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1047 | ctx = rctx // use context from middleware stack in children 1048 | return obj.VideoID, nil 1049 | }) 1050 | if resTmp == nil { 1051 | if !ec.HasError(rctx) { 1052 | ec.Errorf(ctx, "must not be null") 1053 | } 1054 | return graphql.Null 1055 | } 1056 | res := resTmp.(int) 1057 | rctx.Result = res 1058 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1059 | return api.MarshalID(res) 1060 | } 1061 | 1062 | // nolint: vetshadow 1063 | func (ec *executionContext) _Screenshot_url(ctx context.Context, field graphql.CollectedField, obj *api.Screenshot) graphql.Marshaler { 1064 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1065 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1066 | rctx := &graphql.ResolverContext{ 1067 | Object: "Screenshot", 1068 | Args: nil, 1069 | Field: field, 1070 | } 1071 | ctx = graphql.WithResolverContext(ctx, rctx) 1072 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1073 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1074 | ctx = rctx // use context from middleware stack in children 1075 | return obj.URL, nil 1076 | }) 1077 | if resTmp == nil { 1078 | if !ec.HasError(rctx) { 1079 | ec.Errorf(ctx, "must not be null") 1080 | } 1081 | return graphql.Null 1082 | } 1083 | res := resTmp.(string) 1084 | rctx.Result = res 1085 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1086 | return graphql.MarshalString(res) 1087 | } 1088 | 1089 | var subscriptionImplementors = []string{"Subscription"} 1090 | 1091 | // nolint: gocyclo, errcheck, gas, goconst 1092 | func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func() graphql.Marshaler { 1093 | fields := graphql.CollectFields(ctx, sel, subscriptionImplementors) 1094 | ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{ 1095 | Object: "Subscription", 1096 | }) 1097 | if len(fields) != 1 { 1098 | ec.Errorf(ctx, "must subscribe to exactly one stream") 1099 | return nil 1100 | } 1101 | 1102 | switch fields[0].Name { 1103 | case "videoPublished": 1104 | return ec._Subscription_videoPublished(ctx, fields[0]) 1105 | default: 1106 | panic("unknown field " + strconv.Quote(fields[0].Name)) 1107 | } 1108 | } 1109 | 1110 | func (ec *executionContext) _Subscription_videoPublished(ctx context.Context, field graphql.CollectedField) func() graphql.Marshaler { 1111 | ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{ 1112 | Field: field, 1113 | }) 1114 | // FIXME: subscriptions are missing request middleware stack https://github.com/99designs/gqlgen/issues/259 1115 | // and Tracer stack 1116 | rctx := ctx 1117 | results, err := ec.resolvers.Subscription().VideoPublished(rctx) 1118 | if err != nil { 1119 | ec.Error(ctx, err) 1120 | return nil 1121 | } 1122 | return func() graphql.Marshaler { 1123 | res, ok := <-results 1124 | if !ok { 1125 | return nil 1126 | } 1127 | var out graphql.OrderedMap 1128 | out.Add(field.Alias, func() graphql.Marshaler { 1129 | return ec._Video(ctx, field.Selections, &res) 1130 | }()) 1131 | return &out 1132 | } 1133 | } 1134 | 1135 | var userImplementors = []string{"User"} 1136 | 1137 | // nolint: gocyclo, errcheck, gas, goconst 1138 | func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *api.User) graphql.Marshaler { 1139 | fields := graphql.CollectFields(ctx, sel, userImplementors) 1140 | 1141 | out := graphql.NewOrderedMap(len(fields)) 1142 | invalid := false 1143 | for i, field := range fields { 1144 | out.Keys[i] = field.Alias 1145 | 1146 | switch field.Name { 1147 | case "__typename": 1148 | out.Values[i] = graphql.MarshalString("User") 1149 | case "id": 1150 | out.Values[i] = ec._User_id(ctx, field, obj) 1151 | if out.Values[i] == graphql.Null { 1152 | invalid = true 1153 | } 1154 | case "name": 1155 | out.Values[i] = ec._User_name(ctx, field, obj) 1156 | if out.Values[i] == graphql.Null { 1157 | invalid = true 1158 | } 1159 | case "email": 1160 | out.Values[i] = ec._User_email(ctx, field, obj) 1161 | if out.Values[i] == graphql.Null { 1162 | invalid = true 1163 | } 1164 | default: 1165 | panic("unknown field " + strconv.Quote(field.Name)) 1166 | } 1167 | } 1168 | 1169 | if invalid { 1170 | return graphql.Null 1171 | } 1172 | return out 1173 | } 1174 | 1175 | // nolint: vetshadow 1176 | func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *api.User) graphql.Marshaler { 1177 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1178 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1179 | rctx := &graphql.ResolverContext{ 1180 | Object: "User", 1181 | Args: nil, 1182 | Field: field, 1183 | } 1184 | ctx = graphql.WithResolverContext(ctx, rctx) 1185 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1186 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1187 | ctx = rctx // use context from middleware stack in children 1188 | return obj.ID, nil 1189 | }) 1190 | if resTmp == nil { 1191 | if !ec.HasError(rctx) { 1192 | ec.Errorf(ctx, "must not be null") 1193 | } 1194 | return graphql.Null 1195 | } 1196 | res := resTmp.(int) 1197 | rctx.Result = res 1198 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1199 | return api.MarshalID(res) 1200 | } 1201 | 1202 | // nolint: vetshadow 1203 | func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *api.User) graphql.Marshaler { 1204 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1205 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1206 | rctx := &graphql.ResolverContext{ 1207 | Object: "User", 1208 | Args: nil, 1209 | Field: field, 1210 | } 1211 | ctx = graphql.WithResolverContext(ctx, rctx) 1212 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1213 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1214 | ctx = rctx // use context from middleware stack in children 1215 | return obj.Name, nil 1216 | }) 1217 | if resTmp == nil { 1218 | if !ec.HasError(rctx) { 1219 | ec.Errorf(ctx, "must not be null") 1220 | } 1221 | return graphql.Null 1222 | } 1223 | res := resTmp.(string) 1224 | rctx.Result = res 1225 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1226 | return graphql.MarshalString(res) 1227 | } 1228 | 1229 | // nolint: vetshadow 1230 | func (ec *executionContext) _User_email(ctx context.Context, field graphql.CollectedField, obj *api.User) graphql.Marshaler { 1231 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1232 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1233 | rctx := &graphql.ResolverContext{ 1234 | Object: "User", 1235 | Args: nil, 1236 | Field: field, 1237 | } 1238 | ctx = graphql.WithResolverContext(ctx, rctx) 1239 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1240 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1241 | ctx = rctx // use context from middleware stack in children 1242 | return obj.Email, nil 1243 | }) 1244 | if resTmp == nil { 1245 | if !ec.HasError(rctx) { 1246 | ec.Errorf(ctx, "must not be null") 1247 | } 1248 | return graphql.Null 1249 | } 1250 | res := resTmp.(string) 1251 | rctx.Result = res 1252 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1253 | return graphql.MarshalString(res) 1254 | } 1255 | 1256 | var videoImplementors = []string{"Video"} 1257 | 1258 | // nolint: gocyclo, errcheck, gas, goconst 1259 | func (ec *executionContext) _Video(ctx context.Context, sel ast.SelectionSet, obj *api.Video) graphql.Marshaler { 1260 | fields := graphql.CollectFields(ctx, sel, videoImplementors) 1261 | 1262 | var wg sync.WaitGroup 1263 | out := graphql.NewOrderedMap(len(fields)) 1264 | invalid := false 1265 | for i, field := range fields { 1266 | out.Keys[i] = field.Alias 1267 | 1268 | switch field.Name { 1269 | case "__typename": 1270 | out.Values[i] = graphql.MarshalString("Video") 1271 | case "id": 1272 | out.Values[i] = ec._Video_id(ctx, field, obj) 1273 | if out.Values[i] == graphql.Null { 1274 | invalid = true 1275 | } 1276 | case "name": 1277 | out.Values[i] = ec._Video_name(ctx, field, obj) 1278 | if out.Values[i] == graphql.Null { 1279 | invalid = true 1280 | } 1281 | case "description": 1282 | out.Values[i] = ec._Video_description(ctx, field, obj) 1283 | if out.Values[i] == graphql.Null { 1284 | invalid = true 1285 | } 1286 | case "user": 1287 | wg.Add(1) 1288 | go func(i int, field graphql.CollectedField) { 1289 | out.Values[i] = ec._Video_user(ctx, field, obj) 1290 | if out.Values[i] == graphql.Null { 1291 | invalid = true 1292 | } 1293 | wg.Done() 1294 | }(i, field) 1295 | case "url": 1296 | out.Values[i] = ec._Video_url(ctx, field, obj) 1297 | if out.Values[i] == graphql.Null { 1298 | invalid = true 1299 | } 1300 | case "createdAt": 1301 | out.Values[i] = ec._Video_createdAt(ctx, field, obj) 1302 | if out.Values[i] == graphql.Null { 1303 | invalid = true 1304 | } 1305 | case "screenshots": 1306 | wg.Add(1) 1307 | go func(i int, field graphql.CollectedField) { 1308 | out.Values[i] = ec._Video_screenshots(ctx, field, obj) 1309 | wg.Done() 1310 | }(i, field) 1311 | case "related": 1312 | wg.Add(1) 1313 | go func(i int, field graphql.CollectedField) { 1314 | out.Values[i] = ec._Video_related(ctx, field, obj) 1315 | if out.Values[i] == graphql.Null { 1316 | invalid = true 1317 | } 1318 | wg.Done() 1319 | }(i, field) 1320 | default: 1321 | panic("unknown field " + strconv.Quote(field.Name)) 1322 | } 1323 | } 1324 | wg.Wait() 1325 | if invalid { 1326 | return graphql.Null 1327 | } 1328 | return out 1329 | } 1330 | 1331 | // nolint: vetshadow 1332 | func (ec *executionContext) _Video_id(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1333 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1334 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1335 | rctx := &graphql.ResolverContext{ 1336 | Object: "Video", 1337 | Args: nil, 1338 | Field: field, 1339 | } 1340 | ctx = graphql.WithResolverContext(ctx, rctx) 1341 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1342 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1343 | ctx = rctx // use context from middleware stack in children 1344 | return obj.ID, nil 1345 | }) 1346 | if resTmp == nil { 1347 | if !ec.HasError(rctx) { 1348 | ec.Errorf(ctx, "must not be null") 1349 | } 1350 | return graphql.Null 1351 | } 1352 | res := resTmp.(int) 1353 | rctx.Result = res 1354 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1355 | return api.MarshalID(res) 1356 | } 1357 | 1358 | // nolint: vetshadow 1359 | func (ec *executionContext) _Video_name(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1360 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1361 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1362 | rctx := &graphql.ResolverContext{ 1363 | Object: "Video", 1364 | Args: nil, 1365 | Field: field, 1366 | } 1367 | ctx = graphql.WithResolverContext(ctx, rctx) 1368 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1369 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1370 | ctx = rctx // use context from middleware stack in children 1371 | return obj.Name, nil 1372 | }) 1373 | if resTmp == nil { 1374 | if !ec.HasError(rctx) { 1375 | ec.Errorf(ctx, "must not be null") 1376 | } 1377 | return graphql.Null 1378 | } 1379 | res := resTmp.(string) 1380 | rctx.Result = res 1381 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1382 | return graphql.MarshalString(res) 1383 | } 1384 | 1385 | // nolint: vetshadow 1386 | func (ec *executionContext) _Video_description(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1387 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1388 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1389 | rctx := &graphql.ResolverContext{ 1390 | Object: "Video", 1391 | Args: nil, 1392 | Field: field, 1393 | } 1394 | ctx = graphql.WithResolverContext(ctx, rctx) 1395 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1396 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1397 | ctx = rctx // use context from middleware stack in children 1398 | return obj.Description, nil 1399 | }) 1400 | if resTmp == nil { 1401 | if !ec.HasError(rctx) { 1402 | ec.Errorf(ctx, "must not be null") 1403 | } 1404 | return graphql.Null 1405 | } 1406 | res := resTmp.(string) 1407 | rctx.Result = res 1408 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1409 | return graphql.MarshalString(res) 1410 | } 1411 | 1412 | // nolint: vetshadow 1413 | func (ec *executionContext) _Video_user(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1414 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1415 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1416 | rctx := &graphql.ResolverContext{ 1417 | Object: "Video", 1418 | Args: nil, 1419 | Field: field, 1420 | } 1421 | ctx = graphql.WithResolverContext(ctx, rctx) 1422 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1423 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1424 | ctx = rctx // use context from middleware stack in children 1425 | return ec.resolvers.Video().User(rctx, obj) 1426 | }) 1427 | if resTmp == nil { 1428 | if !ec.HasError(rctx) { 1429 | ec.Errorf(ctx, "must not be null") 1430 | } 1431 | return graphql.Null 1432 | } 1433 | res := resTmp.(api.User) 1434 | rctx.Result = res 1435 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1436 | 1437 | return ec._User(ctx, field.Selections, &res) 1438 | } 1439 | 1440 | // nolint: vetshadow 1441 | func (ec *executionContext) _Video_url(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1442 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1443 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1444 | rctx := &graphql.ResolverContext{ 1445 | Object: "Video", 1446 | Args: nil, 1447 | Field: field, 1448 | } 1449 | ctx = graphql.WithResolverContext(ctx, rctx) 1450 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1451 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1452 | ctx = rctx // use context from middleware stack in children 1453 | return obj.URL, nil 1454 | }) 1455 | if resTmp == nil { 1456 | if !ec.HasError(rctx) { 1457 | ec.Errorf(ctx, "must not be null") 1458 | } 1459 | return graphql.Null 1460 | } 1461 | res := resTmp.(string) 1462 | rctx.Result = res 1463 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1464 | return graphql.MarshalString(res) 1465 | } 1466 | 1467 | // nolint: vetshadow 1468 | func (ec *executionContext) _Video_createdAt(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1469 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1470 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1471 | rctx := &graphql.ResolverContext{ 1472 | Object: "Video", 1473 | Args: nil, 1474 | Field: field, 1475 | } 1476 | ctx = graphql.WithResolverContext(ctx, rctx) 1477 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1478 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1479 | ctx = rctx // use context from middleware stack in children 1480 | return obj.CreatedAt, nil 1481 | }) 1482 | if resTmp == nil { 1483 | if !ec.HasError(rctx) { 1484 | ec.Errorf(ctx, "must not be null") 1485 | } 1486 | return graphql.Null 1487 | } 1488 | res := resTmp.(time.Time) 1489 | rctx.Result = res 1490 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1491 | return api.MarshalTimestamp(res) 1492 | } 1493 | 1494 | // nolint: vetshadow 1495 | func (ec *executionContext) _Video_screenshots(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1496 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1497 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1498 | rctx := &graphql.ResolverContext{ 1499 | Object: "Video", 1500 | Args: nil, 1501 | Field: field, 1502 | } 1503 | ctx = graphql.WithResolverContext(ctx, rctx) 1504 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1505 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1506 | ctx = rctx // use context from middleware stack in children 1507 | return ec.resolvers.Video().Screenshots(rctx, obj) 1508 | }) 1509 | if resTmp == nil { 1510 | return graphql.Null 1511 | } 1512 | res := resTmp.([]*api.Screenshot) 1513 | rctx.Result = res 1514 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1515 | 1516 | arr1 := make(graphql.Array, len(res)) 1517 | var wg sync.WaitGroup 1518 | 1519 | isLen1 := len(res) == 1 1520 | if !isLen1 { 1521 | wg.Add(len(res)) 1522 | } 1523 | 1524 | for idx1 := range res { 1525 | idx1 := idx1 1526 | rctx := &graphql.ResolverContext{ 1527 | Index: &idx1, 1528 | Result: res[idx1], 1529 | } 1530 | ctx := graphql.WithResolverContext(ctx, rctx) 1531 | f := func(idx1 int) { 1532 | if !isLen1 { 1533 | defer wg.Done() 1534 | } 1535 | arr1[idx1] = func() graphql.Marshaler { 1536 | 1537 | if res[idx1] == nil { 1538 | return graphql.Null 1539 | } 1540 | 1541 | return ec._Screenshot(ctx, field.Selections, res[idx1]) 1542 | }() 1543 | } 1544 | if isLen1 { 1545 | f(idx1) 1546 | } else { 1547 | go f(idx1) 1548 | } 1549 | 1550 | } 1551 | wg.Wait() 1552 | return arr1 1553 | } 1554 | 1555 | // nolint: vetshadow 1556 | func (ec *executionContext) _Video_related(ctx context.Context, field graphql.CollectedField, obj *api.Video) graphql.Marshaler { 1557 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1558 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1559 | rawArgs := field.ArgumentMap(ec.Variables) 1560 | args, err := field_Video_related_args(rawArgs) 1561 | if err != nil { 1562 | ec.Error(ctx, err) 1563 | return graphql.Null 1564 | } 1565 | rctx := &graphql.ResolverContext{ 1566 | Object: "Video", 1567 | Args: args, 1568 | Field: field, 1569 | } 1570 | ctx = graphql.WithResolverContext(ctx, rctx) 1571 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1572 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1573 | ctx = rctx // use context from middleware stack in children 1574 | return ec.resolvers.Video().Related(rctx, obj, args["limit"].(*int), args["offset"].(*int)) 1575 | }) 1576 | if resTmp == nil { 1577 | if !ec.HasError(rctx) { 1578 | ec.Errorf(ctx, "must not be null") 1579 | } 1580 | return graphql.Null 1581 | } 1582 | res := resTmp.([]api.Video) 1583 | rctx.Result = res 1584 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1585 | 1586 | arr1 := make(graphql.Array, len(res)) 1587 | var wg sync.WaitGroup 1588 | 1589 | isLen1 := len(res) == 1 1590 | if !isLen1 { 1591 | wg.Add(len(res)) 1592 | } 1593 | 1594 | for idx1 := range res { 1595 | idx1 := idx1 1596 | rctx := &graphql.ResolverContext{ 1597 | Index: &idx1, 1598 | Result: &res[idx1], 1599 | } 1600 | ctx := graphql.WithResolverContext(ctx, rctx) 1601 | f := func(idx1 int) { 1602 | if !isLen1 { 1603 | defer wg.Done() 1604 | } 1605 | arr1[idx1] = func() graphql.Marshaler { 1606 | 1607 | return ec._Video(ctx, field.Selections, &res[idx1]) 1608 | }() 1609 | } 1610 | if isLen1 { 1611 | f(idx1) 1612 | } else { 1613 | go f(idx1) 1614 | } 1615 | 1616 | } 1617 | wg.Wait() 1618 | return arr1 1619 | } 1620 | 1621 | var __DirectiveImplementors = []string{"__Directive"} 1622 | 1623 | // nolint: gocyclo, errcheck, gas, goconst 1624 | func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler { 1625 | fields := graphql.CollectFields(ctx, sel, __DirectiveImplementors) 1626 | 1627 | out := graphql.NewOrderedMap(len(fields)) 1628 | invalid := false 1629 | for i, field := range fields { 1630 | out.Keys[i] = field.Alias 1631 | 1632 | switch field.Name { 1633 | case "__typename": 1634 | out.Values[i] = graphql.MarshalString("__Directive") 1635 | case "name": 1636 | out.Values[i] = ec.___Directive_name(ctx, field, obj) 1637 | if out.Values[i] == graphql.Null { 1638 | invalid = true 1639 | } 1640 | case "description": 1641 | out.Values[i] = ec.___Directive_description(ctx, field, obj) 1642 | case "locations": 1643 | out.Values[i] = ec.___Directive_locations(ctx, field, obj) 1644 | if out.Values[i] == graphql.Null { 1645 | invalid = true 1646 | } 1647 | case "args": 1648 | out.Values[i] = ec.___Directive_args(ctx, field, obj) 1649 | if out.Values[i] == graphql.Null { 1650 | invalid = true 1651 | } 1652 | default: 1653 | panic("unknown field " + strconv.Quote(field.Name)) 1654 | } 1655 | } 1656 | 1657 | if invalid { 1658 | return graphql.Null 1659 | } 1660 | return out 1661 | } 1662 | 1663 | // nolint: vetshadow 1664 | func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler { 1665 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1666 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1667 | rctx := &graphql.ResolverContext{ 1668 | Object: "__Directive", 1669 | Args: nil, 1670 | Field: field, 1671 | } 1672 | ctx = graphql.WithResolverContext(ctx, rctx) 1673 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1674 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1675 | ctx = rctx // use context from middleware stack in children 1676 | return obj.Name, nil 1677 | }) 1678 | if resTmp == nil { 1679 | if !ec.HasError(rctx) { 1680 | ec.Errorf(ctx, "must not be null") 1681 | } 1682 | return graphql.Null 1683 | } 1684 | res := resTmp.(string) 1685 | rctx.Result = res 1686 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1687 | return graphql.MarshalString(res) 1688 | } 1689 | 1690 | // nolint: vetshadow 1691 | func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler { 1692 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1693 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1694 | rctx := &graphql.ResolverContext{ 1695 | Object: "__Directive", 1696 | Args: nil, 1697 | Field: field, 1698 | } 1699 | ctx = graphql.WithResolverContext(ctx, rctx) 1700 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1701 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1702 | ctx = rctx // use context from middleware stack in children 1703 | return obj.Description, nil 1704 | }) 1705 | if resTmp == nil { 1706 | return graphql.Null 1707 | } 1708 | res := resTmp.(string) 1709 | rctx.Result = res 1710 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1711 | return graphql.MarshalString(res) 1712 | } 1713 | 1714 | // nolint: vetshadow 1715 | func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler { 1716 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1717 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1718 | rctx := &graphql.ResolverContext{ 1719 | Object: "__Directive", 1720 | Args: nil, 1721 | Field: field, 1722 | } 1723 | ctx = graphql.WithResolverContext(ctx, rctx) 1724 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1725 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1726 | ctx = rctx // use context from middleware stack in children 1727 | return obj.Locations, nil 1728 | }) 1729 | if resTmp == nil { 1730 | if !ec.HasError(rctx) { 1731 | ec.Errorf(ctx, "must not be null") 1732 | } 1733 | return graphql.Null 1734 | } 1735 | res := resTmp.([]string) 1736 | rctx.Result = res 1737 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1738 | 1739 | arr1 := make(graphql.Array, len(res)) 1740 | 1741 | for idx1 := range res { 1742 | arr1[idx1] = func() graphql.Marshaler { 1743 | return graphql.MarshalString(res[idx1]) 1744 | }() 1745 | } 1746 | 1747 | return arr1 1748 | } 1749 | 1750 | // nolint: vetshadow 1751 | func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler { 1752 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1753 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1754 | rctx := &graphql.ResolverContext{ 1755 | Object: "__Directive", 1756 | Args: nil, 1757 | Field: field, 1758 | } 1759 | ctx = graphql.WithResolverContext(ctx, rctx) 1760 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1761 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1762 | ctx = rctx // use context from middleware stack in children 1763 | return obj.Args, nil 1764 | }) 1765 | if resTmp == nil { 1766 | if !ec.HasError(rctx) { 1767 | ec.Errorf(ctx, "must not be null") 1768 | } 1769 | return graphql.Null 1770 | } 1771 | res := resTmp.([]introspection.InputValue) 1772 | rctx.Result = res 1773 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1774 | 1775 | arr1 := make(graphql.Array, len(res)) 1776 | var wg sync.WaitGroup 1777 | 1778 | isLen1 := len(res) == 1 1779 | if !isLen1 { 1780 | wg.Add(len(res)) 1781 | } 1782 | 1783 | for idx1 := range res { 1784 | idx1 := idx1 1785 | rctx := &graphql.ResolverContext{ 1786 | Index: &idx1, 1787 | Result: &res[idx1], 1788 | } 1789 | ctx := graphql.WithResolverContext(ctx, rctx) 1790 | f := func(idx1 int) { 1791 | if !isLen1 { 1792 | defer wg.Done() 1793 | } 1794 | arr1[idx1] = func() graphql.Marshaler { 1795 | 1796 | return ec.___InputValue(ctx, field.Selections, &res[idx1]) 1797 | }() 1798 | } 1799 | if isLen1 { 1800 | f(idx1) 1801 | } else { 1802 | go f(idx1) 1803 | } 1804 | 1805 | } 1806 | wg.Wait() 1807 | return arr1 1808 | } 1809 | 1810 | var __EnumValueImplementors = []string{"__EnumValue"} 1811 | 1812 | // nolint: gocyclo, errcheck, gas, goconst 1813 | func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler { 1814 | fields := graphql.CollectFields(ctx, sel, __EnumValueImplementors) 1815 | 1816 | out := graphql.NewOrderedMap(len(fields)) 1817 | invalid := false 1818 | for i, field := range fields { 1819 | out.Keys[i] = field.Alias 1820 | 1821 | switch field.Name { 1822 | case "__typename": 1823 | out.Values[i] = graphql.MarshalString("__EnumValue") 1824 | case "name": 1825 | out.Values[i] = ec.___EnumValue_name(ctx, field, obj) 1826 | if out.Values[i] == graphql.Null { 1827 | invalid = true 1828 | } 1829 | case "description": 1830 | out.Values[i] = ec.___EnumValue_description(ctx, field, obj) 1831 | case "isDeprecated": 1832 | out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj) 1833 | if out.Values[i] == graphql.Null { 1834 | invalid = true 1835 | } 1836 | case "deprecationReason": 1837 | out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj) 1838 | default: 1839 | panic("unknown field " + strconv.Quote(field.Name)) 1840 | } 1841 | } 1842 | 1843 | if invalid { 1844 | return graphql.Null 1845 | } 1846 | return out 1847 | } 1848 | 1849 | // nolint: vetshadow 1850 | func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler { 1851 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1852 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1853 | rctx := &graphql.ResolverContext{ 1854 | Object: "__EnumValue", 1855 | Args: nil, 1856 | Field: field, 1857 | } 1858 | ctx = graphql.WithResolverContext(ctx, rctx) 1859 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1860 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1861 | ctx = rctx // use context from middleware stack in children 1862 | return obj.Name, nil 1863 | }) 1864 | if resTmp == nil { 1865 | if !ec.HasError(rctx) { 1866 | ec.Errorf(ctx, "must not be null") 1867 | } 1868 | return graphql.Null 1869 | } 1870 | res := resTmp.(string) 1871 | rctx.Result = res 1872 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1873 | return graphql.MarshalString(res) 1874 | } 1875 | 1876 | // nolint: vetshadow 1877 | func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler { 1878 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1879 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1880 | rctx := &graphql.ResolverContext{ 1881 | Object: "__EnumValue", 1882 | Args: nil, 1883 | Field: field, 1884 | } 1885 | ctx = graphql.WithResolverContext(ctx, rctx) 1886 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1887 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1888 | ctx = rctx // use context from middleware stack in children 1889 | return obj.Description, nil 1890 | }) 1891 | if resTmp == nil { 1892 | return graphql.Null 1893 | } 1894 | res := resTmp.(string) 1895 | rctx.Result = res 1896 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1897 | return graphql.MarshalString(res) 1898 | } 1899 | 1900 | // nolint: vetshadow 1901 | func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler { 1902 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1903 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1904 | rctx := &graphql.ResolverContext{ 1905 | Object: "__EnumValue", 1906 | Args: nil, 1907 | Field: field, 1908 | } 1909 | ctx = graphql.WithResolverContext(ctx, rctx) 1910 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1911 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1912 | ctx = rctx // use context from middleware stack in children 1913 | return obj.IsDeprecated(), nil 1914 | }) 1915 | if resTmp == nil { 1916 | if !ec.HasError(rctx) { 1917 | ec.Errorf(ctx, "must not be null") 1918 | } 1919 | return graphql.Null 1920 | } 1921 | res := resTmp.(bool) 1922 | rctx.Result = res 1923 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1924 | return graphql.MarshalBoolean(res) 1925 | } 1926 | 1927 | // nolint: vetshadow 1928 | func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler { 1929 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 1930 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 1931 | rctx := &graphql.ResolverContext{ 1932 | Object: "__EnumValue", 1933 | Args: nil, 1934 | Field: field, 1935 | } 1936 | ctx = graphql.WithResolverContext(ctx, rctx) 1937 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 1938 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1939 | ctx = rctx // use context from middleware stack in children 1940 | return obj.DeprecationReason(), nil 1941 | }) 1942 | if resTmp == nil { 1943 | return graphql.Null 1944 | } 1945 | res := resTmp.(*string) 1946 | rctx.Result = res 1947 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 1948 | 1949 | if res == nil { 1950 | return graphql.Null 1951 | } 1952 | return graphql.MarshalString(*res) 1953 | } 1954 | 1955 | var __FieldImplementors = []string{"__Field"} 1956 | 1957 | // nolint: gocyclo, errcheck, gas, goconst 1958 | func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler { 1959 | fields := graphql.CollectFields(ctx, sel, __FieldImplementors) 1960 | 1961 | out := graphql.NewOrderedMap(len(fields)) 1962 | invalid := false 1963 | for i, field := range fields { 1964 | out.Keys[i] = field.Alias 1965 | 1966 | switch field.Name { 1967 | case "__typename": 1968 | out.Values[i] = graphql.MarshalString("__Field") 1969 | case "name": 1970 | out.Values[i] = ec.___Field_name(ctx, field, obj) 1971 | if out.Values[i] == graphql.Null { 1972 | invalid = true 1973 | } 1974 | case "description": 1975 | out.Values[i] = ec.___Field_description(ctx, field, obj) 1976 | case "args": 1977 | out.Values[i] = ec.___Field_args(ctx, field, obj) 1978 | if out.Values[i] == graphql.Null { 1979 | invalid = true 1980 | } 1981 | case "type": 1982 | out.Values[i] = ec.___Field_type(ctx, field, obj) 1983 | if out.Values[i] == graphql.Null { 1984 | invalid = true 1985 | } 1986 | case "isDeprecated": 1987 | out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj) 1988 | if out.Values[i] == graphql.Null { 1989 | invalid = true 1990 | } 1991 | case "deprecationReason": 1992 | out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj) 1993 | default: 1994 | panic("unknown field " + strconv.Quote(field.Name)) 1995 | } 1996 | } 1997 | 1998 | if invalid { 1999 | return graphql.Null 2000 | } 2001 | return out 2002 | } 2003 | 2004 | // nolint: vetshadow 2005 | func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler { 2006 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2007 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2008 | rctx := &graphql.ResolverContext{ 2009 | Object: "__Field", 2010 | Args: nil, 2011 | Field: field, 2012 | } 2013 | ctx = graphql.WithResolverContext(ctx, rctx) 2014 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2015 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2016 | ctx = rctx // use context from middleware stack in children 2017 | return obj.Name, nil 2018 | }) 2019 | if resTmp == nil { 2020 | if !ec.HasError(rctx) { 2021 | ec.Errorf(ctx, "must not be null") 2022 | } 2023 | return graphql.Null 2024 | } 2025 | res := resTmp.(string) 2026 | rctx.Result = res 2027 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2028 | return graphql.MarshalString(res) 2029 | } 2030 | 2031 | // nolint: vetshadow 2032 | func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler { 2033 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2034 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2035 | rctx := &graphql.ResolverContext{ 2036 | Object: "__Field", 2037 | Args: nil, 2038 | Field: field, 2039 | } 2040 | ctx = graphql.WithResolverContext(ctx, rctx) 2041 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2042 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2043 | ctx = rctx // use context from middleware stack in children 2044 | return obj.Description, nil 2045 | }) 2046 | if resTmp == nil { 2047 | return graphql.Null 2048 | } 2049 | res := resTmp.(string) 2050 | rctx.Result = res 2051 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2052 | return graphql.MarshalString(res) 2053 | } 2054 | 2055 | // nolint: vetshadow 2056 | func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler { 2057 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2058 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2059 | rctx := &graphql.ResolverContext{ 2060 | Object: "__Field", 2061 | Args: nil, 2062 | Field: field, 2063 | } 2064 | ctx = graphql.WithResolverContext(ctx, rctx) 2065 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2066 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2067 | ctx = rctx // use context from middleware stack in children 2068 | return obj.Args, nil 2069 | }) 2070 | if resTmp == nil { 2071 | if !ec.HasError(rctx) { 2072 | ec.Errorf(ctx, "must not be null") 2073 | } 2074 | return graphql.Null 2075 | } 2076 | res := resTmp.([]introspection.InputValue) 2077 | rctx.Result = res 2078 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2079 | 2080 | arr1 := make(graphql.Array, len(res)) 2081 | var wg sync.WaitGroup 2082 | 2083 | isLen1 := len(res) == 1 2084 | if !isLen1 { 2085 | wg.Add(len(res)) 2086 | } 2087 | 2088 | for idx1 := range res { 2089 | idx1 := idx1 2090 | rctx := &graphql.ResolverContext{ 2091 | Index: &idx1, 2092 | Result: &res[idx1], 2093 | } 2094 | ctx := graphql.WithResolverContext(ctx, rctx) 2095 | f := func(idx1 int) { 2096 | if !isLen1 { 2097 | defer wg.Done() 2098 | } 2099 | arr1[idx1] = func() graphql.Marshaler { 2100 | 2101 | return ec.___InputValue(ctx, field.Selections, &res[idx1]) 2102 | }() 2103 | } 2104 | if isLen1 { 2105 | f(idx1) 2106 | } else { 2107 | go f(idx1) 2108 | } 2109 | 2110 | } 2111 | wg.Wait() 2112 | return arr1 2113 | } 2114 | 2115 | // nolint: vetshadow 2116 | func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler { 2117 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2118 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2119 | rctx := &graphql.ResolverContext{ 2120 | Object: "__Field", 2121 | Args: nil, 2122 | Field: field, 2123 | } 2124 | ctx = graphql.WithResolverContext(ctx, rctx) 2125 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2126 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2127 | ctx = rctx // use context from middleware stack in children 2128 | return obj.Type, nil 2129 | }) 2130 | if resTmp == nil { 2131 | if !ec.HasError(rctx) { 2132 | ec.Errorf(ctx, "must not be null") 2133 | } 2134 | return graphql.Null 2135 | } 2136 | res := resTmp.(*introspection.Type) 2137 | rctx.Result = res 2138 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2139 | 2140 | if res == nil { 2141 | if !ec.HasError(rctx) { 2142 | ec.Errorf(ctx, "must not be null") 2143 | } 2144 | return graphql.Null 2145 | } 2146 | 2147 | return ec.___Type(ctx, field.Selections, res) 2148 | } 2149 | 2150 | // nolint: vetshadow 2151 | func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler { 2152 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2153 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2154 | rctx := &graphql.ResolverContext{ 2155 | Object: "__Field", 2156 | Args: nil, 2157 | Field: field, 2158 | } 2159 | ctx = graphql.WithResolverContext(ctx, rctx) 2160 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2161 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2162 | ctx = rctx // use context from middleware stack in children 2163 | return obj.IsDeprecated(), nil 2164 | }) 2165 | if resTmp == nil { 2166 | if !ec.HasError(rctx) { 2167 | ec.Errorf(ctx, "must not be null") 2168 | } 2169 | return graphql.Null 2170 | } 2171 | res := resTmp.(bool) 2172 | rctx.Result = res 2173 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2174 | return graphql.MarshalBoolean(res) 2175 | } 2176 | 2177 | // nolint: vetshadow 2178 | func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler { 2179 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2180 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2181 | rctx := &graphql.ResolverContext{ 2182 | Object: "__Field", 2183 | Args: nil, 2184 | Field: field, 2185 | } 2186 | ctx = graphql.WithResolverContext(ctx, rctx) 2187 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2188 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2189 | ctx = rctx // use context from middleware stack in children 2190 | return obj.DeprecationReason(), nil 2191 | }) 2192 | if resTmp == nil { 2193 | return graphql.Null 2194 | } 2195 | res := resTmp.(*string) 2196 | rctx.Result = res 2197 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2198 | 2199 | if res == nil { 2200 | return graphql.Null 2201 | } 2202 | return graphql.MarshalString(*res) 2203 | } 2204 | 2205 | var __InputValueImplementors = []string{"__InputValue"} 2206 | 2207 | // nolint: gocyclo, errcheck, gas, goconst 2208 | func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler { 2209 | fields := graphql.CollectFields(ctx, sel, __InputValueImplementors) 2210 | 2211 | out := graphql.NewOrderedMap(len(fields)) 2212 | invalid := false 2213 | for i, field := range fields { 2214 | out.Keys[i] = field.Alias 2215 | 2216 | switch field.Name { 2217 | case "__typename": 2218 | out.Values[i] = graphql.MarshalString("__InputValue") 2219 | case "name": 2220 | out.Values[i] = ec.___InputValue_name(ctx, field, obj) 2221 | if out.Values[i] == graphql.Null { 2222 | invalid = true 2223 | } 2224 | case "description": 2225 | out.Values[i] = ec.___InputValue_description(ctx, field, obj) 2226 | case "type": 2227 | out.Values[i] = ec.___InputValue_type(ctx, field, obj) 2228 | if out.Values[i] == graphql.Null { 2229 | invalid = true 2230 | } 2231 | case "defaultValue": 2232 | out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj) 2233 | default: 2234 | panic("unknown field " + strconv.Quote(field.Name)) 2235 | } 2236 | } 2237 | 2238 | if invalid { 2239 | return graphql.Null 2240 | } 2241 | return out 2242 | } 2243 | 2244 | // nolint: vetshadow 2245 | func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler { 2246 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2247 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2248 | rctx := &graphql.ResolverContext{ 2249 | Object: "__InputValue", 2250 | Args: nil, 2251 | Field: field, 2252 | } 2253 | ctx = graphql.WithResolverContext(ctx, rctx) 2254 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2255 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2256 | ctx = rctx // use context from middleware stack in children 2257 | return obj.Name, nil 2258 | }) 2259 | if resTmp == nil { 2260 | if !ec.HasError(rctx) { 2261 | ec.Errorf(ctx, "must not be null") 2262 | } 2263 | return graphql.Null 2264 | } 2265 | res := resTmp.(string) 2266 | rctx.Result = res 2267 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2268 | return graphql.MarshalString(res) 2269 | } 2270 | 2271 | // nolint: vetshadow 2272 | func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler { 2273 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2274 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2275 | rctx := &graphql.ResolverContext{ 2276 | Object: "__InputValue", 2277 | Args: nil, 2278 | Field: field, 2279 | } 2280 | ctx = graphql.WithResolverContext(ctx, rctx) 2281 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2282 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2283 | ctx = rctx // use context from middleware stack in children 2284 | return obj.Description, nil 2285 | }) 2286 | if resTmp == nil { 2287 | return graphql.Null 2288 | } 2289 | res := resTmp.(string) 2290 | rctx.Result = res 2291 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2292 | return graphql.MarshalString(res) 2293 | } 2294 | 2295 | // nolint: vetshadow 2296 | func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler { 2297 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2298 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2299 | rctx := &graphql.ResolverContext{ 2300 | Object: "__InputValue", 2301 | Args: nil, 2302 | Field: field, 2303 | } 2304 | ctx = graphql.WithResolverContext(ctx, rctx) 2305 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2306 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2307 | ctx = rctx // use context from middleware stack in children 2308 | return obj.Type, nil 2309 | }) 2310 | if resTmp == nil { 2311 | if !ec.HasError(rctx) { 2312 | ec.Errorf(ctx, "must not be null") 2313 | } 2314 | return graphql.Null 2315 | } 2316 | res := resTmp.(*introspection.Type) 2317 | rctx.Result = res 2318 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2319 | 2320 | if res == nil { 2321 | if !ec.HasError(rctx) { 2322 | ec.Errorf(ctx, "must not be null") 2323 | } 2324 | return graphql.Null 2325 | } 2326 | 2327 | return ec.___Type(ctx, field.Selections, res) 2328 | } 2329 | 2330 | // nolint: vetshadow 2331 | func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler { 2332 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2333 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2334 | rctx := &graphql.ResolverContext{ 2335 | Object: "__InputValue", 2336 | Args: nil, 2337 | Field: field, 2338 | } 2339 | ctx = graphql.WithResolverContext(ctx, rctx) 2340 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2341 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2342 | ctx = rctx // use context from middleware stack in children 2343 | return obj.DefaultValue, nil 2344 | }) 2345 | if resTmp == nil { 2346 | return graphql.Null 2347 | } 2348 | res := resTmp.(*string) 2349 | rctx.Result = res 2350 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2351 | 2352 | if res == nil { 2353 | return graphql.Null 2354 | } 2355 | return graphql.MarshalString(*res) 2356 | } 2357 | 2358 | var __SchemaImplementors = []string{"__Schema"} 2359 | 2360 | // nolint: gocyclo, errcheck, gas, goconst 2361 | func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler { 2362 | fields := graphql.CollectFields(ctx, sel, __SchemaImplementors) 2363 | 2364 | out := graphql.NewOrderedMap(len(fields)) 2365 | invalid := false 2366 | for i, field := range fields { 2367 | out.Keys[i] = field.Alias 2368 | 2369 | switch field.Name { 2370 | case "__typename": 2371 | out.Values[i] = graphql.MarshalString("__Schema") 2372 | case "types": 2373 | out.Values[i] = ec.___Schema_types(ctx, field, obj) 2374 | if out.Values[i] == graphql.Null { 2375 | invalid = true 2376 | } 2377 | case "queryType": 2378 | out.Values[i] = ec.___Schema_queryType(ctx, field, obj) 2379 | if out.Values[i] == graphql.Null { 2380 | invalid = true 2381 | } 2382 | case "mutationType": 2383 | out.Values[i] = ec.___Schema_mutationType(ctx, field, obj) 2384 | case "subscriptionType": 2385 | out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj) 2386 | case "directives": 2387 | out.Values[i] = ec.___Schema_directives(ctx, field, obj) 2388 | if out.Values[i] == graphql.Null { 2389 | invalid = true 2390 | } 2391 | default: 2392 | panic("unknown field " + strconv.Quote(field.Name)) 2393 | } 2394 | } 2395 | 2396 | if invalid { 2397 | return graphql.Null 2398 | } 2399 | return out 2400 | } 2401 | 2402 | // nolint: vetshadow 2403 | func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler { 2404 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2405 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2406 | rctx := &graphql.ResolverContext{ 2407 | Object: "__Schema", 2408 | Args: nil, 2409 | Field: field, 2410 | } 2411 | ctx = graphql.WithResolverContext(ctx, rctx) 2412 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2413 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2414 | ctx = rctx // use context from middleware stack in children 2415 | return obj.Types(), nil 2416 | }) 2417 | if resTmp == nil { 2418 | if !ec.HasError(rctx) { 2419 | ec.Errorf(ctx, "must not be null") 2420 | } 2421 | return graphql.Null 2422 | } 2423 | res := resTmp.([]introspection.Type) 2424 | rctx.Result = res 2425 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2426 | 2427 | arr1 := make(graphql.Array, len(res)) 2428 | var wg sync.WaitGroup 2429 | 2430 | isLen1 := len(res) == 1 2431 | if !isLen1 { 2432 | wg.Add(len(res)) 2433 | } 2434 | 2435 | for idx1 := range res { 2436 | idx1 := idx1 2437 | rctx := &graphql.ResolverContext{ 2438 | Index: &idx1, 2439 | Result: &res[idx1], 2440 | } 2441 | ctx := graphql.WithResolverContext(ctx, rctx) 2442 | f := func(idx1 int) { 2443 | if !isLen1 { 2444 | defer wg.Done() 2445 | } 2446 | arr1[idx1] = func() graphql.Marshaler { 2447 | 2448 | return ec.___Type(ctx, field.Selections, &res[idx1]) 2449 | }() 2450 | } 2451 | if isLen1 { 2452 | f(idx1) 2453 | } else { 2454 | go f(idx1) 2455 | } 2456 | 2457 | } 2458 | wg.Wait() 2459 | return arr1 2460 | } 2461 | 2462 | // nolint: vetshadow 2463 | func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler { 2464 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2465 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2466 | rctx := &graphql.ResolverContext{ 2467 | Object: "__Schema", 2468 | Args: nil, 2469 | Field: field, 2470 | } 2471 | ctx = graphql.WithResolverContext(ctx, rctx) 2472 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2473 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2474 | ctx = rctx // use context from middleware stack in children 2475 | return obj.QueryType(), nil 2476 | }) 2477 | if resTmp == nil { 2478 | if !ec.HasError(rctx) { 2479 | ec.Errorf(ctx, "must not be null") 2480 | } 2481 | return graphql.Null 2482 | } 2483 | res := resTmp.(*introspection.Type) 2484 | rctx.Result = res 2485 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2486 | 2487 | if res == nil { 2488 | if !ec.HasError(rctx) { 2489 | ec.Errorf(ctx, "must not be null") 2490 | } 2491 | return graphql.Null 2492 | } 2493 | 2494 | return ec.___Type(ctx, field.Selections, res) 2495 | } 2496 | 2497 | // nolint: vetshadow 2498 | func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler { 2499 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2500 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2501 | rctx := &graphql.ResolverContext{ 2502 | Object: "__Schema", 2503 | Args: nil, 2504 | Field: field, 2505 | } 2506 | ctx = graphql.WithResolverContext(ctx, rctx) 2507 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2508 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2509 | ctx = rctx // use context from middleware stack in children 2510 | return obj.MutationType(), nil 2511 | }) 2512 | if resTmp == nil { 2513 | return graphql.Null 2514 | } 2515 | res := resTmp.(*introspection.Type) 2516 | rctx.Result = res 2517 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2518 | 2519 | if res == nil { 2520 | return graphql.Null 2521 | } 2522 | 2523 | return ec.___Type(ctx, field.Selections, res) 2524 | } 2525 | 2526 | // nolint: vetshadow 2527 | func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler { 2528 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2529 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2530 | rctx := &graphql.ResolverContext{ 2531 | Object: "__Schema", 2532 | Args: nil, 2533 | Field: field, 2534 | } 2535 | ctx = graphql.WithResolverContext(ctx, rctx) 2536 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2537 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2538 | ctx = rctx // use context from middleware stack in children 2539 | return obj.SubscriptionType(), nil 2540 | }) 2541 | if resTmp == nil { 2542 | return graphql.Null 2543 | } 2544 | res := resTmp.(*introspection.Type) 2545 | rctx.Result = res 2546 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2547 | 2548 | if res == nil { 2549 | return graphql.Null 2550 | } 2551 | 2552 | return ec.___Type(ctx, field.Selections, res) 2553 | } 2554 | 2555 | // nolint: vetshadow 2556 | func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler { 2557 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2558 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2559 | rctx := &graphql.ResolverContext{ 2560 | Object: "__Schema", 2561 | Args: nil, 2562 | Field: field, 2563 | } 2564 | ctx = graphql.WithResolverContext(ctx, rctx) 2565 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2566 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2567 | ctx = rctx // use context from middleware stack in children 2568 | return obj.Directives(), nil 2569 | }) 2570 | if resTmp == nil { 2571 | if !ec.HasError(rctx) { 2572 | ec.Errorf(ctx, "must not be null") 2573 | } 2574 | return graphql.Null 2575 | } 2576 | res := resTmp.([]introspection.Directive) 2577 | rctx.Result = res 2578 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2579 | 2580 | arr1 := make(graphql.Array, len(res)) 2581 | var wg sync.WaitGroup 2582 | 2583 | isLen1 := len(res) == 1 2584 | if !isLen1 { 2585 | wg.Add(len(res)) 2586 | } 2587 | 2588 | for idx1 := range res { 2589 | idx1 := idx1 2590 | rctx := &graphql.ResolverContext{ 2591 | Index: &idx1, 2592 | Result: &res[idx1], 2593 | } 2594 | ctx := graphql.WithResolverContext(ctx, rctx) 2595 | f := func(idx1 int) { 2596 | if !isLen1 { 2597 | defer wg.Done() 2598 | } 2599 | arr1[idx1] = func() graphql.Marshaler { 2600 | 2601 | return ec.___Directive(ctx, field.Selections, &res[idx1]) 2602 | }() 2603 | } 2604 | if isLen1 { 2605 | f(idx1) 2606 | } else { 2607 | go f(idx1) 2608 | } 2609 | 2610 | } 2611 | wg.Wait() 2612 | return arr1 2613 | } 2614 | 2615 | var __TypeImplementors = []string{"__Type"} 2616 | 2617 | // nolint: gocyclo, errcheck, gas, goconst 2618 | func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler { 2619 | fields := graphql.CollectFields(ctx, sel, __TypeImplementors) 2620 | 2621 | out := graphql.NewOrderedMap(len(fields)) 2622 | invalid := false 2623 | for i, field := range fields { 2624 | out.Keys[i] = field.Alias 2625 | 2626 | switch field.Name { 2627 | case "__typename": 2628 | out.Values[i] = graphql.MarshalString("__Type") 2629 | case "kind": 2630 | out.Values[i] = ec.___Type_kind(ctx, field, obj) 2631 | if out.Values[i] == graphql.Null { 2632 | invalid = true 2633 | } 2634 | case "name": 2635 | out.Values[i] = ec.___Type_name(ctx, field, obj) 2636 | case "description": 2637 | out.Values[i] = ec.___Type_description(ctx, field, obj) 2638 | case "fields": 2639 | out.Values[i] = ec.___Type_fields(ctx, field, obj) 2640 | case "interfaces": 2641 | out.Values[i] = ec.___Type_interfaces(ctx, field, obj) 2642 | case "possibleTypes": 2643 | out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj) 2644 | case "enumValues": 2645 | out.Values[i] = ec.___Type_enumValues(ctx, field, obj) 2646 | case "inputFields": 2647 | out.Values[i] = ec.___Type_inputFields(ctx, field, obj) 2648 | case "ofType": 2649 | out.Values[i] = ec.___Type_ofType(ctx, field, obj) 2650 | default: 2651 | panic("unknown field " + strconv.Quote(field.Name)) 2652 | } 2653 | } 2654 | 2655 | if invalid { 2656 | return graphql.Null 2657 | } 2658 | return out 2659 | } 2660 | 2661 | // nolint: vetshadow 2662 | func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2663 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2664 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2665 | rctx := &graphql.ResolverContext{ 2666 | Object: "__Type", 2667 | Args: nil, 2668 | Field: field, 2669 | } 2670 | ctx = graphql.WithResolverContext(ctx, rctx) 2671 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2672 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2673 | ctx = rctx // use context from middleware stack in children 2674 | return obj.Kind(), nil 2675 | }) 2676 | if resTmp == nil { 2677 | if !ec.HasError(rctx) { 2678 | ec.Errorf(ctx, "must not be null") 2679 | } 2680 | return graphql.Null 2681 | } 2682 | res := resTmp.(string) 2683 | rctx.Result = res 2684 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2685 | return graphql.MarshalString(res) 2686 | } 2687 | 2688 | // nolint: vetshadow 2689 | func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2690 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2691 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2692 | rctx := &graphql.ResolverContext{ 2693 | Object: "__Type", 2694 | Args: nil, 2695 | Field: field, 2696 | } 2697 | ctx = graphql.WithResolverContext(ctx, rctx) 2698 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2699 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2700 | ctx = rctx // use context from middleware stack in children 2701 | return obj.Name(), nil 2702 | }) 2703 | if resTmp == nil { 2704 | return graphql.Null 2705 | } 2706 | res := resTmp.(*string) 2707 | rctx.Result = res 2708 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2709 | 2710 | if res == nil { 2711 | return graphql.Null 2712 | } 2713 | return graphql.MarshalString(*res) 2714 | } 2715 | 2716 | // nolint: vetshadow 2717 | func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2718 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2719 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2720 | rctx := &graphql.ResolverContext{ 2721 | Object: "__Type", 2722 | Args: nil, 2723 | Field: field, 2724 | } 2725 | ctx = graphql.WithResolverContext(ctx, rctx) 2726 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2727 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2728 | ctx = rctx // use context from middleware stack in children 2729 | return obj.Description(), nil 2730 | }) 2731 | if resTmp == nil { 2732 | return graphql.Null 2733 | } 2734 | res := resTmp.(string) 2735 | rctx.Result = res 2736 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2737 | return graphql.MarshalString(res) 2738 | } 2739 | 2740 | // nolint: vetshadow 2741 | func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2742 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2743 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2744 | rawArgs := field.ArgumentMap(ec.Variables) 2745 | args, err := field___Type_fields_args(rawArgs) 2746 | if err != nil { 2747 | ec.Error(ctx, err) 2748 | return graphql.Null 2749 | } 2750 | rctx := &graphql.ResolverContext{ 2751 | Object: "__Type", 2752 | Args: args, 2753 | Field: field, 2754 | } 2755 | ctx = graphql.WithResolverContext(ctx, rctx) 2756 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2757 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2758 | ctx = rctx // use context from middleware stack in children 2759 | return obj.Fields(args["includeDeprecated"].(bool)), nil 2760 | }) 2761 | if resTmp == nil { 2762 | return graphql.Null 2763 | } 2764 | res := resTmp.([]introspection.Field) 2765 | rctx.Result = res 2766 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2767 | 2768 | arr1 := make(graphql.Array, len(res)) 2769 | var wg sync.WaitGroup 2770 | 2771 | isLen1 := len(res) == 1 2772 | if !isLen1 { 2773 | wg.Add(len(res)) 2774 | } 2775 | 2776 | for idx1 := range res { 2777 | idx1 := idx1 2778 | rctx := &graphql.ResolverContext{ 2779 | Index: &idx1, 2780 | Result: &res[idx1], 2781 | } 2782 | ctx := graphql.WithResolverContext(ctx, rctx) 2783 | f := func(idx1 int) { 2784 | if !isLen1 { 2785 | defer wg.Done() 2786 | } 2787 | arr1[idx1] = func() graphql.Marshaler { 2788 | 2789 | return ec.___Field(ctx, field.Selections, &res[idx1]) 2790 | }() 2791 | } 2792 | if isLen1 { 2793 | f(idx1) 2794 | } else { 2795 | go f(idx1) 2796 | } 2797 | 2798 | } 2799 | wg.Wait() 2800 | return arr1 2801 | } 2802 | 2803 | // nolint: vetshadow 2804 | func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2805 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2806 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2807 | rctx := &graphql.ResolverContext{ 2808 | Object: "__Type", 2809 | Args: nil, 2810 | Field: field, 2811 | } 2812 | ctx = graphql.WithResolverContext(ctx, rctx) 2813 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2814 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2815 | ctx = rctx // use context from middleware stack in children 2816 | return obj.Interfaces(), nil 2817 | }) 2818 | if resTmp == nil { 2819 | return graphql.Null 2820 | } 2821 | res := resTmp.([]introspection.Type) 2822 | rctx.Result = res 2823 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2824 | 2825 | arr1 := make(graphql.Array, len(res)) 2826 | var wg sync.WaitGroup 2827 | 2828 | isLen1 := len(res) == 1 2829 | if !isLen1 { 2830 | wg.Add(len(res)) 2831 | } 2832 | 2833 | for idx1 := range res { 2834 | idx1 := idx1 2835 | rctx := &graphql.ResolverContext{ 2836 | Index: &idx1, 2837 | Result: &res[idx1], 2838 | } 2839 | ctx := graphql.WithResolverContext(ctx, rctx) 2840 | f := func(idx1 int) { 2841 | if !isLen1 { 2842 | defer wg.Done() 2843 | } 2844 | arr1[idx1] = func() graphql.Marshaler { 2845 | 2846 | return ec.___Type(ctx, field.Selections, &res[idx1]) 2847 | }() 2848 | } 2849 | if isLen1 { 2850 | f(idx1) 2851 | } else { 2852 | go f(idx1) 2853 | } 2854 | 2855 | } 2856 | wg.Wait() 2857 | return arr1 2858 | } 2859 | 2860 | // nolint: vetshadow 2861 | func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2862 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2863 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2864 | rctx := &graphql.ResolverContext{ 2865 | Object: "__Type", 2866 | Args: nil, 2867 | Field: field, 2868 | } 2869 | ctx = graphql.WithResolverContext(ctx, rctx) 2870 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2871 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2872 | ctx = rctx // use context from middleware stack in children 2873 | return obj.PossibleTypes(), nil 2874 | }) 2875 | if resTmp == nil { 2876 | return graphql.Null 2877 | } 2878 | res := resTmp.([]introspection.Type) 2879 | rctx.Result = res 2880 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2881 | 2882 | arr1 := make(graphql.Array, len(res)) 2883 | var wg sync.WaitGroup 2884 | 2885 | isLen1 := len(res) == 1 2886 | if !isLen1 { 2887 | wg.Add(len(res)) 2888 | } 2889 | 2890 | for idx1 := range res { 2891 | idx1 := idx1 2892 | rctx := &graphql.ResolverContext{ 2893 | Index: &idx1, 2894 | Result: &res[idx1], 2895 | } 2896 | ctx := graphql.WithResolverContext(ctx, rctx) 2897 | f := func(idx1 int) { 2898 | if !isLen1 { 2899 | defer wg.Done() 2900 | } 2901 | arr1[idx1] = func() graphql.Marshaler { 2902 | 2903 | return ec.___Type(ctx, field.Selections, &res[idx1]) 2904 | }() 2905 | } 2906 | if isLen1 { 2907 | f(idx1) 2908 | } else { 2909 | go f(idx1) 2910 | } 2911 | 2912 | } 2913 | wg.Wait() 2914 | return arr1 2915 | } 2916 | 2917 | // nolint: vetshadow 2918 | func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2919 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2920 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2921 | rawArgs := field.ArgumentMap(ec.Variables) 2922 | args, err := field___Type_enumValues_args(rawArgs) 2923 | if err != nil { 2924 | ec.Error(ctx, err) 2925 | return graphql.Null 2926 | } 2927 | rctx := &graphql.ResolverContext{ 2928 | Object: "__Type", 2929 | Args: args, 2930 | Field: field, 2931 | } 2932 | ctx = graphql.WithResolverContext(ctx, rctx) 2933 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2934 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2935 | ctx = rctx // use context from middleware stack in children 2936 | return obj.EnumValues(args["includeDeprecated"].(bool)), nil 2937 | }) 2938 | if resTmp == nil { 2939 | return graphql.Null 2940 | } 2941 | res := resTmp.([]introspection.EnumValue) 2942 | rctx.Result = res 2943 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 2944 | 2945 | arr1 := make(graphql.Array, len(res)) 2946 | var wg sync.WaitGroup 2947 | 2948 | isLen1 := len(res) == 1 2949 | if !isLen1 { 2950 | wg.Add(len(res)) 2951 | } 2952 | 2953 | for idx1 := range res { 2954 | idx1 := idx1 2955 | rctx := &graphql.ResolverContext{ 2956 | Index: &idx1, 2957 | Result: &res[idx1], 2958 | } 2959 | ctx := graphql.WithResolverContext(ctx, rctx) 2960 | f := func(idx1 int) { 2961 | if !isLen1 { 2962 | defer wg.Done() 2963 | } 2964 | arr1[idx1] = func() graphql.Marshaler { 2965 | 2966 | return ec.___EnumValue(ctx, field.Selections, &res[idx1]) 2967 | }() 2968 | } 2969 | if isLen1 { 2970 | f(idx1) 2971 | } else { 2972 | go f(idx1) 2973 | } 2974 | 2975 | } 2976 | wg.Wait() 2977 | return arr1 2978 | } 2979 | 2980 | // nolint: vetshadow 2981 | func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 2982 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 2983 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 2984 | rctx := &graphql.ResolverContext{ 2985 | Object: "__Type", 2986 | Args: nil, 2987 | Field: field, 2988 | } 2989 | ctx = graphql.WithResolverContext(ctx, rctx) 2990 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 2991 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 2992 | ctx = rctx // use context from middleware stack in children 2993 | return obj.InputFields(), nil 2994 | }) 2995 | if resTmp == nil { 2996 | return graphql.Null 2997 | } 2998 | res := resTmp.([]introspection.InputValue) 2999 | rctx.Result = res 3000 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 3001 | 3002 | arr1 := make(graphql.Array, len(res)) 3003 | var wg sync.WaitGroup 3004 | 3005 | isLen1 := len(res) == 1 3006 | if !isLen1 { 3007 | wg.Add(len(res)) 3008 | } 3009 | 3010 | for idx1 := range res { 3011 | idx1 := idx1 3012 | rctx := &graphql.ResolverContext{ 3013 | Index: &idx1, 3014 | Result: &res[idx1], 3015 | } 3016 | ctx := graphql.WithResolverContext(ctx, rctx) 3017 | f := func(idx1 int) { 3018 | if !isLen1 { 3019 | defer wg.Done() 3020 | } 3021 | arr1[idx1] = func() graphql.Marshaler { 3022 | 3023 | return ec.___InputValue(ctx, field.Selections, &res[idx1]) 3024 | }() 3025 | } 3026 | if isLen1 { 3027 | f(idx1) 3028 | } else { 3029 | go f(idx1) 3030 | } 3031 | 3032 | } 3033 | wg.Wait() 3034 | return arr1 3035 | } 3036 | 3037 | // nolint: vetshadow 3038 | func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler { 3039 | ctx = ec.Tracer.StartFieldExecution(ctx, field) 3040 | defer func() { ec.Tracer.EndFieldExecution(ctx) }() 3041 | rctx := &graphql.ResolverContext{ 3042 | Object: "__Type", 3043 | Args: nil, 3044 | Field: field, 3045 | } 3046 | ctx = graphql.WithResolverContext(ctx, rctx) 3047 | ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) 3048 | resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 3049 | ctx = rctx // use context from middleware stack in children 3050 | return obj.OfType(), nil 3051 | }) 3052 | if resTmp == nil { 3053 | return graphql.Null 3054 | } 3055 | res := resTmp.(*introspection.Type) 3056 | rctx.Result = res 3057 | ctx = ec.Tracer.StartFieldChildExecution(ctx) 3058 | 3059 | if res == nil { 3060 | return graphql.Null 3061 | } 3062 | 3063 | return ec.___Type(ctx, field.Selections, res) 3064 | } 3065 | 3066 | func UnmarshalNewReview(v interface{}) (NewReview, error) { 3067 | var it NewReview 3068 | var asMap = v.(map[string]interface{}) 3069 | 3070 | for k, v := range asMap { 3071 | switch k { 3072 | case "videoId": 3073 | var err error 3074 | it.VideoID, err = api.UnmarshalID(v) 3075 | if err != nil { 3076 | return it, err 3077 | } 3078 | case "title": 3079 | var err error 3080 | it.Title, err = graphql.UnmarshalString(v) 3081 | if err != nil { 3082 | return it, err 3083 | } 3084 | case "description": 3085 | var err error 3086 | it.Description, err = graphql.UnmarshalString(v) 3087 | if err != nil { 3088 | return it, err 3089 | } 3090 | case "rating": 3091 | var err error 3092 | it.Rating, err = graphql.UnmarshalInt(v) 3093 | if err != nil { 3094 | return it, err 3095 | } 3096 | case "userId": 3097 | var err error 3098 | it.UserID, err = api.UnmarshalID(v) 3099 | if err != nil { 3100 | return it, err 3101 | } 3102 | } 3103 | } 3104 | 3105 | return it, nil 3106 | } 3107 | 3108 | func UnmarshalNewScreenshot(v interface{}) (NewScreenshot, error) { 3109 | var it NewScreenshot 3110 | var asMap = v.(map[string]interface{}) 3111 | 3112 | for k, v := range asMap { 3113 | switch k { 3114 | case "videoId": 3115 | var err error 3116 | it.VideoID, err = api.UnmarshalID(v) 3117 | if err != nil { 3118 | return it, err 3119 | } 3120 | case "url": 3121 | var err error 3122 | it.URL, err = graphql.UnmarshalString(v) 3123 | if err != nil { 3124 | return it, err 3125 | } 3126 | case "description": 3127 | var err error 3128 | var ptr1 string 3129 | if v != nil { 3130 | ptr1, err = graphql.UnmarshalString(v) 3131 | it.Description = &ptr1 3132 | } 3133 | 3134 | if err != nil { 3135 | return it, err 3136 | } 3137 | } 3138 | } 3139 | 3140 | return it, nil 3141 | } 3142 | 3143 | func UnmarshalNewVideo(v interface{}) (NewVideo, error) { 3144 | var it NewVideo 3145 | var asMap = v.(map[string]interface{}) 3146 | 3147 | for k, v := range asMap { 3148 | switch k { 3149 | case "name": 3150 | var err error 3151 | it.Name, err = graphql.UnmarshalString(v) 3152 | if err != nil { 3153 | return it, err 3154 | } 3155 | case "description": 3156 | var err error 3157 | it.Description, err = graphql.UnmarshalString(v) 3158 | if err != nil { 3159 | return it, err 3160 | } 3161 | case "userId": 3162 | var err error 3163 | it.UserID, err = api.UnmarshalID(v) 3164 | if err != nil { 3165 | return it, err 3166 | } 3167 | case "url": 3168 | var err error 3169 | it.URL, err = graphql.UnmarshalString(v) 3170 | if err != nil { 3171 | return it, err 3172 | } 3173 | } 3174 | } 3175 | 3176 | return it, nil 3177 | } 3178 | 3179 | func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) { 3180 | defer func() { 3181 | if r := recover(); r != nil { 3182 | ec.Error(ctx, ec.Recover(ctx, r)) 3183 | ret = nil 3184 | } 3185 | }() 3186 | rctx := graphql.GetResolverContext(ctx) 3187 | for _, d := range rctx.Field.Definition.Directives { 3188 | switch d.Name { 3189 | case "isAuthenticated": 3190 | if ec.directives.IsAuthenticated != nil { 3191 | n := next 3192 | next = func(ctx context.Context) (interface{}, error) { 3193 | return ec.directives.IsAuthenticated(ctx, obj, n) 3194 | } 3195 | } 3196 | } 3197 | } 3198 | res, err := ec.ResolverMiddleware(ctx, next) 3199 | if err != nil { 3200 | ec.Error(ctx, err) 3201 | return nil 3202 | } 3203 | return res 3204 | } 3205 | 3206 | func (ec *executionContext) introspectSchema() (*introspection.Schema, error) { 3207 | if ec.DisableIntrospection { 3208 | return nil, errors.New("introspection disabled") 3209 | } 3210 | return introspection.WrapSchema(parsedSchema), nil 3211 | } 3212 | 3213 | func (ec *executionContext) introspectType(name string) (*introspection.Type, error) { 3214 | if ec.DisableIntrospection { 3215 | return nil, errors.New("introspection disabled") 3216 | } 3217 | return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil 3218 | } 3219 | 3220 | var parsedSchema = gqlparser.MustLoadSchema( 3221 | &ast.Source{Name: "schema.graphql", Input: `type User { 3222 | id: ID! 3223 | name: String! 3224 | email: String! 3225 | } 3226 | 3227 | type Video { 3228 | id: ID! 3229 | name: String! 3230 | description: String! 3231 | user: User! 3232 | url: String! 3233 | createdAt: Timestamp! 3234 | screenshots: [Screenshot] 3235 | related(limit: Int = 25, offset: Int = 0): [Video!]! 3236 | } 3237 | 3238 | type Screenshot { 3239 | id: ID! 3240 | videoId: ID! 3241 | url: String! 3242 | } 3243 | 3244 | type Review { 3245 | id: ID! 3246 | videoId: ID! 3247 | user: User! 3248 | description: String! 3249 | rating: Int! 3250 | createdAt: Timestamp! 3251 | } 3252 | 3253 | input NewVideo { 3254 | name: String! 3255 | description: String! 3256 | userId: ID! 3257 | url: String! 3258 | } 3259 | 3260 | input NewScreenshot { 3261 | videoId: ID! 3262 | url: String! 3263 | description: String 3264 | } 3265 | 3266 | input NewReview { 3267 | videoId: ID! 3268 | title: String! 3269 | description: String! 3270 | rating: Int! 3271 | userId: ID! 3272 | } 3273 | 3274 | type Mutation { 3275 | createVideo(input: NewVideo!): Video! @isAuthenticated 3276 | } 3277 | 3278 | type Query { 3279 | Videos(limit: Int = 25, offset: Int = 0): [Video!]! 3280 | } 3281 | 3282 | type Subscription { 3283 | videoPublished: Video! 3284 | } 3285 | 3286 | scalar Timestamp 3287 | 3288 | directive @isAuthenticated on FIELD_DEFINITION`}, 3289 | ) 3290 | -------------------------------------------------------------------------------- /gqlgen.yml: -------------------------------------------------------------------------------- 1 | # .gqlgen.yml example 2 | # 3 | # Refer to https://gqlgen.com/config/ 4 | # for detailed .gqlgen.yml documentation. 5 | 6 | schema: 7 | - schema.graphql 8 | exec: 9 | filename: generated.go 10 | model: 11 | filename: models_gen.go 12 | resolver: 13 | filename: resolver.go 14 | type: Resolver 15 | models: 16 | Review: 17 | model: github.com/ridhamtarpara/go-graphql-demo/api.Review 18 | Screenshot: 19 | model: github.com/ridhamtarpara/go-graphql-demo/api.Screenshot 20 | User: 21 | model: github.com/ridhamtarpara/go-graphql-demo/api.User 22 | Video: 23 | model: github.com/ridhamtarpara/go-graphql-demo/api.Video 24 | ID: 25 | model: github.com/ridhamtarpara/go-graphql-demo/api.ID 26 | Timestamp: 27 | model: github.com/ridhamtarpara/go-graphql-demo/api.Timestamp -------------------------------------------------------------------------------- /models_gen.go: -------------------------------------------------------------------------------- 1 | // Code generated by github.com/99designs/gqlgen, DO NOT EDIT. 2 | 3 | package go_graphql_demo 4 | 5 | type NewReview struct { 6 | VideoID int `json:"videoId"` 7 | Title string `json:"title"` 8 | Description string `json:"description"` 9 | Rating int `json:"rating"` 10 | UserID int `json:"userId"` 11 | } 12 | 13 | type NewScreenshot struct { 14 | VideoID int `json:"videoId"` 15 | URL string `json:"url"` 16 | Description *string `json:"description"` 17 | } 18 | 19 | type NewVideo struct { 20 | Name string `json:"name"` 21 | Description string `json:"description"` 22 | UserID int `json:"userId"` 23 | URL string `json:"url"` 24 | } 25 | -------------------------------------------------------------------------------- /resolver.go: -------------------------------------------------------------------------------- 1 | package go_graphql_demo 2 | 3 | import ( 4 | "context" 5 | "database/sql" 6 | "fmt" 7 | "github.com/99designs/gqlgen/graphql" 8 | "github.com/markbates/going/randx" 9 | "github.com/ridhamtarpara/go-graphql-demo/api" 10 | "github.com/ridhamtarpara/go-graphql-demo/api/dal" 11 | "github.com/ridhamtarpara/go-graphql-demo/api/dataloaders" 12 | "github.com/ridhamtarpara/go-graphql-demo/api/errors" 13 | "strconv" 14 | "time" 15 | ) 16 | 17 | var videoPublishedChannel map[string]chan api.Video 18 | 19 | func init() { 20 | videoPublishedChannel = map[string]chan api.Video{} 21 | } 22 | 23 | type contextKey string 24 | 25 | var ( 26 | UserIDCtxKey = contextKey("userID") 27 | ) 28 | 29 | type Resolver struct { 30 | db *sql.DB 31 | } 32 | 33 | func NewRootResolvers(db *sql.DB) Config { 34 | c := Config{ 35 | Resolvers: &Resolver{ 36 | db: db, 37 | }, 38 | } 39 | 40 | // Complexity 41 | countComplexity := func(childComplexity int, limit *int, offset *int) int { 42 | return *limit * childComplexity 43 | } 44 | c.Complexity.Query.Videos = countComplexity 45 | c.Complexity.Video.Related = countComplexity 46 | 47 | // Schema Directive 48 | c.Directives.IsAuthenticated = func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error) { 49 | ctxUserID := ctx.Value(UserIDCtxKey) 50 | if ctxUserID != nil { 51 | return next(ctx) 52 | } else { 53 | return nil, errors.UnauthorisedError 54 | } 55 | } 56 | return c 57 | } 58 | 59 | func (r *Resolver) Mutation() MutationResolver { 60 | return &mutationResolver{r} 61 | } 62 | func (r *Resolver) Query() QueryResolver { 63 | return &queryResolver{r} 64 | } 65 | func (r *Resolver) Review() ReviewResolver { 66 | return &reviewResolver{r} 67 | } 68 | func (r *Resolver) Video() VideoResolver { 69 | return &videoResolver{r} 70 | } 71 | func (r *Resolver) Subscription() SubscriptionResolver { 72 | return &subscriptionResolver{r} 73 | } 74 | 75 | type mutationResolver struct{ *Resolver } 76 | 77 | func (r *mutationResolver) CreateVideo(ctx context.Context, input NewVideo) (api.Video, error) { 78 | userID := UserFromContext(ctx) 79 | newVideo := api.Video{ 80 | URL: input.URL, 81 | Description: input.Description, 82 | Name: input.Name, 83 | CreatedAt: time.Now().UTC(), 84 | UserID: userID, 85 | } 86 | 87 | rows, err := dal.LogAndQuery(r.db, "INSERT INTO videos (name, description, url, user_id, created_at) VALUES($1, $2, $3, $4, $5) RETURNING id", 88 | input.Name, input.Description, input.URL, userID, newVideo.CreatedAt) 89 | if err != nil || !rows.Next() { 90 | return api.Video{}, err 91 | } 92 | defer rows.Close() 93 | 94 | if err := rows.Scan(&newVideo.ID); err != nil { 95 | errors.DebugPrintf(err) 96 | if errors.IsForeignKeyError(err) { 97 | return api.Video{}, errors.UserNotExist 98 | } 99 | return api.Video{}, errors.InternalServerError 100 | } 101 | 102 | for _, observer := range videoPublishedChannel { 103 | observer <- newVideo 104 | } 105 | 106 | return newVideo, nil 107 | } 108 | 109 | type queryResolver struct{ *Resolver } 110 | 111 | func (r *queryResolver) Videos(ctx context.Context, limit *int, offset *int) ([]api.Video, error) { 112 | var video api.Video 113 | var videos []api.Video 114 | 115 | rows, err := dal.LogAndQuery(r.db, "SELECT id, name, description, url, created_at, user_id FROM videos ORDER BY created_at desc limit $1 offset $2", limit, offset) 116 | defer rows.Close(); 117 | if err != nil { 118 | errors.DebugPrintf(err) 119 | return nil, errors.InternalServerError 120 | } 121 | for rows.Next() { 122 | if err := rows.Scan(&video.ID, &video.Name, &video.Description, &video.URL, &video.CreatedAt, &video.UserID); err != nil { 123 | errors.DebugPrintf(err) 124 | return nil, errors.InternalServerError 125 | } 126 | videos = append(videos, video) 127 | } 128 | 129 | return videos, nil 130 | } 131 | 132 | type reviewResolver struct{ *Resolver } 133 | 134 | func (r *reviewResolver) User(ctx context.Context, obj *api.Review) (api.User, error) { 135 | panic("not implemented") 136 | } 137 | 138 | type videoResolver struct{ *Resolver } 139 | 140 | func (r *videoResolver) User(ctx context.Context, obj *api.Video) (api.User, error) { 141 | // Raw 142 | 143 | //rows, _ := dal.LogAndQuery(r.db, "SELECT id, name, email FROM users where id = $1", obj.UserID) 144 | //defer rows.Close() 145 | // 146 | //if !rows.Next() { 147 | // return api.User{}, nil 148 | //} 149 | //var user api.User 150 | //if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil { 151 | // errors.DebugPrintf(err) 152 | // return api.User{}, errors.InternalServerError 153 | //} 154 | // 155 | //return user, nil 156 | 157 | // DataLoader 158 | user, err := ctx.Value(dataloaders.CtxKey).(*dataloaders.UserLoader).Load(obj.UserID) 159 | return *user, err 160 | //return api.User{}, nil 161 | } 162 | func (r *videoResolver) Screenshots(ctx context.Context, obj *api.Video) ([]*api.Screenshot, error) { 163 | panic("not implemented") 164 | } 165 | 166 | func (r *videoResolver) Related(ctx context.Context, obj *api.Video, limit *int, offset *int) ([]api.Video, error) { 167 | fmt.Println("Related Called") 168 | return []api.Video{}, nil 169 | } 170 | 171 | type subscriptionResolver struct{ *Resolver } 172 | 173 | func (r *subscriptionResolver) VideoPublished(ctx context.Context) (<-chan api.Video, error) { 174 | id := randx.String(8) 175 | 176 | videoEvent := make(chan api.Video, 1) 177 | go func() { 178 | <-ctx.Done() 179 | }() 180 | videoPublishedChannel[id] = videoEvent 181 | return videoEvent, nil 182 | } 183 | 184 | func UserFromContext(ctx context.Context) (int) { 185 | userIDStr, _ := ctx.Value(UserIDCtxKey).(string) 186 | userID, _ := strconv.Atoi(userIDStr) 187 | return userID 188 | } 189 | -------------------------------------------------------------------------------- /schema.graphql: -------------------------------------------------------------------------------- 1 | type User { 2 | id: ID! 3 | name: String! 4 | email: String! 5 | } 6 | 7 | type Video { 8 | id: ID! 9 | name: String! 10 | description: String! 11 | user: User! 12 | url: String! 13 | createdAt: Timestamp! 14 | screenshots: [Screenshot] 15 | related(limit: Int = 25, offset: Int = 0): [Video!]! 16 | } 17 | 18 | type Screenshot { 19 | id: ID! 20 | videoId: ID! 21 | url: String! 22 | } 23 | 24 | type Review { 25 | id: ID! 26 | videoId: ID! 27 | user: User! 28 | description: String! 29 | rating: Int! 30 | createdAt: Timestamp! 31 | } 32 | 33 | input NewVideo { 34 | name: String! 35 | description: String! 36 | userId: ID! 37 | url: String! 38 | } 39 | 40 | input NewScreenshot { 41 | videoId: ID! 42 | url: String! 43 | description: String 44 | } 45 | 46 | input NewReview { 47 | videoId: ID! 48 | title: String! 49 | description: String! 50 | rating: Int! 51 | userId: ID! 52 | } 53 | 54 | type Mutation { 55 | createVideo(input: NewVideo!): Video! @isAuthenticated 56 | } 57 | 58 | type Query { 59 | Videos(limit: Int = 25, offset: Int = 0): [Video!]! 60 | } 61 | 62 | type Subscription { 63 | videoPublished: Video! 64 | } 65 | 66 | scalar Timestamp 67 | 68 | directive @isAuthenticated on FIELD_DEFINITION -------------------------------------------------------------------------------- /scripts/gqlgen.go: -------------------------------------------------------------------------------- 1 | // +build ignore 2 | 3 | package main 4 | 5 | import "github.com/99designs/gqlgen/cmd" 6 | 7 | func main() { 8 | cmd.Execute() 9 | } -------------------------------------------------------------------------------- /server/server.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "database/sql" 5 | "github.com/99designs/gqlgen/handler" 6 | "github.com/ridhamtarpara/go-graphql-demo" 7 | "github.com/ridhamtarpara/go-graphql-demo/api/auth" 8 | "github.com/ridhamtarpara/go-graphql-demo/api/dal" 9 | "github.com/ridhamtarpara/go-graphql-demo/api/dataloaders" 10 | "log" 11 | "net/http" 12 | "os" 13 | ) 14 | 15 | const defaultPort = "8080" 16 | 17 | func main() { 18 | port := os.Getenv("PORT") 19 | if port == "" { 20 | port = defaultPort 21 | } 22 | 23 | db, err := dal.Connect() 24 | checkErr(err) 25 | 26 | initDB(db) 27 | 28 | http.Handle("/", handler.Playground("GraphQL playground", "/query")) 29 | rootHandler:= dataloaders.DataloaderMiddleware( 30 | db, 31 | handler.GraphQL( 32 | go_graphql_demo.NewExecutableSchema(go_graphql_demo.NewRootResolvers(db)), 33 | handler.ComplexityLimit(200)), 34 | ) 35 | http.Handle("/query", auth.AuthMiddleware(rootHandler)) 36 | 37 | log.Printf("connect to http://localhost:%s/ for GraphQL playground", port) 38 | log.Fatal(http.ListenAndServe(":"+port, nil)) 39 | } 40 | 41 | func checkErr(err error) { 42 | if err != nil { 43 | panic(err) 44 | } 45 | } 46 | 47 | func initDB(db *sql.DB) { 48 | dal.MustExec(db,"DROP TABLE IF EXISTS reviews") 49 | dal.MustExec(db,"DROP TABLE IF EXISTS screenshots") 50 | dal.MustExec(db,"DROP TABLE IF EXISTS videos") 51 | dal.MustExec(db,"DROP TABLE IF EXISTS users") 52 | dal.MustExec(db,"CREATE TABLE public.users (id SERIAL PRIMARY KEY, name varchar(255), email varchar(255))") 53 | dal.MustExec(db,"CREATE TABLE public.videos (id SERIAL PRIMARY KEY, name varchar(255), description varchar(255), url text,created_at TIMESTAMP, user_id int, FOREIGN KEY (user_id) REFERENCES users (id))") 54 | dal.MustExec(db,"CREATE TABLE public.screenshots (id SERIAL PRIMARY KEY, video_id int, url text, FOREIGN KEY (video_id) REFERENCES videos (id))") 55 | dal.MustExec(db,"CREATE TABLE public.reviews (id SERIAL PRIMARY KEY, video_id int,user_id int, description varchar(255), rating varchar(255), created_at TIMESTAMP, FOREIGN KEY (user_id) REFERENCES users (id), FOREIGN KEY (video_id) REFERENCES videos (id))") 56 | dal.MustExec(db,"INSERT INTO users(name, email) VALUES('Ridham', 'contact@ridham.me')") 57 | dal.MustExec(db,"INSERT INTO users(name, email) VALUES('Tushar', 'tushar@ridham.me')") 58 | dal.MustExec(db,"INSERT INTO users(name, email) VALUES('Dipen', 'dipen@ridham.me')") 59 | dal.MustExec(db,"INSERT INTO users(name, email) VALUES('Harsh', 'harsh@ridham.me')") 60 | dal.MustExec(db,"INSERT INTO users(name, email) VALUES('Priyank', 'priyank@ridham.me')") 61 | } 62 | --------------------------------------------------------------------------------