Change "Apollo Android" to "Apollo Kotlin" in code and internal docs (#3668)

Author: BoD

CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# Contributing to Apollo Android
+# Contributing to Apollo Kotlin
 
 The Apollo team welcomes contributions of all kinds, including bug reports, documentation, test cases, bug fixes, and
 features.
@@ -62,7 +62,7 @@ Java interop
 * If some extensions do not make sense in Java, mark them with `@JvmName("-$methodName")` to hide them from Java
 
 Logging & Error messages
-* Apollo Android must not log anything to System.out or System.err
+* Apollo Kotlin must not log anything to System.out or System.err
 * Error messages are passed to the user through `Exception.message`
 * For debugging logs, APIs are provided to get diagnostics (like CacheMissException, HttpInfo, ...). APIs are better defined and allow more fine-grained diagnostics. 
 * There is one exception for the Gradle plugin. It is allowed to log information though the lifecycle() methods. 
@@ -84,7 +84,7 @@ Please note that we will not accept pull requests for style changes.
 
 ## API compatibility
 
-Apollo Android observes [semantic versioning](https://semver.org/). Between major releases, breaking changes are not
+Apollo Kotlin observes [semantic versioning](https://semver.org/). Between major releases, breaking changes are not
 allowed and any public API change will fail the build.
 
 If that happens, you will need to run `./gradlew apiDump` and check for any incompatible changes before commiting these
@@ -94,7 +94,7 @@ files.
 
 Using Kotlin's (or other dependencies') experimental or internal APIs, such as the ones marked
 with `@ExperimentalCoroutinesApi` should be avoided as much as possible (exceptions can be made for native/JS targets only when no other option is
-available). Indeed, applications using a certain version of Apollo Android could use a more up-to-date version of these
+available). Indeed, applications using a certain version of Apollo Kotlin could use a more up-to-date version of these
 APIs than the one used when building the library, causing crashes or other issues.
 
 We also have the `@ApolloExperimental` annotation which can be used to mark APIs as experimental, for instance when

README.md

@@ -1,5 +1,5 @@
 
-# Apollo Android
+# Apollo Kotlin
 
 [![GitHub license](https://img.shields.io/badge/license-MIT-lightgrey.svg?maxAge=2592000)](https://raw.githubusercontent.com/apollographql/apollo-android/main/LICENSE)
 [![Join the community](https://img.shields.io/discourse/status?label=Join%20the%20community&server=https%3A%2F%2Fcommunity.apollographql.com)](http://community.apollographql.com/new-topic?category=Help&tags=mobile,client)
@@ -8,9 +8,9 @@
 [![Maven Central](https://img.shields.io/maven-central/v/com.apollographql.apollo3/apollo-api)](https://repo1.maven.org/maven2/com/apollographql/apollo3/)
 [![OSS Snapshots](https://img.shields.io/nexus/s/com.apollographql.apollo3/apollo-api?server=https%3A%2F%2Foss.sonatype.org&label=oss-snapshots)](https://oss.sonatype.org/content/repositories/snapshots/com/apollographql/apollo3/)
 
-Apollo Android is a GraphQL client that generates Kotlin and Java models from GraphQL queries.
+Apollo Kotlin is a GraphQL client that generates Kotlin and Java models from GraphQL queries.
 
-Apollo Android executes queries and mutations against a GraphQL server and returns results as query-specific Kotlin types. This means you don't have to deal with parsing JSON, or passing around `Map`s and making clients cast values to the right type manually. You also don't have to write model types yourself, because these are generated from the GraphQL definitions your UI uses.
+Apollo Kotlin executes queries and mutations against a GraphQL server and returns results as query-specific Kotlin types. This means you don't have to deal with parsing JSON, or passing around `Map`s and making clients cast values to the right type manually. You also don't have to write model types yourself, because these are generated from the GraphQL definitions your UI uses.
 
 Because generated types are query-specific, you can only access data that you actually specify as part of a query. If you don't ask for a particular field in a query, you can't access the corresponding property on the returned data structure.
 
@@ -34,7 +34,7 @@ This library is designed primarily with Android in mind, but you can use it in a
 
 ## Multiplatform
 
-Apollo Android is a [Kotlin Multiplatform](https://kotlinlang.org/docs/multiplatform.html) project.
+Apollo Kotlin is a [Kotlin Multiplatform](https://kotlinlang.org/docs/multiplatform.html) project.
 
 Here's the current matrix of supported features per platform:
 
@@ -70,7 +70,7 @@ Check [the project website](https://www.apollographql.com/docs/android/) for in
 
 If you are new to GraphQL, check out [the tutorial](https://www.apollographql.com/docs/android/v3/tutorial/00-introduction/) that will guide you through building an Android app using Apollo, Kotlin and coroutines.
 
-If you'd like to add Apollo Android to an existing project, follow these steps:
+If you'd like to add Apollo Kotlin to an existing project, follow these steps:
 
 Add the plugin to your `build.gradle.kts`:
 
@@ -96,12 +96,12 @@ apollo {
 }
 ```
 
-Apollo Android supports three types of files:
+Apollo Kotlin supports three types of files:
 - `.graphqls` schema files: describes the types in your backend using the GraphQL syntax.  
 - `.json` schema files: describes the types in your backend using the Json syntax.
 - `.graphql` executable files: describes your queries and operations in the GraphQL syntax.
 
-By default, Apollo Android requires a schema in your module's `src/main/graphql` directory. You can download a schema using introspection with the `./gradlew downloadApolloSchema` task. Sometimes introspection is disabled and you will have to ask your backend team to provide a schema. Copy this schema to your module:
+By default, Apollo Kotlin requires a schema in your module's `src/main/graphql` directory. You can download a schema using introspection with the `./gradlew downloadApolloSchema` task. Sometimes introspection is disabled and you will have to ask your backend team to provide a schema. Copy this schema to your module:
 
 ```
 cp ${schema} ${module}/src/main/graphql/ 
@@ -133,7 +133,7 @@ Build your project, this will generate a `HeroQuery` class that you can use with
   println("Hero.name=${response.data?.hero?.name}")
 ```
 
-**To learn more about other Apollo Android APIs:**
+**To learn more about other Apollo Kotlin APIs:**
 
 * Execute your first [mutation](https://www.apollographql.com/docs/android/v3/essentials/mutations/)
 * Handle [custom scalar types](https://www.apollographql.com/docs/android/v3/essentials/custom-scalars/)
@@ -204,9 +204,9 @@ If you'd like to contribute, please see [Contributing.md](https://github.com/apo
 
 ## Additional resources
 
-- [MortyComposeKMM](https://github.com/joreilly/MortyComposeKMM): A Kotlin Multiplatform Github template using Apollo Android, SwiftUI and Jetpack Compose.
+- [MortyComposeKMM](https://github.com/joreilly/MortyComposeKMM): A Kotlin Multiplatform Github template using Apollo Kotlin, SwiftUI and Jetpack Compose.
 - [A journey to Kotlin multiplatform](https://www.youtube.com/watch?v=GN6LHrqyimI): how the project was moved to Kotlin multiplatform, talk given at Kotliners in June 2020.
-- [#125, Fragmented Podcast](http://fragmentedpodcast.com/episodes/125/): Why's and How's about Apollo Android and the entire journey.
+- [#125, Fragmented Podcast](http://fragmentedpodcast.com/episodes/125/): Why's and How's about Apollo Kotlin and the entire journey.
 - [GraphQL.org](http://graphql.org) for an introduction and reference to GraphQL itself.
 - [apollographql.com](http://www.apollographql.com/) to learn about Apollo open-source and commercial tools.
 - [The Apollo blog](https://www.apollographql.com/blog/) for long-form articles about GraphQL, feature announcements for Apollo, and guest articles from the community.
@@ -218,7 +218,7 @@ If you'd like to contribute, please see [Contributing.md](https://github.com/apo
 
 * [Apollo Studio](https://www.apollographql.com/studio/develop/) – A free, end-to-end platform for managing your GraphQL lifecycle. Track your GraphQL schemas in a hosted registry to create a source of truth for everything in your graph. Studio provides an IDE (Apollo Explorer) so you can explore data, collaborate on queries, observe usage, and safely make schema changes.
 * [Apollo Federation](https://www.apollographql.com/apollo-federation) – The industry-standard open architecture for building a distributed graph. Use Apollo’s gateway to compose a unified graph from multiple subgraphs, determine a query plan, and route requests across your services.
-* [Apollo Client](https://www.apollographql.com/apollo-client/) – The most popular GraphQL client for the web. Apollo also builds and maintains [Apollo iOS](https://github.com/apollographql/apollo-ios) and [Apollo Android](https://github.com/apollographql/apollo-android).
+* [Apollo Client](https://www.apollographql.com/apollo-client/) – The most popular GraphQL client for the web. Apollo also builds and maintains [Apollo iOS](https://github.com/apollographql/apollo-ios) and [Apollo Kotlin](https://github.com/apollographql/apollo-android).
 * [Apollo Server](https://www.apollographql.com/docs/apollo-server/) – A production-ready JavaScript GraphQL server that connects to any microservice, API, or database. Compatible with all popular JavaScript frameworks and deployable in serverless environments.
 
 ## Learn how to build with Apollo

ROADMAP.md

@@ -1,8 +1,8 @@
 # Roadmap
 
-This document is meant to give the community some idea of where we're going with Apollo Android in the short and longer term.
+This document is meant to give the community some idea of where we're going with Apollo Kotlin in the short and longer term.
 
-Please open issues or comment/upvote the existing ones for items you'd like to see added here. Feedback is very welcome! We'd love to learn more about how you're using Apollo Android and what you'd like to see in the future.
+Please open issues or comment/upvote the existing ones for items you'd like to see added here. Feedback is very welcome! We'd love to learn more about how you're using Apollo Kotlin and what you'd like to see in the future.
 
 This document was last updated on October 25th, 2021.
 
@@ -24,9 +24,9 @@ As we move to a stable 3.0 release our priority will be to make sure the feedbac
 
 The declarative cache makes working with the cache and defining unique object ids easier. We also want to include helpers to handle with common cases like pagination, garbage collection and eviction.
 
-### Make Apollo Android even more multiplatform
+### Make Apollo Kotlin even more multiplatform
 
-Apollo Android 3 is multiplatform first with runtime and cache support for the JVM, iOS, macOS and JS. We can do more to make the library even more easy to use:
+Apollo Kotlin 3 is multiplatform first with runtime and cache support for the JVM, iOS, macOS and JS. We can do more to make the library even more easy to use:
 
 - HMPP support
 - Trying out and adopting the new memory model

apollo-ast/gradle.properties

@@ -1,3 +1,3 @@
 POM_ARTIFACT_ID=apollo-ast
-POM_NAME=Apollo Android Ast
-POM_DESCRIPTION=Apollo Android Ast
+POM_NAME=Apollo Kotlin Ast
+POM_DESCRIPTION=Apollo Kotlin Ast

apollo-ast/src/main/kotlin/com/apollographql/apollo3/ast/Issue.kt

@@ -43,7 +43,7 @@ sealed class Issue(
    * Upper case fields are not supported as Kotlin doesn't allow a property name with the same name as a nested class.
    * If this happens, the easiest solution is to add an alias with a lower case first letter.
    *
-   * This error is an Apollo Android specific error
+   * This error is an Apollo Kotlin specific error
    */
   class UpperCaseField(message: String, sourceLocation: SourceLocation) : Issue(message, sourceLocation, Severity.ERROR)
 
@@ -80,4 +80,4 @@ enum class ValidationDetails {
    */
   DuplicateTypeName,
   Other
-}
+}

apollo-ast/src/main/resources/apollo.graphqls

@@ -1,5 +1,5 @@
 # Marks a field or variable definition as optional or required
-# By default Apollo Android generates all variables of nullable types as optional, in compliance with the GraphQL specification,
+# 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
 directive @optional(if: Boolean = true) on FIELD | VARIABLE_DEFINITION
 

apollo-compiler/gradle.properties

@@ -1,4 +1,4 @@
 POM_ARTIFACT_ID=apollo-compiler
-POM_NAME=Apollo Android Compiler
+POM_NAME=Apollo Kotlin Compiler
 POM_DESCRIPTION=Implementation for the Gradle plugin
-POM_PACKAGING=jar
+POM_PACKAGING=jar

apollo-gradle-plugin/build.gradle.kts

@@ -94,7 +94,7 @@ gradlePlugin {
   plugins {
     create("apolloGradlePlugin") {
       id = "com.apollographql.apollo3"
-      displayName = "Apollo Android GraphQL client plugin."
+      displayName = "Apollo Kotlin GraphQL client plugin."
       description = "Automatically generates typesafe java and kotlin models from your GraphQL files."
       implementationClass = "com.apollographql.apollo3.gradle.internal.ApolloPlugin"
     }

apollo-gradle-plugin/src/main/kotlin/com/apollographql/apollo3/gradle/api/Service.kt

@@ -226,7 +226,7 @@ interface Service {
 
   /**
    * A list of [Regex] patterns for input/scalar/enum types that should be generated whether they are used by queries/fragments
-   * in this module. When using multiple modules, Apollo Android will generate all the types by default in the root module
+   * in this module. When using multiple modules, Apollo Kotlin will generate all the types by default in the root module
    * because the root module doesn't know what types are going to be used by dependent modules. This can be prohibitive in terms
    * of compilation speed for large projects. If that's the case, opt-in the types that are used by multiple dependent modules here.
    * You don't need to add types that are used by a single dependent module.

apollo-gradle-plugin/src/main/kotlin/com/apollographql/apollo3/gradle/internal/KotlinPluginFacade.kt

@@ -55,7 +55,7 @@ internal fun checkKotlinPluginVersion(project: Project) {
     else -> false
   }
   require(isKotlinSupported) {
-    "Apollo Android requires Kotlin plugin version 1.4 or more (found '${project.getKotlinPluginVersion()}')"
+    "Apollo Kotlin requires Kotlin plugin version 1.4 or more (found '${project.getKotlinPluginVersion()}')"
   }
 }
 

apollo-gradle-plugin/src/test/kotlin/com/apollographql/apollo3/gradle/test/KotlinPluginVersionTests.kt

@@ -23,7 +23,7 @@ class KotlinPluginVersionTests {
         TestUtils.executeGradleWithVersion(dir, "5.6", "generateApolloSources")
         fail("An exception was expected")
       } catch (e: UnexpectedBuildFailure) {
-        Truth.assertThat(e.message).contains("Apollo Android requires Kotlin plugin version 1.4")
+        Truth.assertThat(e.message).contains("Apollo Kotlin requires Kotlin plugin version 1.4")
       }
     }
   }
@@ -37,4 +37,4 @@ class KotlinPluginVersionTests {
       Truth.assertThat(result.task(":help")!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
     }
   }
-}
+}

design-docs/Codegen.md

@@ -1,12 +1,12 @@
 # Codegen Models
 
-In order to provide type safety, Apollo Android generates Kotlin models from your queries. The fields you're querying will be accessible in the Kotlin models. Fields that are not queried will not be accessible. For simple queries, the mapping of GraphQL queries to Kotlin models is relatively natural. GraphQL objects are mapped to Kotlin data classes and GraphQL fields to Kotlin properties.
+In order to provide type safety, Apollo Kotlin generates Kotlin models from your queries. The fields you're querying will be accessible in the Kotlin models. Fields that are not queried will not be accessible. For simple queries, the mapping of GraphQL queries to Kotlin models is relatively natural. GraphQL objects are mapped to Kotlin data classes and GraphQL fields to Kotlin properties.
 
-For more complex queries, involving [merged fields](https://spec.graphql.org/draft/#sec-Field-Selection-Merging) and/or [fragments](https://spec.graphql.org/draft/#sec-Validation.Fragments) on different interfaces/union types, this mapping becomes more complicated as polymorphic types are needed. In order to accommodate different needs, Apollo Android supports three different codegen modes:
+For more complex queries, involving [merged fields](https://spec.graphql.org/draft/#sec-Field-Selection-Merging) and/or [fragments](https://spec.graphql.org/draft/#sec-Validation.Fragments) on different interfaces/union types, this mapping becomes more complicated as polymorphic types are needed. In order to accommodate different needs, Apollo Kotlin supports three different codegen modes:
 
 * **responseBased**: the Kotlin models map the received json.
 * **operationBased**: the Kotlin models map the sent operation.
-* **compat**: for compatibility with Apollo Android 2.x
+* **compat**: for compatibility with Apollo Kotlin 2.x
 
 `operationBased` will generate less code but will use more memory and expose less type information. `responseBased` will generate interfaces to access the models in a more polymorphic way. It will also store each merged field exactly once and have more efficient json parsing. That comes at the price of more generated code.
 
@@ -392,4 +392,4 @@ class Hero(
 )
 </pre></td>
 </tr>
-</table>
+</table>

design-docs/Json.md

@@ -1,4 +1,4 @@
-Json is a relatively simple format but there are a few caveats in Apollo Android:
+Json is a relatively simple format but there are a few caveats in Apollo Kotlin:
 
 ## Fields order
 

design-docs/Readme.md

@@ -1,5 +1,5 @@
 ## Design docs
 
-This is Apollo Android documentation for how things work under the hood. The user-facing documentation about how to use Apollo Android is available at https://www.apollographql.com/docs/android/.
+This is Apollo Kotlin documentation for how things work under the hood. The user-facing documentation about how to use Apollo Kotlin is available at https://www.apollographql.com/docs/android/.
 
 This internal documentation is work in progress. It is used for brainstorming/communication but might be lagging sometimes, feel free to send PRs! 

design-docs/Threading.md

@@ -155,7 +155,7 @@ class NativeSerialSharedState<T>(producer: () -> T): SharedState<T> {
 ## Appendix-2 Non-goal: Atomic Cached Requests
 
 
-Apollo Android has no concept of "Atomic request". Launching the same request twice in a row will most likely end up in the request being sent to the network twice even if the first one will ultimately cache it (but this is not guaranteed either):
+Apollo Kotlin has no concept of "Atomic request". Launching the same request twice in a row will most likely end up in the request being sent to the network twice even if the first one will ultimately cache it (but this is not guaranteed either):
 
 ```kotlin
 val response1 = launch {

samples/README.md

@@ -1,6 +1,6 @@
-If you're looking for a specific feature (APQs, Codegen options, `@nonnull`, ...) the [integration-tests](../tests) have a lot of very focused examples of how to use Apollo Android.
+If you're looking for a specific feature (APQs, Codegen options, `@nonnull`, ...) the [integration-tests](../tests) have a lot of very focused examples of how to use Apollo Kotlin.
 
 For more general examples demonstrating how to build an App end to end, check:
 
 * https://github.com/apollographql/apollo-android-tutorial for an **Android App** example 
-* https://github.com/joreilly/MortyComposeKMM for a **Multiplatform App** example
+* https://github.com/joreilly/MortyComposeKMM for a **Multiplatform App** example