Multi Modules codegen

For multi-modules projects, Apollo Kotlin enables you to define queries in a feature module and reuse fragments and types from another module dependency. This helps with better separation of concerns and build times.

Setup

Multi-modules requires that one and only one module contains a schema. This is the schema that all other modules can reuse. In this document, we'll refer to this module as the "schema module".

In your schema module, opt-in multi-module by generating metadata for use by downstream feature modules:

1
// schema/build.gradle.kts
2
apollo {
3
  service("service") {
4
    packageName.set("schema")
5
    
6
    // enable generation of metadata for use by downstream modules 
7
    generateApolloMetadata.set(true)
8
    
9
    // If you need to specify the location of your schema
10
    schemaFile.set(/*...*/)
11
    
12
    // define options that must be shared between all modules using this schema
13
    mapScalar(/*...*/)
14
    generateDataBuilders.set(true)
15
    // more options...
16
  }
17
}

In your feature module, declare your schema module as a dependency:

1
// feature/build.gradle.kts
2
apollo {
3
  // service names must match
4
  service("service") {
5
    packageName.set("feature")
6
    
7
    // The 'feature' depends on the 'schema' module
8
    dependsOn(project(":schema")) 
9
  }
10
}

Auto-detection of used types

By default, Apollo Kotlin generates all the types in your schema module. This is because there is no way to know in advance what types are going to be used by feature modules.

For large schemas, this can generate a lot of code and increase your build time significantly. In this case, you can opt in auto-detection of used types. This works by splitting the codegen task in different steps so that feature modules can let the schema module know what types are used before actually generating the models. To opt in, you need to add the "opposite" link by using isADependencyOf():

1
// schema/build.gradle.kts
2
apollo {
3
  service("service") {
4
    packageName.set("schema")
5
    generateApolloMetadata.set(true)
6
    
7
    // Get the used types from the downstream module
8
    isADependencyOf(project(":feature1")) 
9
    
10
    // you can have several feature modules
11
    isADependencyOf(project(":feature2"))
12
    // ...
13
  }
14
}

1
// feature1/build.gradle.kts
2
apollo {
3
  service("service") {
4
    packageName.set("feature")
5
    
6
    // Get the generated schema types (and fragments) from the upstream schema module 
7
    dependsOn(project(":schema")) 
8
  }
9
}

Once you opt in auto-detection of used types, it's important that all modules are doubly linked like above. If not the feature modules will fail to compile due to some missing schema classes.