Natuurlijk! Hier is een stapsgewijze gids voor het ontwerpen en implementeren van een GraphQL-server met behulp van Go, inclusief schema-definitie, resolvers, en het afhandelen van queries en mutations, samen met voorbeeldcode. --- ### 1. Voorbereiding Installeer de benodigde Go-pakketten. Een populaire keuze is [`graphql-go`](https://github.com/graph-gophers/graphql-go): ```bash go get github.com/graph-gophers/graphql-go go get github.com/graph-gophers/graphql-go/relay ``` --- ### 2. Schemas definiëren Maak een schema bestand (`schema.graphql`) waarin je types, queries en mutations definieert. **schema.graphql** ```graphql type Query { hello: String! getUser(id: ID!): User } type Mutation { createUser(name: String!): User } type User { id: ID! name: String! } ``` --- ### 3. Resolvers maken In Go definieer je structuren die de resolvers implementeren. **main.go** ```go package main import ( "context" "fmt" "log" "net/http" "github.com/graph-gophers/graphql-go" "github.com/graph-gophers/graphql-go/relay" ) // User struct voor de data type User struct { ID string Name string } // In-memory data opslag var users = map[string]*User{} var idCounter = 1 // Resolver struct type resolver struct{} // Query resolvers func (r *resolver) Hello() string { return "Hallo, wereld!" } func (r *resolver) GetUser(args struct{ ID graphql.ID }) *userResolver { user, exists := users[string(args.ID)] if !exists { return nil } return &userResolver{user} } // Mutation resolvers func (r *resolver) CreateUser(args struct{ Name string }) *userResolver { id := fmt.Sprintf("%d", idCounter) idCounter++ user := &User{ID: id, Name: args.Name} users[id] = user return &userResolver{user} } // User resolver type userResolver struct { u *User } func (u *userResolver) ID() graphql.ID { return graphql.ID(u.u.ID) } func (u *userResolver) Name() string { return u.u.Name } func main() { // Schema laden schema := ` schema { query: Query mutation: Mutation } type Query { hello: String! getUser(id: ID!): User } type Mutation { createUser(name: String!): User } type User { id: ID! name: String! } ` // Schema compileren s := graphql.MustParseSchema(schema, &resolver{}) http.Handle("/graphql", &relay.Handler{Schema: s}) fmt.Println("Server gestart op :8080") log.Fatal(http.ListenAndServe(":8080", nil)) } ``` --- ### 4. Het gebruiken van de API Je kunt nu HTTP POST requests sturen naar `http://localhost:8080/graphql` met een GraphQL query of mutation. **Voorbeeld query:** ```graphql query { hello } ``` **Voorbeeld mutation:** ```graphql mutation { createUser(name: "Jan") { id name } } ``` **Query om een gebruiker op te halen:** ```graphql query { getUser(id: "1") { id name } } ``` --- ### Samenvatting - Definieer schema's in een `.graphql` bestand of als string. - Implementeer resolvers in Go, die de logica bevatten voor elke query en mutation. - Gebruik `graphql-go` om het schema te parsen en te koppelen aan resolvers. - Start een HTTP-server en behandel GraphQL-verzoeken via `/graphql`. --- Mocht je meer geavanceerde functionaliteiten willen, zoals authenticatie, databasetoegang of subscriptions, dan kun je de structuur uitbreiden met die onderdelen.

Zeker! Ik begeleid je stap voor stap door het proces van het opzetten van een GraphQL-server in Go. We gebruiken het populaire `gqlgen` framework, wat een schema-first aanpak biedt. ## Stap 1: Projectopzet en dependencies ```bash # Maak een nieuwe map en initialiseer Go modules mkdir go-graphql-server cd go-graphql-server go mod init go-graphql-server # Installeer gqlgen go get github.com/99designs/gqlgen ``` ## Stap 2: Schema definitie Maak een bestand `graph/schema.graphqls`: ```graphql type User { id: ID! name: String! email: String! posts: [Post!]! } type Post { id: ID! title: String! content: String! author: User! } type Query { users: [User!]! user(id: ID!): User posts: [Post!]! post(id: ID!): Post } type Mutation { createUser(input: NewUserInput!): User! createPost(input: NewPostInput!): Post! } input NewUserInput { name: String! email: String! } input NewPostInput { title: String! content: String! authorID: ID! } ``` ## Stap 3: gqlgen configuratie Maak `gqlgen.yml`: ```yaml # gqlgen configuratie bestand schema: - graph/schema.graphqls exec: filename: graph/generated/generated.go package: generated model: filename: graph/model/models_gen.go package: model resolver: filename: graph/resolver.go type: Resolver autobind: [] ``` ## Stap 4: Genereren van code ```bash # Genereer de GraphQL code go run github.com/99designs/gqlgen generate ``` ## Stap 5: Data modellen en opslag Maak `graph/model/user.go`: ```go package model type User struct { ID string `json:"id"` Name string `json:"name"` Email string `json:"email"` Posts []*Post `json:"posts"` } type Post struct { ID string `json:"id"` Title string `json:"title"` Content string `json:"content"` Author *User `json:"author"` } ``` ## Stap 6: Resolver implementatie Bewerk `graph/resolver.go`: ```go package graph import ( "context" "fmt" "go-graphql-server/graph/generated" "go-graphql-server/graph/model" "math/rand" "strconv" ) type Resolver struct { users []*model.User posts []*model.Post } func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} } func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} } type mutationResolver struct{ *Resolver } type queryResolver struct{ *Resolver } ``` ## Stap 7: Query resolvers implementatie Voeg toe aan `graph/resolver.go`: ```go // Query resolvers func (r *queryResolver) Users(ctx context.Context) ([]*model.User, error) { return r.users, nil } func (r *queryResolver) User(ctx context.Context, id string) (*model.User, error) { for _, user := range r.users { if user.ID == id { return user, nil } } return nil, fmt.Errorf("user not found") } func (r *queryResolver) Posts(ctx context.Context) ([]*model.Post, error) { return r.posts, nil } func (r *queryResolver) Post(ctx context.Context, id string) (*model.Post, error) { for _, post := range r.posts { if post.ID == id { return post, nil } } return nil, fmt.Errorf("post not found") } ``` ## Stap 8: Mutation resolvers implementatie Voeg toe aan `graph/resolver.go`: ```go // Mutation resolvers func (r *mutationResolver) CreateUser(ctx context.Context, input model.NewUserInput) (*model.User, error) { user := &model.User{ ID: strconv.Itoa(rand.Intn(100000)), Name: input.Name, Email: input.Email, Posts: []*model.Post{}, } r.users = append(r.users, user) return user, nil } func (r *mutationResolver) CreatePost(ctx context.Context, input model.NewPostInput) (*model.Post, error) { // Zoek de auteur var author *model.User for _, user := range r.users { if user.ID == input.AuthorID { author = user break } } if author == nil { return nil, fmt.Errorf("author not found") } post := &model.Post{ ID: strconv.Itoa(rand.Intn(100000)), Title: input.Title, Content: input.Content, Author: author, } r.posts = append(r.posts, post) author.Posts = append(author.Posts, post) return post, nil } ``` ## Stap 9: Server opzetten Maak `server.go`: ```go package main import ( "log" "net/http" "os" "go-graphql-server/graph" "go-graphql-server/graph/generated" "github.com/99designs/gqlgen/graphql/handler" "github.com/99designs/gqlgen/graphql/playground" ) const defaultPort = "8080" func main() { port := os.Getenv("PORT") if port == "" { port = defaultPort } // Initialiseer de resolver met wat testdata resolver := &graph.Resolver{} // Voeg wat initiële gebruikers toe resolver.users = []*graph.User{ {ID: "1", Name: "Jan Jansen", Email: "jan@voorbeeld.nl"}, {ID: "2", Name: "Piet Pieters", Email: "piet@voorbeeld.nl"}, } srv := handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{Resolvers: resolver})) http.Handle("/", playground.Handler("GraphQL Playground", "/query")) http.Handle("/query", srv) log.Printf("GraphQL server start op http://localhost:%s", port) log.Fatal(http.ListenAndServe(":"+port, nil)) } ``` ## Stap 10: Testen van de API Start de server: ```bash go run server.go ``` Ga naar `http://localhost:8080` voor de GraphQL Playground. ### Voorbeeld queries: **Alle gebruikers ophalen:** ```graphql query { users { id name email } } ``` **Nieuwe gebruiker aanmaken:** ```graphql mutation { createUser(input: { name: "Klaas Klaassen" email: "klaas@voorbeeld.nl" }) { id name email } } ``` **Post aanmaken voor gebruiker:** ```graphql mutation { createPost(input: { title: "Mijn eerste post" content: "Dit is de inhoud van mijn post" authorID: "1" }) { id title content author { name email } } } ``` ## Belangrijke concepten uitgelegd: 1. **Schema**: Definieert de types, queries en mutations 2. **Resolvers**: Implementeren de business logic voor elke field 3. **Queries**: Voor het ophalen van data (GET-equivalent) 4. **Mutations**: Voor het wijzigen van data (POST/PUT/DELETE-equivalent) Deze setup biedt een solide basis voor een GraphQL API in Go. Je kunt dit uitbreiden met database-integratie, authenticatie, en complexere business logic.