Using the Ktor Server Plugin, where is the place t...

# graphql-kotlin

[S.]

Using the Ktor Server Plugin, where is the place to add additional types like here ?

[Dariusz Kuc]

👋 currently i don't think it is possible

it is not exposed for spring one either (but there I guess you could provide your own schema instance)

whats your use case? (those extensions were primarily added for federation support so the referenced types may not be accessible through regular query/mutation paths)

[S.]

I see. I was trying to reference a GraphQL type from SchemaGeneratorHooks

[Dariusz Kuc]

fun didBuildSchema(builder: GraphQLSchema.Builder): GraphQLSchema.Builder = builder is the last hook that gives you access to the schema builder up to that point. There is no way to read out of the builder but you could build a schema and then transform it to add more stuff into it (thats what is done for federation)

*unsure whats your use case or what you are trying to do there

[S.]

My grand goal is to map Arrow's Either to union types in accordance to the "Error as Data" approach.

I hoped to just be able to add the union interfaces to my classes and use something like GraphQLTypeReference in hooks.

but I suppose I can achieve the same with GraphQLUnionType.newUnionType() and go this way.

[Dariusz Kuc]

haven't tried adding the support for the Either type but it should be doable through the hooks .... but most likely you will need to manually provide the mappings

first thing that pops to mind is the willGenerateGraphQLType hook -> https://github.com/ExpediaGroup/graphql-kotlin/blob/master/generator/graphql-kotli[…]iagroup/graphql/generator/internal/types/generateGraphQLType.kt
or willResolveMonad hook (https://github.com/ExpediaGroup/graphql-kotlin/blob/master/generator/graphql-kotli[…]pediagroup/graphql/generator/internal/types/generateProperty.kt)

[S.]

but is there any way to get my already defined classes as GraphQLObjectType so I can use them as possible types for the new union type? Redefining everything like this does not sound feasible

[Dariusz Kuc]

arent you trying to return Either? you would have to map those left and right values

i don't think there is anything automated atm that you could use

[S.]

yes, but I want both to be subtypes of the same union type.
so for example Either<NotFound, User> to union UserResponse = User | NotFound

whereas User is a predefined class with a bunch of fields/functions to query user's items

[Dariusz Kuc]

if User type is already defined in the schema then I think you could just use GraphQLTypeReference and graphql-java will update the ref before providing final schema

[S.]

When I tried that I got an NPE from some internal CheckNotNull method. I have to take a closer look at graphql-java itself

[Dariusz Kuc]

unsure

[S.]

Alright, NPE's gone though I'm not even sure what the issue was.

val graphqlDeckEither: GraphQLUnionType = GraphQLUnionType.newUnionType()
    .name("DeckEither")
    .possibleType(GraphQLTypeReference("Deck"))
    .possibleType(GraphQLTypeReference("NotFound"))
    .possibleType(GraphQLTypeReference("Unauthorized"))
    .typeResolver { env ->
        when (val value = env.getObject<Either<DomainError, Deck>>()) {
            is arrow.core.Either.Left -> {
                when (value.value) {
                    NotFound -> env.schema.getObjectType("NotFound")
                    Unauthorized -> env.schema.getObjectType("Unauthorized")
                    is Duplicate -> env.schema.getObjectType("Duplicate")
                    is InvalidInput -> env.schema.getObjectType("InvalidInput")
                }
            }

            is arrow.core.Either.Right -> env.schema.getObjectType("Deck")
        }
    }
    .build()

with this a union DeckEither = Deck | NotFound | Unauthorized is created as expected.
querying returns the correct types however I'm getting Exception while fetching data (/getDeck/title) : object is not an instance of declaring class when trying to access any properties of returned objects

[Dariusz Kuc]

Yeah for that i'm pretty sure you would need custom data fetcher to unwrap your results

[S.]

With this it works

class CustomDataFetcher(private val propertyGetter: KProperty.Getter<*>) : DataFetcher<Any?> {
    override fun get(environment: DataFetchingEnvironment): Any? {
        environment.getSource<Any?>().let { source ->
            return propertyGetter.call(getSourceValue(source))
        }
    }

    private fun getSourceValue(source: Any?): Any? = when (source) {
        is Either.Right<*> -> source.value
        is Either.Left<*> -> source.value
        else -> source
    }
}

class DataFetcherFactoryProvider : SimpleKotlinDataFetcherFactoryProvider() {
    override fun propertyDataFetcherFactory(kClass: KClass<*>, kProperty: KProperty<*>): DataFetcherFactory<Any?> =
        DataFetcherFactory {
            CustomDataFetcher(kProperty.getter)
        }
}

Thank you very much for your help!

[Dariusz Kuc]

🚀

[S.]

No, back at this mysterious npe blob upside down

Caused by: java.lang.NullPointerException
	at graphql.com.google.common.base.Preconditions.checkNotNull(Preconditions.java:903)
	at graphql.com.google.common.collect.ImmutableList$Builder.add(ImmutableList.java:815)
	at graphql.collect.ImmutableKit.map(ImmutableKit.java:56)
	at graphql.schema.GraphQLTypeResolvingVisitor.visitGraphQLUnionType(GraphQLTypeResolvingVisitor.java:38)
	at graphql.schema.GraphQLUnionType.accept(GraphQLUnionType.java:185)
	at graphql.schema.SchemaTraverser$TraverserDelegateVisitor.enter(SchemaTraverser.java:111)
	at graphql.util.Traverser.traverse(Traverser.java:144)
	at graphql.schema.SchemaTraverser.doTraverse(SchemaTraverser.java:98)
	at graphql.schema.SchemaTraverser.depthFirst(SchemaTraverser.java:88)
	at graphql.schema.SchemaTraverser.depthFirst(SchemaTraverser.java:81)
	at graphql.schema.impl.SchemaUtil.replaceTypeReferences(SchemaUtil.java:105)
	at graphql.schema.GraphQLSchema$Builder.buildImpl(GraphQLSchema.java:938)
	at graphql.schema.GraphQLSchema$Builder.build(GraphQLSchema.java:904)
	at com.expediagroup.graphql.generator.SchemaGenerator.generateSchema(SchemaGenerator.kt:88)
	at com.expediagroup.graphql.generator.SchemaGenerator.generateSchema$default(SchemaGenerator.kt:58)
	at com.expediagroup.graphql.generator.ToSchemaKt.toSchema(toSchema.kt:43)
	at com.expediagroup.graphql.plugin.schema.GenerateSDLKt.generateSDL(GenerateSDL.kt:97)
	at com.expediagroup.graphql.plugin.gradle.actions.GenerateSDLAction.execute(GenerateSDLAction.kt:38)

[Dariusz Kuc]

guessing it is caused by the order in which the types got processed

[S.]

so likely this custom union type is being processed before one of the ones I'm trying to reference with GraphQLTypeReference?

[Dariusz Kuc]

so those type visitors should be applied at the very end when creating the schema (at which point all the types should be available)

[Dariusz Kuc]

unsure whats happening there

[S.]

I can see a typeMap which contains some of my custom types however is missing all regular types. I tried to declare additionalTypes with the willBuildSchema hook (https://github.com/ExpediaGroup/graphql-kotlin/blob/716809e6a1842e36516c093cd848cd[…]om/expediagroup/graphql/generator/hooks/SchemaGeneratorHooks.kt) but it doesn't seem to be picked up either

[Dariusz Kuc]

Are you providing your custom hooks to the plugin?

[S.]

it's definitely there, yes

[Dariusz Kuc]

i meant -> did you configured https://opensource.expediagroup.com/graphql-kotlin/docs/plugins/hooks-provider?

[Dariusz Kuc]

otherwise plugin wont be able to locate your custom hooks

[S.]

oh yes, I did that. and I can also see my class in the config's hooks property
earlier with only UUID and LocalDateTime custom types/hooks it was working fine too

[Dariusz Kuc]

then unsure it "should" work the same

[S.]

so I just made a few debug queries (`

fun debugUser(): User? = null

`) for all possible union types - so doing this it works

[S.]

so I guess a possible workaround is to do this and find a hook at the very end where I can remove those queries again

[Dariusz Kuc]

If it works when you add those debug queries then it sounds like some ordering issue

[S.]

yep, presumably also explains why it "just disappeared" before

[S.]

no luck with removing those queries at the end of the building process.
I tried to remove them in didGenerateQueryObject as well as in didBuildSchema but it always results in the same NPE

[S.]

there are no introspection configs exposed by any chance? I cannot find anything other than the enabled boolean

[Dariusz Kuc]

what sort of config are you looking for? introspection is either enabled or not

[S.]

something like a schema object it uses so I can rip out the debug queries from there

[Dariusz Kuc]

schema modifications are enabled through various hooks, other than that you can build a schema and transform it afterwards

[Dariusz Kuc]

if you can provide a repro repository with the NPE i may be able to take a look over the weekend

[Dariusz Kuc]

it sounds like some ordering problem

[S.]

the issue is that up to the didBuildSchema hook, it seems to need those debug queries to reference the types correctly. so I cannot remove those. If I simply could remove those queries before passing the schema on to the user (introspection or sdl) I could live with it

[S.]

I will try to set up a repro

[Dariusz Kuc]

If I simply could remove those queries before passing the schema on to the user (introspection or sdl) I could live with it

you definitely should be able to do it in didBuildSchema -> pseudocode

val originalSchema = builder.build()
return originalSchema.transform {
  // remove the fields
}

[S.]

I tried this but it also results in the same npe

private var queryType: GraphQLObjectType? = null

    override fun didGenerateQueryObject(type: GraphQLObjectType): GraphQLObjectType {
        queryType = GraphQLObjectType.newObject()
            .name(type.name)
            .withAppliedDirectives(*type.appliedDirectives.toTypedArray())
            .fields(type.fieldDefinitions.filter { !it.name.contains("debug") })
            .build()

        return super.didGenerateQueryObject(type)
    }

    override fun didBuildSchema(builder: GraphQLSchema.Builder): GraphQLSchema.Builder {
        builder.query(queryType)
        return super.didBuildSchema(builder)
    }

(didGenerateQueryObject because I don't see a way to retrieve queryType from the Builder)

[Dariusz Kuc]

pretty sure this should work

override fun didBuildSchema(builder: GraphQLSchema.Builder): GraphQLSchema.Builder {
    val originalSchema = builder.build()
    val filteredQueries = originalSchema.queryType.fields.filter { it.name != "foo" }
    builder.query(originalSchema.queryType.transform {
        it.replaceFields(filteredQueries)
    })
    return builder
}

[Dariusz Kuc]

i.e.
val originalSchema = builder.build() <=== this would fail if there are some unresolved type references

that being said even with your filtering on the didGenerateQueryObject the result "should" be the same (as the types should already be processed at that time) -> there is some weird ordering issue going on there

[S.]

yeah, the second build() fails with the exception

[Dariusz Kuc]

without seeing the codebase hard to say -> definitely some ordering issue

[Dariusz Kuc]

if the second build fails it means that you got some dangling type references that don't get correctly resolved

[Dariusz Kuc]

so there is something going on with how the types are added to the schema, i.e. if you add debug queries => you get concrete type implementations

if you don't and only use your Either queries then you end up with references only

[Dariusz Kuc]

what is odd though is that by processing the debug queries you should get the types registered so it "should" be safe to remove those queries ... yet it blows up so something is off in how those types are added

[Dariusz Kuc]

so this "should" work

override fun didBuildSchema(builder: GraphQLSchema.Builder): GraphQLSchema.Builder {
    val originalSchema = builder.build()
    val filteredQueries = originalSchema.queryType.fields.filter { it.name != "foo" }
    val modifiedQuery = originalSchema.queryType.transform {
        it.replaceFields(filteredQueries)
    }
    return GraphQLSchema.newSchema(originalSchema).query(modifiedQuery)
}

but it doesn't solve the underlying issue

[S.]

the type reference issue makes sense. I will try again if providing additionalTypes could somehow help.
it certainly sounded like I can simply remove the debug queries afterwards but yeah.
already working on a repro

[Dariusz Kuc]

so the diff in the last code is that I modify the already build schema (so it shouldnt have any type references)

[Dariusz Kuc]

if that doesnt work then I have no idea and would need to do some debugging to figure it out

[S.]

still fails with the buildImpl call afterwards

[Dariusz Kuc]

then something is really fishy in how those types are added/processed

[S.]

https://github.com/TheDome0/graphql-ordering-repro

[S.]

(un)commenting the two debug.. queries in BookQueryService is what breaks or fixes it

[Dariusz Kuc]

the reason why it doesn't work is that you are just creating references to something that doesn't exist -> i.e. nothing else in the schema references those types so they won't be automatically created

if you add debug queries then the underlying types get created hence it works (i'd still say that transform of a build schema to drop those debug queries "should" work -> haven't looked into that piece but if would be something with the graphql-java itself)

[Dariusz Kuc]

so while various workarounds might be possible I think the "simplest" way would be to provide ktor server ability to add the additional types -> please open an issue to track it

[S.]

so essentially support what it says here https://opensource.expediagroup.com/graphql-kotlin/docs/schema-generator/customizing-schemas/advanced-features/#adding-custom-additional-types

[S.]

created an issue https://github.com/ExpediaGroup/graphql-kotlin/issues/1884