How do I use custom error types?

[F21]

I noticed #49 supports custom errors. However, there is no documentation for how to use them.

I want to add a few extra fields to my errors.

Here's what I've done:

package main

import (
	"log"
	"net/http"

	"encoding/json"

	"fmt"

	"github.com/neelance/graphql-go"
	"github.com/neelance/graphql-go/errors"
)

type CustomErr struct {
	errors.QueryError
	Code         string `json:"code"`
	AnotherField string `json:"anotherField"`
}

var Schema = `
	schema {
		query: Query
		mutation: Mutation
	}

	type Query {
	}

	type Mutation {
		createReview(review: String!): Review
	}

	type Review {
		stars: Int!
	}
`

type Resolver struct{}

func (r *Resolver) CreateReview(args *struct {
	Review string
}) (*reviewResolver, error) {

	return nil, &CustomErr{
		Code:         "TEST_CODE",
		AnotherField: "TESTTEST",
		QueryError: errors.QueryError{
			Message: "test_error",
		},
	}
	//return &reviewResolver{5}, nil
}

type reviewResolver struct {
	stars int32
}

func (r *reviewResolver) Stars() int32 {
	return r.stars
}

type Handler struct {
	Schema *graphql.Schema
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

	var params struct {
		Query         string                 `json:"query"`
		OperationName string                 `json:"operationName"`
		Variables     map[string]interface{} `json:"variables"`
	}

	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	response := h.Schema.Exec(r.Context(), params.Query, params.OperationName, params.Variables)

	responseJSON, err := json.Marshal(response)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	fmt.Println(string(responseJSON))
	w.Write(responseJSON)
}

func main() {
	s, err := graphql.ParseSchema(Schema, &Resolver{})

	if err != nil {
		panic(err)
	}

	http.Handle("/", &Handler{Schema: s})

	log.Fatal(http.ListenAndServe(":13371", nil))
}

This is the response I get (custom fields missing):

{
  "data": {
    "createReview": null
  },
  "errors": [
    {
      "message": "graphql: test_error"
    }
  ]
}

[tonyghita]

Before you marshal the response to JSON, you have an opportunity to inspect the errors array.

response := h.Schema.Exec(r.Context(), params.Query, params.OperationName, params.Variables)
for _, err := range res.Errors {
  if err.ResolverError != nil {
    log.Println("my custom error:", err.ResolverError)
  }
}

You could then set the err.Message to err.ResolverError.Error() or whatever you fancy.

[F21]

Hey @tonyghita

Thanks for the example. However, I am still somewhat confused. @neelance suggested creating a custom error type for custom fields in #49 (comment)

In my case, I am using:

type CustomErr struct {
	errors.QueryError
	Code         string `json:"code"`
	AnotherField string `json:"anotherField"`
}

However, response.Errors is errors.QueryError and not an interface{}, so I cannot assert it as a CustomErr to get my Code and AnotherField fields back.

[tonyghita]

Each errors.QueryError in response.Errors has a field called ResolverError. That type will contain your CustomErr.

response := h.Schema.Exec(r.Context(), params.Query, params.OperationName, params.Variables)
for _, err := range res.Errors {
  if err.ResolverError != nil {
    if cErr, ok := err.ResolverError.(*CustomErr); ok {
       // do whatever you want with your *CustomErr named cErr
       err.Message = fmt.Sprintf("%s: %s", cErr.Code, cErr.AnotherField)
    } 
  }
}

I don't think the errors.QueryError defined on your CustomErr is useful as-is.

[F21]

@tonyghita

Thanks, that makes a lot of sense!