Having 422 HTTP status code when you send Query requests from Apollo client

[rkunhi]

What happened?

Getting 422 http status code error message on all query calls from Apollo client to gqlgen graphql server. Apollo client works fine when I query Apollo Graphql server.
Error Message
Objects are not valid as a React child (found: Error: Response not successful: Received status code 422). If you meant to render a collection of children, use an array instead.

What did you expect?

Query calls be executed as expected return the result with any error message

Minimal graphql.schema and models to reproduce

type Test {
name; String
}

query {
Testnow: Test
}

Resolver:
Just return Test Model. Very simple

versions

• gqlgen version?
  0.12.2
• go version?
  1.15
• dep or go modules?
  go modules

[dstotijn]

I don't think there's an issue. When there's an error before query execution (e.g. when the query is validated against a schema), gqlgen returns a 422 Unprocessable Entity status. If the query is valid but an error is returned from a resolver, gqlgen will respond with a 200 OK status. This seems to be the adopted behaviour in other projects like express-graphql (the reference server for GraphQL over HTTP I believe) and apollo-server as well. Please check out this and this for more context and reasoning.

Error handling in Apollo Client (v3.0) treats HTTP responses with valid JSON but a status >= 300 as a generic network/server error (ref). This is a safe fallback which aligns with the proposed spec for how GraphQL over HTTP should work:

"For any non-2XX response, the client should not rely on the body to be in GraphQL format since the source of the response may not be the GraphQL server but instead some intermediary such as API gateways, firewalls, etc."

(ref)

It would be nice though if Apollo Client first attempts to parse the HTTP response body as GraphQL errors and only if that fails fallback and handle it as a generic network error.

TL;DR: It's perfectly fine for a GraphQL server to respond with a 4xx code when there's a syntax/validation error that occurs before query execution. It's also (probably) expected that Apollo Client treats statuses >= 300 as generic network/server errors, although it would be nice if it first attempts to parse them as GraphQL errors.

[geertjanvdk]

Sending HTTP errors codes is a thing done by RESTful APIs; it goes against the GraphQL spirit. HTTP is just the transport, so let us keep status codes out of the GraphQL (different OSI layer). Can do it over FTP as well!

Anyway, gqlgen offers the possibility to override this. This makes it easier to use with tools like, for example, Apollo Rover CLI. If there is something wrong with the schema (e.g. it misses some directives), you would just get a bad, incomprehensible 422:

E004: HTTP status client error (422 Unprocessable Entity) for url (http://127.0.0.1:8082/api) while resolving the schema for the 'myserivce' subgraph
            Make sure the endpoint is accepting connections and is spelled correctly

Note the message about accepting connections, but since the client gets a 4xx, it thinks something is wrong with the transport.

You can change this behavior by using errcode.RegisterErrorType:

import gqlgenerrcode "github.com/99designs/gqlgen/graphql/errcode"

// somewhere before creating the gqlgen 'router' object
gqlgenerrcode.RegisterErrorType(gqlgenerrcode.ValidationFailed, gqlgenerrcode.KindUser)

Now the GraphQL world and its clients will be happy and show a much better error:

    E007: This endpoint doesn't support subgraph introspection via the Query._service field while resolving the schema for the 'myserivce' subgraph
            Try running the command on a valid federated graph, or use the appropriate `rover graph` command instead of `rover subgraph`.

Maybe it can be added to the gqlgen configuration? Changing how it works now is going to break things :)

Alternatively, if you want keep pestering GraphQL clients with HTTP Status Codes, you can add an error presenter:

	h.SetErrorPresenter(func(ctx context.Context, err error) *gqlerror.Error {
		var gqlErr *gqlerror.Error
		if errors.As(err, &gqlErr) {
                         // do some logging here <----
			return gqlErr
		}
		return gqlerror.WrapPath(graphql.GetPath(ctx), err)
	})

Hope this helps!