Nested queries with MongoDB

[JasperAlexander]

Does anyone know how the resolvers and schema files should look like to be able to make nested queries when using MongoDB? For example, how to get the name of the author of a post?

GraphQL query

query GetPost {
  post(id: "63948ab53a9483a31b35639b") {
    id
    author {
      name
    }
    title
    text
  }
}

schema.graphqls

type Author {
  id: ID!
  name: String!
}

type Post {
  id: ID!
  author: Author!
  title: String!
  text: String
}

input NewAuthor {
  name: String!
}

input NewPost {
  authorId: String!
  title: String!
  text: String
}

type Query {
  author(id: String!): Author!
  post(id: String!): Post!
}

type Mutation {
  createAuthor(input: NewAuthor!): Author!
  createPost(input: NewPost!): Post!
}

schema.resolvers.go

package graph

import (
	"context"
	"testproject/graph/model"
        "go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

var db = database.Connect()

func (r *mutationResolver) CreateAuthor(ctx context.Context, input model.NewAuthor) (*model.Author, error) {
        collection := db.client.Database("testproject").Collection("authors")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	res, err := collection.InsertOne(ctx, input)
	if err != nil {
		log.Fatal(err)
	}
	return &model.Author{
		ID:       res.InsertedID.(primitive.ObjectID).Hex(),
		Name:     input.Name,
	}
}

func (r *mutationResolver) CreatePost(ctx context.Context, input model.NewPost) (*model.Post, error) {
        collection := db.client.Database("testproject").Collection("posts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	res, err := collection.InsertOne(ctx, input)
	if err != nil {
		log.Fatal(err)
	}
	return &model.Post{
	         ID:         res.InsertedID.(primitive.ObjectID).Hex(),
                 Author:  // input.User ???
                 Title:      input.Title,
                 Text:       input.Text,
	}
}

func (r *queryResolver) Author(ctx context.Context, id string) (*model.Author, error) {
	ObjectID, err := primitive.ObjectIDFromHex(ID)
	if err != nil {
		log.Fatal(err)
	}
	collection := db.client.Database("testproject").Collection("authors")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	res := collection.FindOne(ctx, bson.M{"_id": ObjectID})
	author := model.Author{}
	res.Decode(&author)
	return &author
}

func (r *queryResolver) Post(ctx context.Context, id string) (*model.Post, error) {
	ObjectID, err := primitive.ObjectIDFromHex(ID)
	if err != nil {
		log.Fatal(err)
	}
	collection := db.client.Database("testproject").Collection("posts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	res := collection.FindOne(ctx, bson.M{"_id": ObjectID})
	post := model.Post{}
	res.Decode(&post)
	return &post
}

func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }

type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }