Custom errors raised by resolvers are not formatted

I’m attempting to mimic a couple of the errors in apollo-server, and want to include a code value in the extensions, as such:

class AuthenticationError(Exception):
    @property
    def formatted(self) -> dict:
        return {"message": self.message, "extensions": {"code": "UNAUTHENTICATED",}}

def throwError(_, info: ResolveInfo):
    raise AuthenticationError("dummy auth error")

After much stack debugging, I discovered that python’s graphql.error.located_error.located_error() is wrapping my custom child class in a new instance of GraphQLError, so its formatted property is never accessed by ariadne.

According to the ariadne error-messaging documentation, the default formatter “Unwraps GraphQL error by accessing its original_error property”. And while I realize that in the code this is happening exactly in the order described in the docs, this also means that the formatted = error.formatted is being called on the result of located_error() rather than the original one that was thrown.

Additionally, when I hook the debugger into format_error, it shows that my original error is actually double-wrapped, and only accessible by drilling two layers deep via error.original_error.original_error (the first level error.original_error is another GraphQLError … not quite sure where the double-wrapping got added)

It feels like there is a bug in here somewhere (especially with that nested original_error), but it’s certainly the case where the documentation could use some work explaining what actually happens under the hood, since as written, it sounds like it should be possible to just add a formatted property on an error and expect it to be reported to the API (which is definitely not the case).

[rafalp]

I’ve tried reproducing Apollo’s errors approach in past and I don’t remember it ever being nearly as troublesome as you are describing it, eg. I’ve never had to touch formatter logic in order to get those errors to work.

So I’ve did a quick test and it turns out I was wrong: you aren’t supposed to extend GraphQLError in your exception, extending regular Exception does the trick just fine:

from ariadne import QueryType, make_executable_schema
from ariadne.asgi import GraphQL


class AuthenticationError(Exception):
    extensions = {"code": "UNAUTHENTICATED"}


type_def = """
    type Query {
        field: Boolean
    }
"""

query_type = QueryType()


@query_type.field("field")
def counter_resolver(*_):
    raise AuthenticationError("PLEASE LOGIN")


schema = make_executable_schema(type_def, query_type)
app = GraphQL(schema, debug=True)

GraphQL response:

{
  "data": {
    "field": null
  },
  "errors": [
    {
      "message": "PLEASE LOGIN",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": [
        "field"
      ],
      "extensions": {
        "code": "UNAUTHENTICATED",
        "exception": {
          "stacktrace": [
            "Traceback (most recent call last):",
            "  File \"/Users/rafalpiton/github/ariadne/venv/lib/python3.7/site-packages/graphql/execution/execute.py\", line 625, in resolve_field_value_or_error",
            "    result = resolve_fn(source, info, **args)",
            "  File \"./errortest.py\", line 21, in counter_resolver",
            "    raise AuthenticationError(\"PLEASE LOGIN\")",
            "errortest.AuthenticationError: PLEASE LOGIN"
          ],
          "context": {
            "_": "(None, GraphQLResolv...0x105cee080>}))"
          }
        }
      }
    }
  ]
}

And same query with DEBUG=False:

{
  "data": {
    "field": null
  },
  "errors": [
    {
      "message": "PLEASE LOGIN",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": [
        "field"
      ],
      "extensions": {
        "code": "UNAUTHENTICATED"
      }
    }
  ]
}

You also don’t need to write any custom formatting logic for this because when query executor wraps exception in GraphQLError, it does graphql_error.extensions = original_error.extensions, effectively passing error code data up to error formatter.

[rafalp]

@nilansaha this is not related to this issue. Please ask question on discussions instead.