迁移到Apollo Kotlin 4

1
// Replace:
2
implementation("com.apollographql.apollo3:apollo-runtime:3.8.4")
3

4
// With:
5
implementation("com.apollographql.apollo:apollo-runtime:4.0.0")

1
// Replace:
2
plugins {
3
  id("com.apollographql.apollo3") version "3.8.4"
4
}
5

6
// With:
7
plugins {
8
  id("com.apollographql.apollo") version "4.0.0"
9
}

1
// Replace:
2
import com.apollographql.apollo3.ApolloClient
3
import com.apollographql.apollo3.*
4

5
// With:
6
import com.apollographql.apollo.ApolloClient
7
import com.apollographql.apollo.*

1
// Replace 
2
import com.apollographql.apollo3.mockserver.MockServer
3

4
// With
5
import com.apollographql.mockserver.MockServer

1
// Replace
2
try {
3
  val response = client.query(MyQuery()).execute()
4
  if (response.hasErrors()) {
5
    // Handle GraphQL errors
6
  } else {
7
    // No errors
8
    val data = response.data
9
    // ...
10
  }
11
} catch (e: ApolloException) {
12
  // Handle fetch errors
13
}
14

15
// With
16
val response = client.query(MyQuery()).execute()
17
if (response.data != null) {
18
  // Handle (potentially partial) data
19
} else {
20
  // Something wrong happened
21
  if (response.exception != null) {
22
    // Handle fetch errors
23
  } else {
24
    // Handle GraphQL errors in response.errors
25
  }
26
}

1
// Replace
2
client.subscription(MySubscription()).toFlow().collect { response ->
3
  if (response.hasErrors()) {
4
    // Handle GraphQL errors
5
  }
6
}.catch { e ->
7
  // Handle fetch errors
8
}
9

10
// With
11
client.subscription(MySubscription()).toFlow().collect { response ->
12
  val data = response.data
13
  if (data != null) {
14
    // Handle (potentially partial) data
15
  } else {
16
    // Something wrong happened
17
    if (response.exception != null) {
18
      // Handle fetch errors
19
    } else {
20
      // Handle GraphQL errors in response.errors
21
    }
22
  }
23
}

1
// Replace
2
apolloClient.query(query).watch()
3

4
// With
5
apolloClient.query(query).watch().filter { it.exception == null }

1
// Replace
2
if (exception is ApolloCompositeException) {
3
  val cacheMissException = exception.first
4
  val networkException = exception.second
5
}
6

7
// With
8
val cacheMissException = exception
9
val networkException = exception.suppressedExceptions.firstOrNull()

1
val apolloClient = ApolloClient.Builder()
2
    .serverUrl(mockServer.url())
3
    .addInterceptor(object : ApolloInterceptor {
4
      override fun <D : Operation.Data> intercept(request: ApolloRequest<D>, chain: ApolloInterceptorChain): Flow<ApolloResponse<D>> {
5
        return chain.proceed(request.newBuilder()
6
            .addHttpHeader("X-APOLLO-OPERATION-NAME", request.operation.name())
7
            .addHttpHeader("X-APOLLO-OPERATION-ID", request.operation.id())
8
            .build()
9
        )
10
      }
11
    })
12
    .build()

1
// Replace
2
val call = client.query(MyQuery())
3
  .httpHeaders(listOf("key", "value"))
4
  .execute()
5

6
// With
7
val call = client.query(MyQuery())
8
  .httpHeaders(listOf("key", "value"))
9
  .ignoreApolloClientHttpHeaders(true)
10
  .execute()

1
// feature1/build.gradle.kts
2

3
// Replace
4
dependencies {
5
  // ...
6

7
  // Get the generated schema types (and fragments) from the upstream schema module 
8
  apolloMetadata(project(":schema"))
9

10
  // You also need to declare the schema module as a regular dependency
11
  implementation(project(":schema"))
12
}
13

14
// With
15
dependencies {
16
  // ...
17
  
18
  // You still need to declare the schema module as a regular dependency
19
  implementation(project(":schema"))
20
}
21

22
apollo {
23
  service("service") {
24
    // ...
25

26
    // Get the generated schema types and fragments from the upstream schema module 
27
    dependsOn(project(":schema"))
28
  }
29
}

1
// schema/build.gradle.kts
2

3
// Replace
4
apollo {
5
  service("service") {
6
    // ...
7
    
8
    // Generate all the types in the schema module
9
    alwaysGenerateTypesMatching.set(listOf(".*"))
10

11
    // Enable generation of metadata for use by downstream modules 
12
    generateApolloMetadata.set(true)
13
  }
14
}
15

16
// With
17
apollo {
18
  service("service") {
19
    // ...
20

21
    // Enable generation of metadata for use by downstream modules 
22
    generateApolloMetadata.set(true)
23

24
    // Get used types from the downstream module1
25
    isADependencyOf(project(":feature1"))
26

27
    // Get used types from the downstream module2
28
    isADependencyOf(project(":feature2"))
29
    
30
    // ...
31
  }
32
}

1
dependencies {
2
  // Remove this 
3
  apolloUsedCoordinates(project(":feature1"))
4
}

1
publishing {
2
  publications {
3
    create("apollo", MavenPublication::class.java) {
4
      from(components["apollo"])
5
      artifactId = "${project.name}-apollo"
6
    }
7
  }
8
}

1
// Replace
2
customScalarsMapping.set(mapOf(
3
    "Date" to "kotlinx.datetime.LocalDate"
4
))
5

6
// With
7
mapScalar("Date", "kotlinx.datetime.LocalDate")
8

9
// Replace
10
customScalarsMapping.put("MyLong", "kotlin.Long")
11

12
// With
13
mapScalarToKotlinLong("MyLong")

1
// Replace (in your build scripts) 
2
val operationOutputGenerator = object: OperationOutputGenerator {
3
  override fun generate(operationDescriptorList: Collection<OperationDescriptor>): OperationOutput {
4
    return operationDescriptorList.associateBy {
5
      it.source.sha1()
6
    }
7
  }
8
  override val version: String = "v1"
9
}
10

11
// Or, if using OperationIdGenerator, replace
12
val operationIdGenerator = object: OperationIdGenerator {
13
  override fun apply(operationDocument: String, operationName: String): String {
14
    return operationDocument.sha1()
15
  }
16

17
  override val version: String = "v1"
18
}
19

20
// With (in your compiler plugin module) 
21
class MyPlugin: ApolloCompilerPlugin {
22
  override fun operationIds(descriptors: List<OperationDescriptor>): List<OperationId>? {
23
    return descriptors.map {
24
      OperationId(it.source.sha1(), it.name)
25
    }
26
  }
27
}

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

8
// With
9
apollo {
10
  service("service") {
11
    codegenModels.set("operationBased")
12
  }
13
}

1
// Replace
2
data.hero.asDroid
3

4
// With
5
data.hero.onDroid

1
// Replace
2
data.hero.fragments.heroDetails
3

4
// With
5
data.hero.heroDetails

1
// Replace
2
/**
3
 * {
4
 *   hero {
5
 *     # this condition is always true
6
 *     # allowing to merge the name field
7
 *     ... on Character {
8
 *       name
9
 *     }
10
 *   }
11
 * }
12
 */
13
data.hero.name
14

15
// With 
16
/**
17
 * name is not merged anymore
18
 */
19
data.hero.onCharacter?.name

1
// Replace
2
val data = AnimalDetailsImpl.Data {
3
  buildCat {
4
    name = "Noushka"
5
    species = "Maine Coon"
6
  }
7
}
8

9
// With
10
val data = AnimalDetailsImpl.Data(Cat) {
11
  name = "Noushka"
12
  species = "Maine Coon"
13
}

1
# Make sure `someEnum` isn't renamed to `SomeEnum`
2
enum someEnum @targetName(name: "someEnum"){
3
  A
4
  B
5
}

1
// Replace
2
import com.example.type.__Schema
3

4
// With
5
import com.example.schema.__Schema

1
# Replace
2
extend schema @link(url: "https://specs.apollo.dev/kotlin_labs/v0.1/", import: ["@typePolicy"])
3

4
# With
5
extend schema @link(url: "https://specs.apollo.dev/kotlin_labs/v0.3/", import: ["@typePolicy"])

1
query HeroName {
2
  hero {
3
    # WARNING: '@required' is not defined by the schema
4
    name @required
5
  }
6
}

1
directive @required on FIELD

1
// Replace
2
val myEnum = MyEnum.UNKNOWN__("foo")
3

4
// With
5
val myEnum = MyEnum.safeValueOf("foo")

1
// Replace
2
val apolloClient = ApolloClient.Builder()
3
  .serverUrl(...)
4
  .autoPersistedQueries(...)
5
  .normalizedCache(...)
6
  .build()
7

8
// With
9
val apolloClient = ApolloClient.Builder()
10
  .serverUrl(...)
11
  .normalizedCache(...)
12
  .autoPersistedQueries(...)
13
  .build()