How to map Set -> List

[dave-at-season]

Hello! First off, I understand the reasoning for not supporting the automatic mapping of Kotlin Sets to GraphQL List types as per the docs and the various issue/pr conversations around the topic.

But I am trying to add graphql to an existing Kotlin project that has a collection of domain objects defined as data classes which heavily use Sets. So I will need some way to do this and its not feasible for me to do this mapping manually. Currently I'm trying to do that by maintaining separate copies of these data classes and mapping all of their properties manually. For example:

data class DomainClient(
    val firstName: String,
    val lastName: String,
    // ... many more properties,
    val locations: Set<Location> = emptySet()
)
data class Client(
    val firstName: String,
    val lastName: String,
    // ... many more properties,
    val locations: List<Location> = emptyList()
)
fun clientFromDomain(c: DomainClient): Client = Client(
    firstName = c.firstName,
    lastName = c.lastName,
    // ... many more properties,
    locations = c.locations.toList()
)

@Provider
class ClientsQuery @Inject constructor(
    private val clientService: ClientService
) : Query {
    fun clients(context: CustomGraphQLContext): List<Client> {
        return clientService.getClients(context.user.accountId)
            .map { clientFromDomain(it) }
    }
}

Which is exceedingly yucky given the number of classes/fields I need to map across this project.

All I really want is a way to automate this mapping, I don't even necessarily want that reflected in the resulting schema. I'm fine with the schema outputting these fields as a List type, and then serializing/deserializing these fields into Sets behind the scenes as long as I don't have to do it manually.

It seems like functionality was introduced to accommodate this workflow as discussed in this issue: #584 but I don't understand how generateAdditionalTypes would be used here.

I would greatly appreciate any help on this

[dariuszkuc]

Hello 👋
I think the "simplest" way would be to follow the suggestion from #584 with small update -> with latest code you can just pass the additional types to the generator directly.

1. Create custom SchemaGeneratorHooks

override fun willGenerateGraphQLType(type: KType): GraphQLType? = when (type.classifier) {
  Set::class -> GraphQLList.list(GraphQLTypeReference.typeRef(type.getTypeOfFirstArgument().getSimpleName()))
  else -> super.willGenerateGraphQLType(type)
}

override fun isValidSuperclass(kClass: KClass<*>): Boolean {
  return if(kClass == Set::class) false else  super.isValidSuperclass(kClass)
}

2. Generate schema by explicitly passing additional Set types to ensure they get generated

val additionalTypes = mutableSetOf(MyClass::class.createType())
val generator = SchemaGenerator(config) // config should use your custom hooks from above
return generator.use {
    it.generateSchema(queries, mutations, subscriptions, additionalTypes)
}

[dariuszkuc]

If you do type ref then you have to ensure that underlying reference will be build (i.e. it is referenced from some other place in graph) - that is why those were explicitly added in my example.

[dave-at-season]

yep! I just noticed that trying to work this into the actual project I'm working on. It worked in this trivial example because the sets were of Strings, not generated types

[dave-at-season]

would y'all be open to a PR that allowed for optionally overriding isListType to include Set? That seems like the cleanest way to accomplish this to me

[smyrick]

@dave-at-season See the discussion here on why we don't support Set as a collection: #201

What if instead we updated the hooks willResolveMonad to be called on both properties and functions. That would be a backwards compatible change for everyone

[dave-at-season]

@smyrick yea I think that would be great

[TiKevin83]

For anyone who got here and was still confused, the example project has the current solution

class CustomSchemaGeneratorHooks() : SchemaGeneratorHooks {
    override fun willResolveMonad(type: KType): KType = when (type.classifier) {
        Set::class -> List::class.createType(type.arguments)
        else -> super.willResolveMonad(type)
    }
}

And then to use this in a spring server, this is also needed from the example project:

@Configuration
class GraphQLConfiguration {
  @Bean
  fun hooks() = CustomSchemaGeneratorHooks()
}

[tyrantkhan]

ooh i see there is a hook for input monads :) Need to also create! willResolveInputMonad

[coolbharat78]

Can we support reactor Flux also using same way? I wrote a MonadHook + custom fetcher but it complains for
Exception in thread "main" com.expediagroup.graphql.generator.exceptions.TypeNotSupportedException: Cannot convert reactor.core.publisher.Flux<com.example.Gues> since it is not a valid GraphQL type or outside the supported packages "[com.example]"

class MonadHooks : SchemaGeneratorHooks {
    override fun willResolveMonad(type: KType): KType = when (type.classifier) {
        Mono::class -> type.arguments.firstOrNull()?.type
        Flux::class -> List::class.createType(type.arguments)
        Flow::class -> List::class.createType(type.arguments)
        Set::class -> List::class.createType(type.arguments)
        else -> type
    } ?: type
}

class CustomFunctionDataFetcher(target: Any?, fn: KFunction<*>) : FunctionDataFetcher(target, fn) {
    override fun get(environment: DataFetchingEnvironment): Any? {
        val result = super.get(environment)
        when (result) {
            is Mono<*> -> return result.toFuture()
            is Flux<*> -> return result.log().collectList().toFuture()
            else -> return result
        }
    }
}

[smyrick]

The hooks should override Flux the same way as Set, just make sure the Flux::class you are mapping is infact the correct package and not some other Flux, like from coroutines vs Spring Flux

[coolbharat78]

qq. How will Flux and Mono work with dataloaders? Can I return a Flux or Mono from the dataloader or I have completely misunderstood dataloaders?
override fun getDataLoader(graphQLContext: GraphQLContext):
DataLoader<Pair<String, List>, Flux< User > =
DataLoaderFactory.newDataLoader { keys -> Flux.of(User())}

[smyrick]

I am not quite sure about that but the docs here describe how you can use Dataloader with Coroutines https://opensource.expediagroup.com/graphql-kotlin/docs/server/data-loader/#dataloaders-and-coroutines