Error messaging best practice

[SarloAkrobata]

Hi all,
Does anyone found a best way to make consistent error messaging (like permission or validation errors) raised by resolvers? (usage of ariadne with flask)

[maxmorlocke]

Example of how we do this on the django side: mirumee/ariadne-django#37

[rafalp]

For mutations making errors part of your schema is best approach. Here's Ariadne doc with examples.

For Query or Subscription, jury is still not out:

• Use built in error handler and just raise errors.
• Just return null, skip explicit errors and leave it to client to work out why nothing was returned when data was expected (because "XyZ doesn't exist or you don't have permission to see it" is good enough error message most of time).
• Use union types for returning errors (Twitter does that)

Speaking from experience, combination of errors in schema, nulls and using custom error formatter for things like missing auth/expired auth token most powerful:

• Errors in schema make things easy to work with for client devs, even if client dev is full-stack dev revisiting client code they've did months ago and don't remember details of anymore. They also enable things like returning error messages together with current state of the object that was mutated, eg. to roll-back optimistic update in the client and sync it with backend. Something you can't really do if you just raise an error.
• Errors in errors, if there's very limited number of cases supported, make it easy to implement custom boilerplate in client for things like rotating expired tokens.

I've found that if you follow "errors in schema" approach for mutations, those mutations start resembling Django's form views:

• they get and validate inputs against form (or different validator like Pydantic model)
• they load mutated object from database
• they return list of errors together with unchanged object OR they return empty errors list together with updated object

Here's example from my OS project where this pattern is clearly visible:

@post_reply_mutation.field("postReply")
@convert_kwargs_to_snake_case
@error_handler
async def resolve_post_reply(
    _, info: GraphQLResolveInfo, *, input: dict  # pylint: disable=redefined-builtin
):
    # Create pydantic model to use for validation and validate input against it
    input_model = create_input_model(info.context)
    cleaned_data, errors = validate_model(input_model, input)

    if cleaned_data.get("thread"):
        thread = await load_thread(info.context, cleaned_data["thread"])
    else:
        thread = None

    # If data types validation passed, validate data against database and business logic
    if cleaned_data:
        validators: Dict[str, List[Validator]] = {
            "thread": [
                ThreadExistsValidator(info.context),
                ThreadCategoryValidator(
                    info.context, CategoryIsOpenValidator(info.context)
                ),
                ThreadIsOpenValidator(info.context),
            ],
            ErrorsList.ROOT_LOCATION: [
                UserIsAuthorizedRootValidator(info.context),
            ],
        }
        cleaned_data, errors = await validate_input_data(info.context, validators, cleaned_data, errors)

    # Return errors list and unmodified Thread object to the client
    if errors:
        return {"errors": errors, "thread": thread}

    # Update database to post new reply to thread, then return updated thread and new post to client
    thread, post = post_reply(info.context, cleaned_data)
    return {"thread": thread, "post": post}