Validate argument in many mutations

[huehnerlady]

Hi,

we have a bunch of mutations all get an argument as a string. This argument has always the same name. We want to validate that this string must not be blank.

How is the easiest way to do that?

Example
We have for example these mutations:

@Service
class TestMutation: Mutation {

  fun foo(input: String): BasicResponse {
    return BasicResponse("foo was called")
  }

  fun foo2(input: String): BasicResponse {
    return BasicResponse("foo2 was called")
  }
}

I want to return a GraphQlError if input is blank. Of course I can always add a if(input.isBlank() into all mutations, but is there a more generic point where I can do that?

We use the schema generation with a CustomSchemaGenerationHook so I was hoping maybe there is a place where we can validate this input argument?

val schema = toSchema(
        config = SchemaGeneratorConfig(
            supportedPackages = listOf("foo", "bar"),
            hooks = CustomSchemaGeneratorHooks(),
            dataFetcherFactoryProvider = JacksonKotlinDataFetcherFactoryProvider(objectMapper), // custom as graphql-kotlin does not support jackson anymore 
        ),
        queries = listOf(TopLevelObject(placeholderQuery)), //we just have mutations but on query is mandatory, so it is this one
        mutations = listOf(
            TopLevelObject(testMutation),
            TopLevelObject(test2Mutation)
        )
    )

class CustomSchemaGeneratorHooks : SchemaGeneratorHooks {

  override fun willGenerateGraphQLType(type: KType): GraphQLType? {
    return when (type.javaType) {
      Foo::class.java -> graphQlFooScalar
      else -> null
    }
  }

  override fun isValidProperty(kClass: KClass<*>, property: KProperty<*>): Boolean {
    // do something
    return super.isValidProperty(kClass, property)
  }
}

[samuelAndalon]

Hello, have you take a look at GraphQL java instrumentations ? https://www.graphql-java.com/documentation/instrumentation/

that might be what you are looking for, with the begin execution execution field you can have access to the arguments and apply validation over them, then you could return your error from there and apply the instrumentation to the specific GraphQL operations you want.

[huehnerlady]

Thanks for your reply. I did start implementing an instrumation in the hope that the exceptions there are caught in GraphQL Errors like when fetching data, unfortunately they are wrapped in a java.util.concurrent.CompletionException and actually thrown. So that was a very hacky way to then catch this specific Exception 😞

[huehnerlady]

I had a closer look in the link you send and there they throw a specific graphql.execution.AbortExecutionException. If I let my Exception inherit from that one it gets forwarded the way I want it to work. Many thanks 👍🏻

[dariuszkuc]

Hello 👋
While you would still have to repeat the same info in all places, IMHO the "cleanest" way to validate those constraints would be to use javax.validation.NotBlank annotations. See https://github.com/ExpediaGroup/graphql-kotlin/blob/master/examples/server/spring-server/src/main/kotlin/com/expediagroup/graphql/examples/server/spring/query/ValidatedQuery.kt for example usage.

[huehnerlady]

@dariuszkuc thanks for your answer. I was hoping in a more elegant way. We have several mutations with all the same input and so I was hoping I could add that validation at a central point instead of at every single mutation.

From your answer I gather that there is no such point?

[dariuszkuc]

You definitely could do it within a single location (e.g. as Sam mentioned above using instrumentations or even a custom data fetcher that validates the arguments) but IMHO those solutions would be more complex and implicitly add behavior that could be confusing to the future maintainers. I'd prefer an explicit solution where it is clear from the code what is the expected behavior.