Do not compute key fields and key args when the Cache compiler plugin is present (#6797)

Author: BoD

libraries/apollo-ast/src/commonMain/kotlin/com/apollographql/apollo/ast/internal/SchemaValidationScope.kt

@@ -53,20 +53,34 @@ import com.apollographql.apollo.ast.withBuiltinDefinitions
  * @param addKotlinLabsDefinitions automatically import the kotlin_labs definitions, even if no `@link` is present. If [excludeCacheDirectives] is `true`, cache related directives are excluded.
  * @param foreignSchemas a list of known [ForeignSchema] that may or may not be imported depending on the `@link` directives
  * @param excludeCacheDirectives whether to exclude cache related directives when auto-importing the kotlin_labs definitions. Has no effect if [addKotlinLabsDefinitions] is `false`.
+ * @param computeKeyFields whether to compute cache key fields. Can be false when using the Apollo Cache compiler plugin to avoid unneeded computation.
  */
 @ApolloExperimental
 class SchemaValidationOptions(
     val addKotlinLabsDefinitions: Boolean,
     val foreignSchemas: List<ForeignSchema>,
     val excludeCacheDirectives: Boolean,
+    val computeKeyFields: Boolean,
 ) {
+  constructor(
+      addKotlinLabsDefinitions: Boolean,
+      foreignSchemas: List<ForeignSchema>,
+      excludeCacheDirectives: Boolean,
+  ) : this(
+      addKotlinLabsDefinitions = addKotlinLabsDefinitions,
+      foreignSchemas = foreignSchemas,
+      excludeCacheDirectives = excludeCacheDirectives,
+      computeKeyFields = true,
+  )
+
   constructor(
       addKotlinLabsDefinitions: Boolean,
       foreignSchemas: List<ForeignSchema>,
   ) : this(
       addKotlinLabsDefinitions = addKotlinLabsDefinitions,
       foreignSchemas = foreignSchemas,
       excludeCacheDirectives = false,
+      computeKeyFields = true,
   )
 }
 
@@ -339,7 +353,11 @@ internal fun validateSchema(definitions: List<GQLDefinition>, options: SchemaVal
   mergedScope.validateScalars()
   mergedScope.validateDirectiveDefinitions()
 
-  val keyFields = mergedScope.validateAndComputeKeyFields()
+  val keyFields = if (options.computeKeyFields) {
+    mergedScope.validateAndComputeKeyFields()
+  } else {
+    emptyMap()
+  }
 
   return GQLResult(
       Schema(

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/ApolloCompiler.kt

@@ -70,7 +70,14 @@ object ApolloCompiler {
   /**
    * The Cache plugin starts providing the cache directives in v1.0.0-alpha.7
    */
-  private fun String.hasCacheDirectives(): Boolean {
+  private val cacheCompilerPluginHasCacheDirectives: Boolean = cacheCompilerPluginVersion?.isAtLeastAlpha(7) == true
+
+  /**
+   * The Cache plugin starts computing key fields and key args in v1.0.0-alpha.8
+   */
+  private val cacheCompilerPluginComputesKeys: Boolean = cacheCompilerPluginVersion?.isAtLeastAlpha(8) == true
+
+  private fun String.isAtLeastAlpha(alpha: Int): Boolean {
     val parts = this.split('.', '-')
     val major = parts[0].toInt()
     if (major < 1) return false
@@ -83,7 +90,7 @@ object ApolloCompiler {
     val preRelease = parts[3]
     if (preRelease != "alpha") return true
     val alphaVersion = parts[4].toInt()
-    return alphaVersion >= 7
+    return alphaVersion >= alpha
   }
 
   fun buildCodegenSchema(
@@ -177,7 +184,11 @@ object ApolloCompiler {
             /**
              * If the cache compiler plugin is present and provides the cache directives, don't automatically import the cache related directives to avoid a conflict
              */
-            excludeCacheDirectives = cacheCompilerPluginVersion?.hasCacheDirectives() == true,
+            excludeCacheDirectives = cacheCompilerPluginHasCacheDirectives,
+            /**
+             * If the cache compiler plugin is present and computes key fields, don't compute them to save redundant work
+             */
+            computeKeyFields = !cacheCompilerPluginComputesKeys,
         )
     )
 
@@ -379,6 +390,7 @@ object ApolloCompiler {
     val irSchema = IrSchemaBuilder.build(
         schema = codegenSchema.schema,
         usedCoordinates = usedCoordinates,
+        computeKeyArgs = !cacheCompilerPluginComputesKeys,
     )
 
     val targetLanguage = defaultTargetLanguage(codegenOptions.targetLanguage, emptyList())

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/ir/IrSchema.kt

@@ -297,7 +297,7 @@ internal fun GQLInputObjectTypeDefinition.toIr(schema: Schema): IrInputObject {
   )
 }
 
-internal fun GQLInterfaceTypeDefinition.toIr(schema: Schema, usedCoordinates: UsedCoordinates): IrInterface {
+internal fun GQLInterfaceTypeDefinition.toIr(schema: Schema, usedCoordinates: UsedCoordinates, computeKeyArgs: Boolean): IrInterface {
   return IrInterface(
       name = name,
       implements = implementsInterfaces,
@@ -309,14 +309,14 @@ internal fun GQLInterfaceTypeDefinition.toIr(schema: Schema, usedCoordinates: Us
       fieldDefinitions = this.fieldDefinitions(schema).filter {
         usedCoordinates.hasField(type = name, field = it.name)
       }.mapNotNull {
-        it.toIrFieldDefinition(schema, name, usedCoordinates)
+        it.toIrFieldDefinition(schema, name, usedCoordinates, computeKeyArgs)
             // Only include fields that have arguments used in operations
             .takeIf { it.argumentDefinitions.isNotEmpty() }
       },
   )
 }
 
-internal fun GQLObjectTypeDefinition.toIr(schema: Schema, usedCoordinates: UsedCoordinates): IrObject {
+internal fun GQLObjectTypeDefinition.toIr(schema: Schema, usedCoordinates: UsedCoordinates, computeKeyArgs: Boolean): IrObject {
   return IrObject(
       name = name,
       implements = implementsInterfaces,
@@ -327,7 +327,7 @@ internal fun GQLObjectTypeDefinition.toIr(schema: Schema, usedCoordinates: UsedC
       fieldDefinitions = this.fieldDefinitions(schema).filter {
         usedCoordinates.hasField(type = name, field = it.name)
       }.mapNotNull {
-        it.toIrFieldDefinition(schema, name, usedCoordinates)
+        it.toIrFieldDefinition(schema, name, usedCoordinates, computeKeyArgs)
             // Only include fields that have arguments used in operations
             .takeIf { it.argumentDefinitions.isNotEmpty() }
       },
@@ -338,9 +338,10 @@ private fun GQLFieldDefinition.toIrFieldDefinition(
     schema: Schema,
     parentType: String,
     usedCoordinates: UsedCoordinates,
+    computeKeyArgs: Boolean,
 ): IrFieldDefinition {
   val typeDefinition = schema.typeDefinition(parentType)
-  val keyArgs = typeDefinition.keyArgs(name, schema)
+  val keyArgs = if (computeKeyArgs) typeDefinition.keyArgs(name, schema) else emptyList()
   return IrFieldDefinition(
       argumentDefinitions = arguments.mapNotNull {
         // We only include arguments that are used in operations

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/ir/IrSchemaBuilder.kt

@@ -13,6 +13,7 @@ internal object IrSchemaBuilder {
   fun build(
       schema: Schema,
       usedCoordinates: UsedCoordinates,
+      computeKeyArgs: Boolean,
   ): IrSchema {
 
     val irEnums = mutableListOf<IrEnum>()
@@ -65,10 +66,10 @@ internal object IrSchemaBuilder {
           irUnions.add(typeDefinition.toIr())
         }
         typeDefinition is GQLInterfaceTypeDefinition -> {
-          irInterfaces.add(typeDefinition.toIr(schema, mergedUsedCoordinates))
+          irInterfaces.add(typeDefinition.toIr(schema, mergedUsedCoordinates, computeKeyArgs))
         }
         typeDefinition is GQLObjectTypeDefinition -> {
-          irObjects.add(typeDefinition.toIr(schema, mergedUsedCoordinates))
+          irObjects.add(typeDefinition.toIr(schema, mergedUsedCoordinates, computeKeyArgs))
         }
       }
     }