/ GoLang

How to create a GraphQL API Server using Go (Golang)

I've written an example on how to develop a GraphQL API using Apollo Server. Using Apollo and NodeJS was quite straightforward. However, I wanted to use Go(Golang) for a new project I am working on. Initially, I hesitated in doing it in Go since it didn't look easy. After reading a few references and some perseverance, I managed to come up with an example on how to create a GraphQL using graphql-go, n implementation of GraphQL for Go / Golang.

There are a few interesting frameworks you can start with when building your GraphQL APIs using Go. Here are a few from GraphQL's website:

In this example, we'll be using graphql-go, the first one in the list. Let's start.  Full source code is available in my github repo https://github.com/donvito/go-graphql-server-example

Below is our main function. In the line 3, we are creating a GraphiQL Handler. This will enable GraphiQL for our api server so it doesn't not have to run separately.  GraphiQL is an in-browser tool for exploring GraphQL APIs. Later on, once we're done with the code, we'll be able to see how GraphiQL looks like.

Since we wanted our server to accept requests using http, we have created a server in line 10 running in port 3000 using the standard http package. We also need to handle GraphQL queries so we created a gqlHandler handler for it.

func main() {

	graphiqlHandler, err := graphiql.NewGraphiqlHandler("/graphql")
	if err != nil {
		panic(err)
	}

	http.Handle("/graphql", gqlHandler())
	http.Handle("/graphiql", graphiqlHandler)
	http.ListenAndServe(":3000", nil)
}
function main() in main.go

Below is the code for our handler. In this function, we receive the request and decode it to json. If there is an error in the parsing of the json, we return a HTTP error 400.

After that, the function processQuery() is called passing in the query.

func gqlHandler() http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Body == nil {
			http.Error(w, "No query data", 400)
			return
		}

		var rBody reqBody
		err := json.NewDecoder(r.Body).Decode(&rBody)
		if err != nil {
			http.Error(w, "Error parsing JSON request body", 400)
		}

		fmt.Fprintf(w, "%s", processQuery(rBody.Query))

	})
}
function gqlHandler in main.go

Here how our process Query() function looks like. We retrieve the data from a json file for now using the dataFromJSON() function but ideally, this should be querying a database. After getting the data we'll be using, we call gqlSchema(jobsData) which creates the GraphQL schema from our data.  jobsData is an slice of Job structs and contains the data from our json file.

func processQuery(query string) (result string) {

	jobsData := dataFromJSON()

	params := graphql.Params{Schema: gqlSchema(jobsData), RequestString: query}
	r := graphql.Do(params)
	if len(r.Errors) > 0 {
		fmt.Printf("failed to execute graphql operation, errors: %+v", r.Errors)
	}
	rJSON, _ := json.Marshal(r)

	return fmt.Sprintf("%s", rJSON)

}
function processQuery() in main.go

The GraphQL magic happens in the gqlSchema(jobsData) function. In this example, we have support for 2 queries, /jobs and jobs/{id}

/jobs - returns all jobs (line 3)
/jobs/{id} - supports a single argument id and returns a single job filtered by id (line 10)

The Resolvers for both functions are in line 6 and 18. Resolvers are responsible for returning the data for a query.

func gqlSchema(jobsData []Job) graphql.Schema {
	fields := graphql.Fields{
		"jobs": &graphql.Field{
			Type:        graphql.NewList(jobType),
			Description: "All Jobs",
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				return jobsData, nil
			},
		},
		"job": &graphql.Field{
			Type:        jobType,
			Description: "Get Jobs by ID",
			Args: graphql.FieldConfigArgument{
				"id": &graphql.ArgumentConfig{
					Type: graphql.Int,
				},
			},
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				id, success := params.Args["id"].(int)
				if success {
					for _, job := range jobsData {
						if int(job.ID) == id {
							return job, nil
						}
					}
				}
				return nil, nil
			},
		},
	}
	rootQuery := graphql.ObjectConfig{Name: "RootQuery", Fields: fields}
	schemaConfig := graphql.SchemaConfig{Query: graphql.NewObject(rootQuery)}
	schema, err := graphql.NewSchema(schemaConfig)
	if err != nil {
		fmt.Printf("failed to create new schema, error: %v", err)
	}

	return schema

}

Run the GraphQL API server

git clone https://github.com/donvito/go-graphql-server-example.git
cd go-graphql-server-example/src/cmd/server/
go run main.go

Access GraphiQL after running the server

http://localhost:3000/graphiql

That's it! We've now created a GraphQL API using Go.

Full source code is available in my github repo.
https://github.com/donvito/go-graphql-server-example

References

https://github.com/graphql-go/graphql
https://github.com/friendsofgo/graphiql
https://graphql.org/code/#go

Cheers! Hope this helps anyone who is starting out with GraphQL!

For more updates my new blog posts, you can follow me in Twitter @donvito and GitHub.  I also share code in my GitHub. If you want to know more about what I do, please add me in LinkedIn. I recently started a new youtube channel - I upload some tutorials there as well. Check it out!

I'm also looking for remote/contractual software development projects.
http://www.melvinvivas.com/looking-for-remote-software-development-work-outsource/