Apollo Kotlin Documentation

apollo-compiler is a low-level compiler API designed to generate Java and Kotlin models from GraphQL operations. It is the underlying engine used by the apollo-gradle-plugin. The module utilizes JavaPoet and KotlinPoet for code generation.

End-users typically consume this module through Gradle or Maven plugins. It also provides the ApolloCompilerPlugin interface for extending compiler functionality.

The apollo-execution module provides the core logic required to execute GraphQL documents.

Dependencies:

• kotlinx-coroutines (Coroutines)
• apollo-api

⚠️ Warning: This module is currently marked as experimental.

The apollo-testing-support module provides specialized network transports designed for testing GraphQL queries without requiring a running mock server. You can use QueueTestNetworkTransport or MapTestNetworkTransport to simulate network responses directly within your tests.

For detailed implementation guidance, refer to the official documentation on Mocking GraphQL responses.

apollo-api provides the essential symbols required to compile generated GraphQL code and parse responses. It is a lightweight alternative to the full runtime.

Note: This module does not include networking or caching capabilities. If you require a complete Apollo client implementation with networking and caching, use apollo-runtime instead.

For instructions on how to use these models without the full runtime, refer to the official guide on using models without apollo-runtime.

The apollo-runtime module provides the ApolloClient class, which is the primary entry point for executing GraphQL queries and subscriptions. It contains the core networking code required to interact with your GraphQL server.

To instantiate and use an ApolloClient, refer to the official Apollo Kotlin Get Started guide.

Apollo Kotlin is highly modular, allowing you to include only the features you need to keep binary size and compile times small. The library is split into main modules for runtime, caching, and tooling, as well as deprecated modules that have moved to Apollo Galaxy.

Key functional areas include:

• Runtime & API: apollo-runtime (main entry point) and apollo-api (minimal symbols).
• Caching: apollo-http-cache (HTTP level) and apollo-normalized-cache (application level).
• Tooling: apollo-gradle-plugin and apollo-compiler.
• Testing: apollo-testing-support for mocking responses.

The library uses specific terminology to describe GraphQL types:

• Raw type: The named type without any List or NonNull wrappers.
• Leaf type: A type that contains no subfields (e.g., a Scalar or an Enum).
• Composite type: A type that contains subfields (e.g., an Interface, Object, or Union).
• Concrete type: A synonym for an Object type.
• Possible types: The set of concrete types that satisfy a specific type condition.
• Polymorphic field: A field that can return multiple different shapes.

Apollo Kotlin Compose is an experimental framework designed for developers using Jetpack Compose. It works alongside a special compiler plugin to provide APIs optimized for declarative UI.

Key goals include:

• Fragment colocation
• Error boundaries
• Deep integration with the Jetpack Compose UI framework.

Apollo Kotlin distinguishes between different types of definitions (directives/metadata) in the schema:

• API schema: The server schema as seen via introspection (JSON or SDL).
• Server definition: Definitions present in the API schema (e.g., @include, @oneOf, __Schema).
• Client definition: Definitions added to the API schema by the client via @link or concatenation.
• Linked definition: A definition added to a schema using @link (e.g., @targetName, @typePolicy).
• Checked definitions: Definitions recognized by Apollo Kotlin that must follow a specific shape to prevent compiler crashes or unexpected behavior (e.g., @oneOf, @semanticNonNull, @targetName).