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

👋 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)

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

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

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.

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)

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

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

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

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

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

unsure

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

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

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!

🚀

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)

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

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

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

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

Are you providing your custom hooks to the plugin?

it's definitely there, yes

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

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

then unsure it "should" work the same

so I just made a few debug queries (`

fun debugUser(): User? = null

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

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

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

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

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

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

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

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
}

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)

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
}

yeah, the second build() fails with the exception

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

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

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

still fails with the buildImpl call afterwards

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

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)

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