Use published version of the Java support libs (#5991)

* Use published version of the Java support libs

* Deprecate Java support modules

* Generate Java/Guava Optional adapters instead of expecting them from the Java client dependency

* Remove integration tests that were moved to the java-support repo

* Update libraries/apollo-api-java/README.md

Co-authored-by: Martin Bonnin <[email protected]>

* Fix artifact id in readmes

* Fix artifact id in code

---------

Co-authored-by: Martin Bonnin <[email protected]>

Author: BoD

gradle/libraries.toml

@@ -77,7 +77,6 @@ apollo-normalizedcache-incubating-snapshot = { group = "com.apollographql.cache"
 apollo-normalizedcache-sqlite = { group = "com.apollographql.apollo3", name = "apollo-normalized-cache-sqlite", version.ref = "apollo" }
 apollo-normalizedcache-sqlite-incubating = { group = "com.apollographql.cache", name = "normalized-cache-sqlite-incubating", version.ref = "apollo-normalizedcache-incubating" }
 apollo-normalizedcache-sqlite-incubating-snapshot = { group = "com.apollographql.cache", name = "normalized-cache-sqlite-incubating", version.ref = "apollo-normalizedcache-incubating-snapshot" }
-apollo-rx2-support-java = { group = "com.apollographql.apollo3", name = "apollo-rx2-support-java", version.ref = "apollo" }
 apollo-plugin = { group = "com.apollographql.apollo3", name = "apollo-gradle-plugin", version.ref = "apollo" }
 apollo-runtime = { group = "com.apollographql.apollo3", name = "apollo-runtime", version.ref = "apollo" }
 apollo-compiler = { group = "com.apollographql.apollo3", name = "apollo-compiler", version.ref = "apollo" }
@@ -89,9 +88,7 @@ apollo-execution-gradle-plugin = { group = "com.apollographql.execution", name =
 # Used by the apollo-tooling project which uses a published version of Apollo
 apollo-runtime-published = { group = "com.apollographql.apollo3", name = "apollo-runtime", version.ref = "apollo-published" }
 apollo-annotations = { group = "com.apollographql.apollo3", name = "apollo-annotations", version.ref = "apollo" }
-apollo-runtime-java = { group = "com.apollographql.apollo3", name = "apollo-runtime-java", version.ref = "apollo" }
 apollo-engine-ktor = { group = "com.apollographql.apollo3", name = "apollo-engine-ktor", version.ref = "apollo" }
-apollo-rx3-java = { group = "com.apollographql.apollo3", name = "apollo-rx3-support-java", version.ref = "apollo" }
 apollo-testingsupport = { group = "com.apollographql.apollo3", name = "apollo-testing-support", version.ref = "apollo" }
 # Used by the apollo-tooling project which uses a published version of Apollo
 apollo-testingsupport-published = { group = "com.apollographql.apollo3", name = "apollo-testing-support", version.ref = "apollo-published" }

libraries/apollo-api-java/README.md

@@ -1,3 +1,3 @@
 # Module apollo-api-java
 
-apollo-api-java contains adapters for Java Optional values. 
+This module has been moved to the [Java Support](https://github.com/apollographql/apollo-kotlin-java-support) repository and published under `com.apollographql.java:client`. Please update your dependencies.

libraries/apollo-compiler/api/apollo-compiler.api

@@ -558,6 +558,8 @@ public final class com/apollographql/apollo3/compiler/codegen/ResolverKeyKind :
 	public static final field Fragment Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
 	public static final field FragmentSelections Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
 	public static final field FragmentVariablesAdapter Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
+	public static final field JavaOptionalAdapter Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
+	public static final field JavaOptionalAdapters Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
 	public static final field MapType Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
 	public static final field Model Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;
 	public static final field ModelAdapter Lcom/apollographql/apollo3/compiler/codegen/ResolverKeyKind;

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/LayoutImpl.kt

@@ -157,6 +157,10 @@ internal fun SchemaLayout.typeUtilPackageName() = "${schemaPackageName()}.type.u
 
 internal fun SchemaLayout.paginationPackageName() = "${schemaPackageName()}.pagination"
 internal fun SchemaLayout.schemaSubPackageName() = "${schemaPackageName()}.schema"
+
+internal fun SchemaLayout.javaOptionalAdapterClassName() = "OptionalAdapter"
+internal fun SchemaLayout.javaOptionalAdaptersClassName() = "OptionalAdapters"
+
 internal fun ExecutableSchemaLayout.executionPackageName() = "${schemaPackageName()}.execution"
 
 internal fun OperationsLayout.operationAdapterPackageName(filePath: String) = "${executableDocumentPackageName(filePath)}.adapter"

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/Resolver.kt

@@ -34,6 +34,8 @@ enum class ResolverKeyKind {
   CustomScalarAdapters,
   Pagination,
   ArgumentDefinition,
+  JavaOptionalAdapter,
+  JavaOptionalAdapters,
 }
 
 @Serializable

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/java/JavaClassNames.kt

@@ -81,10 +81,6 @@ internal object JavaClassNames {
    * ClassNames for kotlin files turned into java classes
    */
   val Adapters = ClassName.get(apolloApiPackageName, "Adapters")
-  val JavaOptionalAdapter = ClassName.get("com.apollographql.apollo3.api.java.adapter", "JavaOptionalAdapter")
-  val JavaOptionalAdapters = ClassName.get("com.apollographql.apollo3.api.java.adapter", "JavaOptionalAdapters")
-  val GuavaOptionalAdapter = ClassName.get("com.apollographql.apollo3.api.java.adapter", "GuavaOptionalAdapter")
-  val GuavaOptionalAdapters = ClassName.get("com.apollographql.apollo3.api.java.adapter", "GuavaOptionalAdapters")
   val BooleanExpressions = ClassName.get(apolloApiPackageName, "BooleanExpressions")
   val Assertions = ClassName.get(apolloApiPackageName, "Assertions")
   val JsonReaders = ClassName.get(apolloApiJsonPackageName, "JsonReaders")

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/java/JavaCodegen.kt

@@ -13,6 +13,8 @@ import com.apollographql.apollo3.compiler.codegen.OperationsLayout
 import com.apollographql.apollo3.compiler.codegen.ResolverKey
 import com.apollographql.apollo3.compiler.codegen.ResolverKeyKind
 import com.apollographql.apollo3.compiler.codegen.SchemaLayout
+import com.apollographql.apollo3.compiler.codegen.java.adapters.JavaOptionalAdapterBuilder
+import com.apollographql.apollo3.compiler.codegen.java.adapters.JavaOptionalAdaptersBuilder
 import com.apollographql.apollo3.compiler.codegen.java.operations.FragmentBuilder
 import com.apollographql.apollo3.compiler.codegen.java.operations.FragmentDataAdapterBuilder
 import com.apollographql.apollo3.compiler.codegen.java.operations.FragmentModelsBuilder
@@ -168,6 +170,10 @@ internal object JavaCodegen {
         // When using the Guava optionals, generate assertOneOf in the project, as apollo-api doesn't depend on Guava
         builders.add(UtilAssertionsBuilder(context))
       }
+      if (context.nullableFieldStyle == JavaNullable.JAVA_OPTIONAL || context.nullableFieldStyle == JavaNullable.GUAVA_OPTIONAL) {
+        builders.add(JavaOptionalAdapterBuilder(context, context.nullableFieldStyle))
+        builders.add(JavaOptionalAdaptersBuilder(context))
+      }
       irSchema.irUnions.forEach { irUnion ->
         builders.add(UnionBuilder(context, irUnion))
         if (generateDataBuilders) {

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/java/JavaResolver.kt

@@ -51,16 +51,14 @@ internal class JavaResolver(
     else -> JavaClassNames.Optional
   }
 
-  private val optionalAdapterClassName: ClassName = when (nullableFieldStyle) {
-    JavaNullable.JAVA_OPTIONAL -> JavaClassNames.JavaOptionalAdapter
-    JavaNullable.GUAVA_OPTIONAL -> JavaClassNames.GuavaOptionalAdapter
+  private fun getOptionalAdapterClassName(): ClassName = when (nullableFieldStyle) {
+    JavaNullable.JAVA_OPTIONAL, JavaNullable.GUAVA_OPTIONAL -> resolveJavaOptionalAdapter()
     else -> JavaClassNames.ApolloOptionalAdapter
   }
 
-  private val optionalOrNullableAdapterClassName: ClassName = when (nullableFieldStyle) {
+  private fun getOptionalOrNullableAdapterClassName(): ClassName = when (nullableFieldStyle) {
     JavaNullable.APOLLO_OPTIONAL -> JavaClassNames.ApolloOptionalAdapter
-    JavaNullable.JAVA_OPTIONAL -> JavaClassNames.JavaOptionalAdapter
-    JavaNullable.GUAVA_OPTIONAL -> JavaClassNames.GuavaOptionalAdapter
+    JavaNullable.JAVA_OPTIONAL, JavaNullable.GUAVA_OPTIONAL -> resolveJavaOptionalAdapter()
     else -> JavaClassNames.NullableAdapter
   }
 
@@ -185,8 +183,7 @@ internal class JavaResolver(
 
   fun adapterInitializer(type: IrType, requiresBuffering: Boolean): CodeBlock {
     return if (type.optional) {
-      val adapterClassName = if (!type.rawType().isComposite()) optionalAdapterClassName else optionalAdapterClassName
-      return CodeBlock.of("new $T<>($L)", adapterClassName, adapterInitializer(type.optional(false), requiresBuffering))
+      return CodeBlock.of("new $T<>($L)", getOptionalAdapterClassName(), adapterInitializer(type.optional(false), requiresBuffering))
     } else if (type.catchTo != IrCatchTo.NoCatch) {
       error("Java codegen does not support @catch")
     } else if (type.nullable) {
@@ -203,8 +200,7 @@ internal class JavaResolver(
         }
 
         else -> {
-          val adapterClassName = if (!type.rawType().isComposite()) optionalOrNullableAdapterClassName else optionalOrNullableAdapterClassName
-          CodeBlock.of("new $T<>($L)", adapterClassName, adapterInitializer(type.nullable(false), requiresBuffering))
+          CodeBlock.of("new $T<>($L)", getOptionalOrNullableAdapterClassName(), adapterInitializer(type.nullable(false), requiresBuffering))
         }
       }
     } else {
@@ -214,7 +210,7 @@ internal class JavaResolver(
         }
 
         is IrScalarType -> {
-          scalarAdapterInitializer(type.name, customScalarAdapters)
+          scalarAdapterInitializer(type.name)
         }
 
         is IrEnumType -> {
@@ -243,7 +239,7 @@ internal class JavaResolver(
   }
 
   private fun resolveScalarTarget(name: String): ClassName? {
-    return scalarMapping.get(name)?.targetName?.let {
+    return scalarMapping[name]?.targetName?.let {
       ClassName.bestGuess(it)
     }
   }
@@ -252,7 +248,7 @@ internal class JavaResolver(
     return CodeBlock.of("$T.$type", resolveAndAssert(ResolverKeyKind.SchemaType, name))
   }
 
-  private fun scalarAdapterInitializer(name: String, customScalarAdapters: String): CodeBlock {
+  private fun scalarAdapterInitializer(name: String): CodeBlock {
     return when (val adapterInitializer = scalarMapping[name]?.adapterInitializer) {
       is ExpressionAdapterInitializer -> {
         CodeBlock.of(adapterInitializer.expression)
@@ -305,16 +301,10 @@ internal class JavaResolver(
         adapterNamePrefix = "ApolloOptional"
       }
 
-      JavaNullable.JAVA_OPTIONAL -> {
-        // Ex: JavaOptionalAdapters.JavaOptionalStringAdapter
-        className = JavaClassNames.JavaOptionalAdapters
-        adapterNamePrefix = "JavaOptional"
-      }
-
-      JavaNullable.GUAVA_OPTIONAL -> {
-        // Ex: GuavaOptionalAdapters.GuavaOptionalStringAdapter
-        className = JavaClassNames.GuavaOptionalAdapters
-        adapterNamePrefix = "GuavaOptional"
+      JavaNullable.JAVA_OPTIONAL, JavaNullable.GUAVA_OPTIONAL -> {
+        // Ex: OptionalAdapters.OptionalStringAdapter
+        className = resolveJavaOptionalAdapters()
+        adapterNamePrefix = "Optional"
       }
 
       else -> {
@@ -396,7 +386,7 @@ internal class JavaResolver(
       is IrListType2 -> adapterInitializer2(type.ofType)?.listAdapter(isComposite = type.ofType.isCompositeOrWrappedComposite())
       is IrScalarType2 -> {
         if (scalarMapping.containsKey(type.name)) {
-          scalarAdapterInitializer(type.name, customScalarAdapters)
+          scalarAdapterInitializer(type.name)
         } else {
           null
         }
@@ -427,6 +417,12 @@ internal class JavaResolver(
 
   fun registerArgumentDefinition(id: String, className: ClassName) = register(ResolverKeyKind.ArgumentDefinition, id, className)
   fun resolveArgumentDefinition(id: String): ClassName = resolveAndAssert(ResolverKeyKind.ArgumentDefinition, id)
+
+  fun registerJavaOptionalAdapter(className: ClassName) = register(ResolverKeyKind.JavaOptionalAdapter, "", className)
+  fun resolveJavaOptionalAdapter() = resolveAndAssert(ResolverKeyKind.JavaOptionalAdapter, "")
+
+  fun registerJavaOptionalAdapters(className: ClassName) = register(ResolverKeyKind.JavaOptionalAdapters, "", className)
+  fun resolveJavaOptionalAdapters() = resolveAndAssert(ResolverKeyKind.JavaOptionalAdapters, "")
 }
 
 

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/java/adapters/JavaOptionalAdapterBuilder.kt

@@ -0,0 +1,105 @@
+package com.apollographql.apollo3.compiler.codegen.java.adapters
+
+import com.apollographql.apollo3.compiler.JavaNullable
+import com.apollographql.apollo3.compiler.codegen.Identifier
+import com.apollographql.apollo3.compiler.codegen.Identifier.customScalarAdapters
+import com.apollographql.apollo3.compiler.codegen.Identifier.fromJson
+import com.apollographql.apollo3.compiler.codegen.Identifier.reader
+import com.apollographql.apollo3.compiler.codegen.Identifier.value
+import com.apollographql.apollo3.compiler.codegen.Identifier.writer
+import com.apollographql.apollo3.compiler.codegen.java.CodegenJavaFile
+import com.apollographql.apollo3.compiler.codegen.java.JavaClassBuilder
+import com.apollographql.apollo3.compiler.codegen.java.JavaClassNames
+import com.apollographql.apollo3.compiler.codegen.java.JavaSchemaContext
+import com.apollographql.apollo3.compiler.codegen.java.T
+import com.apollographql.apollo3.compiler.codegen.javaOptionalAdapterClassName
+import com.apollographql.apollo3.compiler.codegen.typeAdapterPackageName
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.FieldSpec
+import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.ParameterizedTypeName
+import com.squareup.javapoet.TypeSpec
+import com.squareup.javapoet.TypeVariableName
+import javax.lang.model.element.Modifier
+
+internal class JavaOptionalAdapterBuilder(
+    private val context: JavaSchemaContext,
+    private val nullableFieldStyle: JavaNullable,
+) : JavaClassBuilder {
+  private val packageName = context.layout.typeAdapterPackageName()
+  private val simpleName = context.layout.javaOptionalAdapterClassName()
+
+  override fun prepare() {
+    context.resolver.registerJavaOptionalAdapter(ClassName.get(packageName, simpleName))
+  }
+
+  override fun build(): CodegenJavaFile {
+    return CodegenJavaFile(
+        packageName = packageName,
+        typeSpec = javaOptionalAdapterTypeSpec()
+    )
+  }
+
+  private fun javaOptionalAdapterTypeSpec(): TypeSpec {
+    val t = TypeVariableName.get("T")
+    val javaOptional = when (nullableFieldStyle) {
+      JavaNullable.JAVA_OPTIONAL -> JavaClassNames.JavaOptional
+      JavaNullable.GUAVA_OPTIONAL -> JavaClassNames.GuavaOptional
+      else -> error("Unsupported nullableFieldStyle: $nullableFieldStyle")
+    }
+    val javaOptionalT = ParameterizedTypeName.get(javaOptional, t)
+    val adapterT = ParameterizedTypeName.get(JavaClassNames.Adapter, t)
+    val adapterOptionalT = ParameterizedTypeName.get(JavaClassNames.Adapter, javaOptionalT)
+
+    val wrappedAdapterField = FieldSpec.builder(adapterT, "wrappedAdapter", Modifier.PRIVATE, Modifier.FINAL).build()
+
+    val constructor = MethodSpec.constructorBuilder()
+        .addModifiers(Modifier.PUBLIC)
+        .addParameter(adapterT, "wrappedAdapter")
+        .addStatement("this.wrappedAdapter = wrappedAdapter")
+        .build()
+
+    val absentFunName = when (nullableFieldStyle) {
+      JavaNullable.JAVA_OPTIONAL -> "empty"
+      JavaNullable.GUAVA_OPTIONAL -> "absent"
+      else -> error("Unsupported nullableFieldStyle: $nullableFieldStyle")
+    }
+    val fromJson = MethodSpec.methodBuilder(fromJson)
+        .addException(JavaClassNames.IOException)
+        .addAnnotation(JavaClassNames.Override)
+        .addModifiers(Modifier.PUBLIC)
+        .addParameter(JavaClassNames.JsonReader, reader)
+        .addParameter(JavaClassNames.CustomScalarAdapters, customScalarAdapters)
+        .returns(javaOptionalT)
+        .beginControlFlow("if ($reader.peek() == $T.Token.NULL)", JavaClassNames.JsonReader)
+        .addStatement("$reader.skipValue()")
+        .addStatement("return $T.$absentFunName()", javaOptional)
+        .endControlFlow()
+        .addStatement("return $T.of(wrappedAdapter.fromJson($reader, $customScalarAdapters))", javaOptional)
+        .build()
+
+    val toJson = MethodSpec.methodBuilder(Identifier.toJson)
+        .addException(JavaClassNames.IOException)
+        .addAnnotation(JavaClassNames.Override)
+        .addModifiers(Modifier.PUBLIC)
+        .addParameter(JavaClassNames.JsonWriter, writer)
+        .addParameter(JavaClassNames.CustomScalarAdapters, customScalarAdapters)
+        .addParameter(javaOptionalT, value)
+        .beginControlFlow("if (!$value.isPresent())")
+        .addStatement("$writer.nullValue()")
+        .nextControlFlow("else")
+        .addStatement("wrappedAdapter.toJson($writer, $customScalarAdapters, $value.get())")
+        .endControlFlow()
+        .build()
+
+    return TypeSpec.classBuilder(simpleName)
+        .addModifiers(Modifier.PUBLIC)
+        .addTypeVariable(t)
+        .addSuperinterface(adapterOptionalT)
+        .addField(wrappedAdapterField)
+        .addMethod(constructor)
+        .addMethod(fromJson)
+        .addMethod(toJson)
+        .build()
+  }
+}

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo3/compiler/codegen/java/adapters/JavaOptionalAdaptersBuilder.kt

@@ -0,0 +1,69 @@
+package com.apollographql.apollo3.compiler.codegen.java.adapters
+
+import com.apollographql.apollo3.compiler.codegen.java.CodegenJavaFile
+import com.apollographql.apollo3.compiler.codegen.java.JavaClassBuilder
+import com.apollographql.apollo3.compiler.codegen.java.JavaClassNames
+import com.apollographql.apollo3.compiler.codegen.java.JavaSchemaContext
+import com.apollographql.apollo3.compiler.codegen.java.T
+import com.apollographql.apollo3.compiler.codegen.javaOptionalAdaptersClassName
+import com.apollographql.apollo3.compiler.codegen.typeAdapterPackageName
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.FieldSpec
+import com.squareup.javapoet.ParameterizedTypeName
+import com.squareup.javapoet.TypeSpec
+import javax.lang.model.element.Modifier
+
+internal class JavaOptionalAdaptersBuilder(private val context: JavaSchemaContext) : JavaClassBuilder {
+  private val packageName = context.layout.typeAdapterPackageName()
+  private val simpleName = context.layout.javaOptionalAdaptersClassName()
+
+  override fun prepare() {
+    context.resolver.registerJavaOptionalAdapters(ClassName.get(packageName, simpleName))
+  }
+
+  override fun build(): CodegenJavaFile {
+    return CodegenJavaFile(
+        packageName = packageName,
+        typeSpec = javaOptionalAdaptersTypeSpec()
+    )
+  }
+
+  private fun javaOptionalAdaptersTypeSpec(): TypeSpec {
+    val optionalAdapter = context.resolver.resolveJavaOptionalAdapter()
+    val stringAdapter = ParameterizedTypeName.get(optionalAdapter, JavaClassNames.String)
+    val doubleAdapter = ParameterizedTypeName.get(optionalAdapter, JavaClassNames.Double)
+    val intAdapter = ParameterizedTypeName.get(optionalAdapter, JavaClassNames.Integer)
+    val booleanAdapter = ParameterizedTypeName.get(optionalAdapter, JavaClassNames.Boolean)
+    val anyAdapter = ParameterizedTypeName.get(optionalAdapter, JavaClassNames.Object)
+
+    val stringAdapterField = FieldSpec.builder(stringAdapter, "OptionalStringAdapter", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+        .initializer("new $T($T.StringAdapter)", stringAdapter, JavaClassNames.Adapters)
+        .build()
+
+    val doubleAdapterField = FieldSpec.builder(doubleAdapter, "OptionalDoubleAdapter", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+        .initializer("new $T($T.DoubleAdapter)", doubleAdapter, JavaClassNames.Adapters)
+        .build()
+
+    val intAdapterField = FieldSpec.builder(intAdapter, "OptionalIntAdapter", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+        .initializer("new $T($T.IntAdapter)", intAdapter, JavaClassNames.Adapters)
+        .build()
+
+    val booleanAdapterField =
+      FieldSpec.builder(booleanAdapter, "OptionalBooleanAdapter", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+          .initializer("new $T($T.BooleanAdapter)", booleanAdapter, JavaClassNames.Adapters)
+          .build()
+
+    val anyAdapterField = FieldSpec.builder(anyAdapter, "OptionalAnyAdapter", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+        .initializer("new $T($T.AnyAdapter)", anyAdapter, JavaClassNames.Adapters)
+        .build()
+
+    return TypeSpec.classBuilder(simpleName)
+        .addModifiers(Modifier.PUBLIC)
+        .addField(stringAdapterField)
+        .addField(doubleAdapterField)
+        .addField(intAdapterField)
+        .addField(booleanAdapterField)
+        .addField(anyAdapterField)
+        .build()
+  }
+}