Code generation methods in Apollo Kotlin

Apollo Kotlin provides multiple code generation engines (codegens) that you can choose from depending on your use case:

To use a particular codegen, configure codegenModels in your Gradle scripts:

1
apollo {
2
  service("service") {
3
    // ...
4
    codegenModels.set("responseBased")
5
  }
6
}

The responseBased codegen

The responseBased codegen differs from the operationBased codegen in the following ways:

• Generated models have a 1:1 mapping with the JSON structure received in an operation's response.
• Polymorphism is handled by generating interfaces. Possible shapes are then defined as different classes that implement the corresponding interfaces.
• Fragments are also generated as interfaces.
• Any merged fields appear once in generated models.

Let's look at examples using fragments to highlight some of these differences.

Inline fragments

Consider this query:

1
query HeroForEpisode($ep: Episode!) {
2
  hero(episode: $ep) {
3
    name
4
    ... on Droid {
5
      primaryFunction
6
    }
7
    ... on Human {
8
      height
9
    }
10
  }
11
}

If we run the responseBased codegen on this operation, it generates a Hero interface with three implementing classes:

• DroidHero
• HumanHero
• OtherHero

Because Hero is an interface with different implementations, you can use a when clause to handle each different case:

1
when (hero) {
2
  is DroidHero -> println(hero.primaryFunction)
3
  is HumanHero -> println(hero.height)
4
  else -> {
5
    // Account for other Hero types (including unknown ones)
6
    // Note: in this example `name` is common to all Hero types
7
    println(hero.name)
8
  }
9
}

Accessors

As a convenience, the responseBased codegen generates methods with the name pattern as<ShapeName> (e.g., asDroid or asHuman) that enable you to avoid manual casting:

1
val primaryFunction = hero1.asDroid().primaryFunction
2
val height = hero2.asHuman().height

Named fragments

Consider this example:

1
query HeroForEpisode($ep: Episode!) {
2
    hero(episode: $ep) {
3
        name
4
        ...DroidFields
5
        ...HumanFields
6
    }
7
}
8

9
fragment DroidFields on Droid {
10
    primaryFunction
11
}
12

13
fragment HumanFields on Human {
14
    height
15
}

The responseBased codegen generates interfaces for the DroidFields and HumanFields fragments:

1
interface DroidFields {
2
  val primaryFunction: String
3
}
4

5
interface HumanFields {
6
  val height: Double
7
}

These interfaces are implemented by subclasses of the generated HeroForEpisodeQuery.Data.Hero (and other models for any operations using these fragments):

1
interface Hero {
2
  val name: String
3
}
4

5
data class DroidHero(
6
  override val name: String,
7
  override val primaryFunction: String
8
) : Hero, DroidFields
9

10
data class HumanHero(
11
  override val name: String,
12
  override val height: Double
13
) : Hero, HumanFields
14

15
data class OtherHero(
16
  override val name: String
17
) : Hero

This can be used like so:

1
when (hero) {
2
  is DroidFields -> println(hero.primaryFunction)
3
  is HumanFields -> println(hero.height)
4
}

Accessors

As a convenience, the responseBased codegen generates methods with the name pattern <fragmentName> (e.g., droidFields for a fragment named DroidFields). This enables you to chain calls together, like so:

1
val primaryFunction = hero1.droidFields().primaryFunction
2
val height = hero2.humanFields().height