Make it impossible to pass as input some type which was generated only to preserve forwards compatibility but was not meant to be used as input

[StylianosGakis]

Use case

For a schema which contains these

type Mutation {
    someMutation(input: SomeInput!): Irrelevant!
}

input SomeInput {
    otherField: ID!
    enumInput: SomeEnum
}

enum SomeEnum {
    FOO,
    BAR,
}

Apollo-kotlin generates this code for SomeEnum:

public enum class SomeEnum(
  public val rawValue: String,
) {
  FOO("FOO"),
  BAR("BAR"),
  /**
   * Auto generated constant for unknown enum values
   */
  UNKNOWN__("UNKNOWN__"),
  ;

  public companion object {
    public val type: EnumType = EnumType("SomeEnum", listOf("FOO", "BAR"))

    public fun safeValueOf(rawValue: String): ChatMessageContext =
        values().find { it.rawValue == rawValue } ?: UNKNOWN__

    /**
     * Returns all [SomeEnum] known at compile time
     */
    public fun knownValues(): Array<SomeEnum> = arrayOf(
      FOO,
      BAR,
    )
  }
}

This makes it possible in user code to try and pass to a mutation this:

apolloClient.mutation(SomeMutation(input = SomeInput(otherField = ..., enumInput = SomeEnum.UNKNOWN__))

This however will always fail on the backend validation since this entry is not part of the real schema, and there is nothing to map it to.

Describe the solution you'd like

The problem here is just that this is possible and the compiler is not warning us about trying to run something that would never work.

Optimally, this code should not compile in the first place.
If this turns out to be way too complicated, even a lint warning or something similar might be a good first step. But as of right now making this mistake is unfortunately something that can happen silently.

[martinbonnin]

For the record, a possible solution is to use sealedClassesForEnumsMatching.set(listOf(".*")) (probably make it the default in v4) and have the UNKNOWN__(rawValue) constructor be annotated with an @OptIn annotation so that it's harder to call from user code.

[BoD]

Heads up that we added the @OptIn annotation to the unknown constructor in #5813. This should be available in the v4 snapshots shortly!

For now we haven't decided on making sealed classes for enums the default in v4.

[BoD]

After some back and forth, in #5904 we ended up removing the @OptIn annotation, and instead removed the UNKNOWN__ constructor. Now safeValueOf should be used in the rare case where one needs to construct unknown values.

[BoD]

Closing as this is available to try with the v4 betas.

[github-actions]

Do you have any feedback for the maintainers? Please tell us by taking a one-minute survey. Your responses will help us understand Apollo Kotlin usage and allow us to serve you better.