Exclude auto-imported cache related directives when the Apollo cache plugin is present (#6766)

* Exclude auto-imported cache related directives when the Apollo cache plugin is present

* Don't break SchemaValidationOptions and check cache plugin version

* Minor and patch can't be negative

* Bogus comment

* Add kotlin_labs v0.3-noCache definitions

Author: BoD

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

@@ -8,6 +8,7 @@ import com.apollographql.apollo.ast.internal.builtinsDefinitionsStr
 import com.apollographql.apollo.ast.internal.compilerOptions_0_0
 import com.apollographql.apollo.ast.internal.compilerOptions_0_1_additions
 import com.apollographql.apollo.ast.internal.kotlinLabsDefinitions_0_3
+import com.apollographql.apollo.ast.internal.kotlinLabsDefinitions_0_3_no_cache
 import com.apollographql.apollo.ast.internal.kotlinLabsDefinitions_0_4
 import com.apollographql.apollo.ast.internal.linkDefinitionsStr
 import com.apollographql.apollo.ast.internal.nullabilityDefinitionsStr
@@ -127,6 +128,8 @@ fun kotlinLabsDefinitions(version: String): List<GQLDefinition> {
   return definitionsFromString(when (version) {
     // v0.3 has no behavior change over v0.2, so both versions map to the same definitions
     "v0.2", "v0.3" -> kotlinLabsDefinitions_0_3
+    // v0.3-noCache is the same as v0.3 without `@typePolicy` and `@fieldPolicy`
+    "v0.3-noCache" -> kotlinLabsDefinitions_0_3_no_cache
     // v0.4 doesn't have `@nonnull`
     "v0.4" -> kotlinLabsDefinitions_0_4
     // v0.5 adds `@map` and `@mapTo`
@@ -138,6 +141,8 @@ fun kotlinLabsDefinitions(version: String): List<GQLDefinition> {
 }
 
 internal val autoLinkedKotlinLabsForeignSchema = ForeignSchema("kotlin_labs", "v0.3", kotlinLabsDefinitions("v0.3"), listOf("optional", "nonnull"))
+internal val autoLinkedKotlinLabsForeignSchemaNoCache =
+  ForeignSchema("kotlin_labs", "v0.3-noCache", kotlinLabsDefinitions("v0.3-noCache"), listOf("optional", "nonnull"))
 
 /**
  * The foreign schemas supported by Apollo Kotlin.

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

@@ -38,6 +38,7 @@ import com.apollographql.apollo.ast.Schema
 import com.apollographql.apollo.ast.Schema.Companion.TYPE_POLICY
 import com.apollographql.apollo.ast.SourceLocation
 import com.apollographql.apollo.ast.autoLinkedKotlinLabsForeignSchema
+import com.apollographql.apollo.ast.autoLinkedKotlinLabsForeignSchemaNoCache
 import com.apollographql.apollo.ast.builtinDefinitions
 import com.apollographql.apollo.ast.canHaveKeyFields
 import com.apollographql.apollo.ast.findOneOf
@@ -49,14 +50,25 @@ import com.apollographql.apollo.ast.transform2
 import com.apollographql.apollo.ast.withBuiltinDefinitions
 
 /**
- * @param addKotlinLabsDefinitions automatically import all the kotlin_labs definitions, even if no `@link` is present
+ * @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`.
  */
 @ApolloExperimental
 class SchemaValidationOptions(
     val addKotlinLabsDefinitions: Boolean,
     val foreignSchemas: List<ForeignSchema>,
-)
+    val excludeCacheDirectives: Boolean,
+) {
+  constructor(
+      addKotlinLabsDefinitions: Boolean,
+      foreignSchemas: List<ForeignSchema>,
+  ) : this(
+      addKotlinLabsDefinitions = addKotlinLabsDefinitions,
+      foreignSchemas = foreignSchemas,
+      excludeCacheDirectives = false,
+  )
+}
 
 private fun ForeignSchema.asNonPrefixedImport(): LinkedSchema {
   return LinkedSchema(this, definitions, definitions.map { (it as GQLNamed).definitionName() }.associateBy { it }, null)
@@ -81,7 +93,13 @@ internal fun validateSchema(definitions: List<GQLDefinition>, options: SchemaVal
   val linkedSchemas = definitions.filterIsInstance<GQLSchemaExtension>().getLinkedSchemas(issues, options.foreignSchemas).toMutableList()
 
   if (options.addKotlinLabsDefinitions && linkedSchemas.none { it.foreignSchema.name == "kotlin_labs" }) {
-    linkedSchemas.add(autoLinkedKotlinLabsForeignSchema.asNonPrefixedImport())
+    linkedSchemas.add(
+        if (options.excludeCacheDirectives) {
+          autoLinkedKotlinLabsForeignSchemaNoCache
+        } else {
+          autoLinkedKotlinLabsForeignSchema
+        }.asNonPrefixedImport()
+    )
   }
 
   val typeDefinitions = mutableMapOf<String, GQLTypeDefinition>()
@@ -213,7 +231,7 @@ internal fun validateSchema(definitions: List<GQLDefinition>, options: SchemaVal
   importedDirectiveDefinitions.forEach { entry ->
     val existing = directiveDefinitions.get(entry.key)
     if (existing != null) {
-      if (entry.value.linkedSchema.foreignSchema == autoLinkedKotlinLabsForeignSchema) {
+      if (entry.value.linkedSchema.foreignSchema == autoLinkedKotlinLabsForeignSchema || entry.value.linkedSchema.foreignSchema == autoLinkedKotlinLabsForeignSchemaNoCache) {
         /*
          * This may be an auto-linked definition.
          * For compatibility reasons, it takes precedence over the user-provided ones.

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

@@ -132,6 +132,56 @@ internal val kotlinLabsDefinitions_0_3 = """
       | INPUT_OBJECT
 """.trimIndent()
 
+/**
+ * This is the same as `kotlinLabsDefinitions_0_3` without `@typePolicy` and `@fieldPolicy`.
+ */
+internal val kotlinLabsDefinitions_0_3_no_cache = """
+  ""${'"'}
+  Marks a field or variable definition as optional or required
+  By default Apollo Kotlin generates all variables of nullable types as optional, in compliance with the GraphQL specification,
+  but this can be configured with this directive, because if the variable was added in the first place, it's usually to pass a value
+  Since: 3.0.0
+  ""${'"'}
+  directive @optional(if: Boolean = true) on FIELD | VARIABLE_DEFINITION
+  
+  ""${'"'}
+  Marks a field as non-null. The corresponding Kotlin property will be made non-nullable even if the GraphQL type is nullable.
+  When used on an object definition in a schema document, `fields` must be non-empty and contain a selection set of fields that should be non-null
+  When used on a field from an executable document, `fields` must always be empty
+  
+  Setting the directive at the schema level is usually easier as there is little reason that a field would be non-null in one place
+  and null in the other
+  Since: 3.0.0
+  ""${'"'}
+  directive @nonnull(fields: String! = "") on OBJECT | FIELD
+  
+  ""${'"'}
+  Indicates that the given field, argument, input field or enum value requires
+  giving explicit consent before being used.
+  Since: 3.3.1
+  ""${'"'}
+  directive @requiresOptIn(feature: String!) repeatable
+  on FIELD_DEFINITION
+      | ARGUMENT_DEFINITION
+      | INPUT_FIELD_DEFINITION
+      | ENUM_VALUE
+  
+  ""${'"'}
+  Use the specified name in the generated code instead of the GraphQL name.
+  Use this for instance when the name would clash with a reserved keyword or field in the generated code.
+  This directive is experimental.
+  Since: 3.3.1
+  ""${'"'}
+  directive @targetName(name: String!)
+  on OBJECT
+      | INTERFACE
+      | ENUM
+      | ENUM_VALUE
+      | UNION
+      | SCALAR
+      | INPUT_OBJECT
+""".trimIndent()
+
 internal val kotlinLabsDefinitions_0_4 = """
 ""${'"'}
 Marks a field or variable definition as optional or required
@@ -588,4 +638,4 @@ directive @nonnull(fields: String! = "") on OBJECT | FIELD
 
 internal val disableErrorPropagationStr = """
 directive @experimental_disableErrorPropagation on QUERY | MUTATION | SUBSCRIPTION
-""".trimIndent()
+""".trimIndent()

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

@@ -59,6 +59,33 @@ object ApolloCompiler {
     fun error(message: String)
   }
 
+  private val cacheCompilerPluginVersion: String? = try {
+    Class.forName("com.apollographql.cache.apollocompilerplugin.VersionKt")
+        .getDeclaredField("VERSION")
+        .get(null) as String
+  } catch (_: Exception) {
+    null
+  }
+
+  /**
+   * The Cache plugin starts providing the cache directives in v1.0.0-alpha.7
+   */
+  private fun String.hasCacheDirectives(): Boolean {
+    val parts = this.split('.', '-')
+    val major = parts[0].toInt()
+    if (major < 1) return false
+    if (major > 1) return true
+    val minor = parts[1].toInt()
+    if (minor > 0) return true
+    val patch = parts[2].toInt()
+    if (patch > 0) return true
+    if (parts.size <= 3) return true
+    val preRelease = parts[3]
+    if (preRelease != "alpha") return true
+    val alphaVersion = parts[4].toInt()
+    return alphaVersion >= 7
+  }
+
   fun buildCodegenSchema(
       schemaFiles: List<InputFile>,
       logger: Logger?,
@@ -146,7 +173,11 @@ object ApolloCompiler {
              * TODO: switch to false
              */
             addKotlinLabsDefinitions = true,
-            builtinForeignSchemas() + foreignSchemas
+            foreignSchemas = builtinForeignSchemas() + foreignSchemas,
+            /**
+             * 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,
         )
     )
 
@@ -241,18 +272,12 @@ object ApolloCompiler {
      * If we detect that the cache compiler plugin is present, we skip adding the keyfields because it will do it.
      * TODO: deprecate `addTypename`
      */
-    val hasCacheCompilerPlugin = try {
-      Class.forName("com.apollographql.cache.apollocompilerplugin.internal.ApolloCacheCompilerPlugin")
-      true
-    } catch (_: ClassNotFoundException) {
-      false
-    }
-
-    var document = ApolloExecutableDocumentTransform(options.addTypename ?: defaultAddTypename, !hasCacheCompilerPlugin).transform(
-        schema = schema,
-        document = GQLDocument(userDefinitions, sourceLocation = null),
-        upstreamFragmentDefinitions
-    )
+    var document =
+      ApolloExecutableDocumentTransform(options.addTypename ?: defaultAddTypename, cacheCompilerPluginVersion == null).transform(
+          schema = schema,
+          document = GQLDocument(userDefinitions, sourceLocation = null),
+          upstreamFragmentDefinitions
+      )
 
     if (documentTransform != null) {
       document = documentTransform.transform(schema, document, upstreamFragmentDefinitions)