A modern programming language that makes developers happier.

kotlinlang

are there any docs/examples for how union types are treated in Apollo Kotlin?

hmm I don't think we have specific docs, but the result is essentially the same as with interfaces. So basically you need to use fragments for the different possible cases.

Sort of related question....to support this new union type we're going from something like

```    components {
        ...componentInfo
    }```
to

```    elements {
        ... on Component { ...componentInfo }
    }```
Instead of having `Component` type we now have `OnComponent` .....is there some way to keep/generate that `Component` type?

I don't think so :sweat_smile:. That model's name is based on the field's name - but it is gone? You should see an `Element` model though. But it looks like it's not just the fields that have changed, but also the structure?  So I don't think you'll avoid the rename here.

It would just allow not having to change quite a lot of code that currently expects `Component` type....but that's fine.....that's what refactoring tools are for :slightly_smiling_face:

Both `Component` before (and `OnComponent` now) contain same info (componentInfo)

haha yeah :slightly_smiling_face: Maybe you can even use "structural search and replace" (but last few times I tried, it failed me..., a good old regexp was the solution)

had wondered maybe if there was some kind of alias feature

but as you say the structure would be different

so, if you use an alias in the query, that will also change the name of the model

```   components: elements {
        ... on Component { ...componentInfo }
   }```
But I think that may be very confusing in the end :slightly_smiling_face:  Maybe it can help as an intermediary refactoring step.

have started using this and right now handling by checking if various values in union are null or not......looks like there's way to setup use of sealed interfaces....and, related to that, is it possible to do that only in some cases or is it a global option?

You may be thinking of the <https://www.apollographql.com/docs/kotlin/advanced/response-based#the-responsebased-codegen|response based> codegen? If so, it's a global affair.

ah, ok.....yeah, switching to that would be very significant change at this point.....think I'll stick to way we're handling them right now :smiley:

is that the general approach used when dealing with union types like this (when not using response based codegen)?

&gt;  switching to that would be very significant change
Yeah :slightly_smiling_face: also there are a few caveats.

&gt; is that the general approach used
Yes I think that's it. I mean you can also look at the value of `__typename` but that may actually be less typesafe? Or maybe it's the same... in both cases what's missing is a way to be sure to be exhaustive I guess?

and just generally more idiomatic I guess

it's fine though....it's only a small thing