How to handle exceptions in DgsReactiveCustomContextBuilderWithRequest

[bjoernmayer]

Heyho,

we have a quite heavy Custom GraphQLContext. We have implemented a DgsReactiveCustomContextBuilderWithRequest which also does some validation.

How shall we handle possible exceptions?

• If we let them bubble up the whole request fails with HTTP 400.
• If we catch the exception and return Mono.empty(), the custom context becomes null and code downstream, cannot handle a null custom context leading to NPEs
• If we return Mono.error() with the exception, the error is not handled and directly sent to the user. No proper error response

Any help would be helpful.

Thanks!

[srinivasankavitha]

Have you tried setting up your own custom exception handler for this? https://netflix.github.io/dgs/error-handling/#mapping-custom-exceptions

[bjoernmayer]

We do have a custom exception handler. Unfortunately, exceptions happening in the ContextBuilder are not caught by it.

Instead it is handled here:
https://github.com/Netflix/dgs-framework/blob/master/graphql-dgs-spring-webflux-autoconfigure/src/main/kotlin/com/netflix/graphql/dgs/webflux/handlers/DefaultDgsWebfluxHttpHandler.kt#L89

And from there on it isn't a proper gql error response anymore.
I find it strange, that errors handled in onErrorResume are not formatted according to the specification.

It would be nice, to either properly handle exceptions and format them or at least allow hooking into onErrorResume

Edit:
I was able to handle the exception by decorating the DefaultDgsReactiveQueryExecutor:

 @Bean
    open fun dgsWebfluxHttpHandler(
        dgsQueryExecutor: DgsReactiveQueryExecutor,
        @Qualifier("dgsObjectMapper") dgsObjectMapper: ObjectMapper
    ): DgsWebfluxHttpHandler {
        return DefaultDgsWebfluxHttpHandler(
            DgsReactiveQueryExecutorDecorator(dgsQueryExecutor),
            dgsObjectMapper
        )
    }

I then wrapped defaultDgsReactiveQueryExecutor.execute() in a try catch and now I can handle the exceptions.

It works. But it is way to complicated IMHO

[srinivasankavitha]

Couple more comments:
It seems that any validation should actually happen in an instrumentation class and not as part of the context building process. You could also add additional custom logic for data fetchers and transform the result into any custom responses : https://www.graphql-java.com/documentation/instrumentation#custom-instrumentation in instrumentExecutionResult.

In addition, you can also wrap your data fetchers in custom logic in the same instrumentation class and return a custom DataFetcherResult: https://www.graphql-java.com/documentation/execution#returning-data-and-errors.

I'm thinking one or a combination of the above methods should address your use case.

Usually graphql errors are returned after the request starts actual execution, and because this is part of the request building, the framework currently doesn't handle it.

Finally, we are in the process of moving to an implementation that integrates with spring-graphql, so that would have better support for Webflux features that we don't use internally, and hence don't maintain it as much. So you can try that out as well very soon.

Hope that helps.

[bjoernmayer]

I will give Instrumentation a try.
Looking at the SimpleFieldValidation it looks like the perfect spot for it.

Thank you for your input!

I am looking forward to the spring-graphql integration

[bjoernmayer]

For reference.
This is how I had to change it for v8.5:

class RequestErrorInterceptor : WebGraphQlInterceptor {
    override fun intercept(
        request: WebGraphQlRequest,
        chain: WebGraphQlInterceptor.Chain
    ): Mono<WebGraphQlResponse> = chain.next(request).onErrorResume { throwable -> 
        val typedGraphQLError = // build it somehow

        val executionResult = ExecutionResult.newExecutionResult()
            .addError(typedGraphQLError)
            .build()

        val executionGraphQlResponse = DefaultExecutionGraphQlResponse(
            request.toExecutionInput(),
            executionResult
        )

        Mono.just(WebGraphQlResponse(executionGraphQlResponse))
    }
}