Gradle plugin configuration

1
apollo {
2
  service("starwars") {
3
    srcDir("src/main/graphql/starwars")
4
    packageName.set("com.starwars")
5
  }
6
  service("githunt") {
7
    srcDir("src/main/graphql/githunt")
8
    packageName.set("com.githunt")
9
  }
10
}

1
apollo {
2
  service("service") {
3
    schemaFiles.from(file("shared/graphql/schema.graphqls"))
4
  }
5
}

1
apollo {
2
  service("service") {
3
    schemaFiles.setFrom("shared/graphql/schema.graphqls", "shared/graphql/extra.graphqls")
4
  }
5
}

1
apollo {
2
  service("service") {
3
    outputDirConnection {
4
      connectToKotlinSourceSet("test")
5
    }
6
  }
7
}

1
apollo {
2
  createAllAndroidVariantServices(sourceFolder = ".", nameSuffix = "") {
3
    // Configure the service here
4
    packageName.set("...")
5
  }
6
}

1
- main
2
    - graphql
3
        - schema.graphqls // Schema for all variants
4
        - operations.graphql // Operations shared by all variants
5
- debug
6
    - graphql
7
        - operations.graphql // Operations specific to the 'debug' build type

1
- main
2
- demo
3
    - graphql
4
        - schema.graphqls // Schema for the 'demo' flavor
5
        - operations.graphql // Operations specific to the 'demo' flavor
6
- full
7
    - graphql
8
        - schema.graphqls // Schema for the 'full' flavor
9
        - operations.graphql // Operations specific to the 'full' flavor

1
apollo {
2
  service("debug") {
3
    srcDir(file("src/debug/graphql/"))
4
    packageName.set("com.example")
5
    outputDirConnection {
6
      connectToAndroidSourceSet("debug")
7
    }
8
  }
9
  service("release") {
10
    srcDir(file("src/release/graphql/"))
11
    packageName.set("com.example")
12
    outputDirConnection {
13
      connectToAndroidSourceSet("release")
14
    }
15
  }
16
}

1
# --schema is interpreted relative to the project's root directory (can also be an absolute path). This example
2
# assumes the root project directory and an Android app in `app`
3
./gradlew downloadApolloSchema \
4
  --endpoint="https://your.domain/graphql/endpoint" \
5
  --schema="app/src/main/graphql/com/example/schema.graphqls"

1
apollo {
2
  service("starwars") {
3
    packageName.set("com.starwars")
4

5
    // This will create a downloadStarwarsApolloSchemaFromIntrospection task
6
    introspection {
7
      endpointUrl.set("https://your.domain/graphql/endpoint")
8
      // The path is interpreted relative to the current project here, no need to prepend 'app'
9
      schemaFile.set(file("src/main/graphql/com/example/schema.graphqls"))
10
    }
11
  }
12
}

1
apollo {
2
  service("starwars") {
3
    packageName.set("com.starwars")
4

5
    // This will create a downloadStarwarsApolloSchemaFromRegistry task
6
    registry {
7
      key.set(System.getenv("APOLLO_KEY"))
8
      graph.set(System.geten("APOLLO_GRAPH"))
9
      // The path is interpreted relative to the current project here, no need to prepend 'app'
10
      schemaFile.set(file("src/main/graphql/com/example/schema.graphqls"))
11
    }
12
  }
13
}

1
apollo {
2
  service("service") {
3
    // Generates equals and hashCode
4
    generateMethods.set(listOf("equalsHashCode"))
5
    // Generates toString, equals, and hashcode (the default for Java)
6
    generateMethods.set(listOf("equalsHashCode", "toString"))
7
    // Only generates copy
8
    generateMethods.set(listOf("copy"))
9
    // Generates data classes (the default for Kotlin)
10
    generateMethods.set(listOf("dataClass"))
11
  }
12
}

1
apollo {
2
  service("api") {
3
    // The package name for the generated models
4
    packageName.set("com.example")
5

6
    // Adds the given directory as a GraphQL source root
7
    srcDir("src/main/graphql")
8
    // Operation files to include.
9
    includes.add("**/*.graphql")
10
    // Operation files to exclude.
11
    excludes.add("**/*.graphqls")
12

13
    // Explicitly set the schema
14
    schemaFiles.from("src/main/graphql/schema.graphqls")
15
    // Extend your schema locally with type extensions
16
    schemaFiles.from("shared/graphql/schema.graphqls", "shared/graphql/extra.graphqls")
17

18
    // What codegen to use. One of "operationBased", "responseBased"
19
    codegenModels.set("operationBased")
20

21
    // Warn if using a deprecated field
22
    warnOnDeprecatedUsages.set(true)
23
    // Fail on warnings
24
    failOnWarnings.set(true)
25

26
    // Map the "Date" custom scalar to the com.example.Date Kotlin type
27
    mapScalar("Date", "com.example.Date")
28
    // Shorthands to map scalar to builtin types and configure their adapter at build time
29
    mapScalarToUpload("Upload")
30
    mapScalarToKotlinString("MyString")
31
    mapScalarToKotlinInt("MyInt")
32
    mapScalarToKotlinDouble("MyDouble")
33
    mapScalarToKotlinFloat("MyFloat")
34
    mapScalarToKotlinLong("MyLong")
35
    mapScalarToKotlinBoolean("MyBoolean")
36
    mapScalarToKotlinAny("MyAny")
37
    mapScalarToJavaString("MyString")
38
    mapScalarToJavaInteger("MyInteger")
39
    mapScalarToJavaDouble("MyDouble")
40
    mapScalarToJavaFloat("MyFloat")
41
    mapScalarToJavaLong("MyLong")
42
    mapScalarToJavaBoolean("MyBoolean")
43
    mapScalarToJavaObject("MyObject")
44

45
    // Configure operation ids for persisted queries
46
    operationOutputGenerator = object : OperationOutputGenerator {
47
      override fun generate(operationDescriptorList: Collection<OperationDescriptor>): OperationOutput {
48
        return operationDescriptorList.map {
49
          it.source.sha256() to it
50
        }.toMap()
51
      }
52

53
      override val version = "v1"
54
    }
55
    // The format to output for the operation manifest.
56
    operationManifestFormat.set("persistedQueryManifest")
57
    // The file where to write the operaiton manifest
58
    operationManifest.set("build/generated/persistedQueryManifest.json")
59

60
    // Whether to generate Kotlin or Java models
61
    generateKotlinModels.set(true)
62
    // Target language version for the generated code.
63
    languageVersion.set("1.5")
64
    // Whether to suffix operation name with 'Query', 'Mutation' or 'Subscription'
65
    useSemanticNaming.set(true)
66
    // Whether to generate kotlin constructors with `@JvmOverloads` for more graceful Java interop experience when default values are present.
67
    addJvmOverloads.set(true)
68
    // Whether to generate Kotlin models with `internal` visibility modifier.
69
    generateAsInternal.set(true)
70
    // Whether to generate default implementation classes for GraphQL fragments.
71
    generateFragmentImplementations.set(true)
72
    // Whether to write the query document in models
73
    generateQueryDocument.set(true)
74
    // Whether to generate the Schema class.
75
    generateSchema.set(true)
76
    // Name for the generated schema
77
    generatedSchemaName.set("Schema")
78
    // Whether to generate operation variables as [com.apollographql.apollo3.api.Optional]
79
    generateOptionalOperationVariables.set(true)
80
    // Whether to generate the type safe Data builders.
81
    generateDataBuilders.set(true)
82
    // Whether to generate response model builders for Java.
83
    generateModelBuilders.set(true)
84
    // Which methods to auto generate (can include: `equalsHashCode`, `copy`, `toString`, or `dataClass`)
85
    generateMethods.set(listOf("dataClass"))
86
    // Whether to generate fields as primitive types (`int`, `double`, `boolean`) instead of their boxed types (`Integer`, `Double`, etc..)
87
    generatePrimitiveTypes.set(true)
88
    // Opt-in Builders for Operations, Fragments and Input types. Builders are more ergonomic than default arguments when there are a lot of
89
    // optional arguments.
90
    generateInputBuilders.set(true)
91
    // The style to use for fields that are nullable in the Java generated code
92
    nullableFieldStyle.set("apolloOptional")
93
    // Whether to decapitalize field names in the generated models (for instance `FooBar` -> `fooBar`)
94
    decapitalizeFields.set(false)
95

96
    // Whether to add the [JsExport] annotation to generated models.
97
    jsExport.set(true)
98
    // When to add __typename.
99
    addTypename.set("always")
100
    // Whether to flatten the models. File paths are limited on MacOSX to 256 chars and flattening can help keeping the path length manageable
101
    flattenModels.set(true)
102
    // A list of [Regex] patterns for GraphQL enums that should be generated as Kotlin sealed classes instead of the default Kotlin enums.
103
    sealedClassesForEnumsMatching.set(listOf(".*"))
104
    // A list of [Regex] patterns for GraphQL enums that should be generated as Java classes.
105
    classesForEnumsMatching.set(listOf(".*"))
106
    // Whether fields with different shape are disallowed to be merged in disjoint types.
107
    fieldsOnDisjointTypesMustMerge.set(false)
108

109

110
    // The directory where the generated models will be written.
111
    outputDir.set("build/generated/apollo")
112

113
    // Whether to generate Apollo metadata. Apollo metadata is used for multi-module support.
114
    generateApolloMetadata.set(true)
115
    // list of [Regex] patterns matching for types and fields that should be generated whether they are used by queries/fragments in this module or not.
116
    alwaysGenerateTypesMatching.set(listOf(".*"))
117
    // Reuse the schema from an upstream module
118
    dependsOn(project(":schema"))
119
    // Compute used types from a downstream module 
120
    isADependencyOf(project(":feature"))
121

122
    // configure introspection schema download
123
    introspection {
124
      endpointUrl.set("https://your.domain/graphql/endpoint")
125
      schemaFile.set(file("src/main/graphql/com/example/schema.graphqls"))
126
    }
127
    // configure registry schema download
128
    registry {
129
      key.set(System.getenv("APOLLO_KEY"))
130
      graph.set(System.geten("APOLLO_GRAPH"))
131
      schemaFile.set(file("src/main/graphql/com/example/schema.graphqls"))
132
    }
133

134
    // wire the generated models to the "test" source set
135
    outputDirConnection {
136
      connectToKotlinSourceSet("test")
137
    }
138
  }
139

140
  // Make IDEA aware of codegen and will run it during your Gradle Sync, default: false
141
  generateSourcesDuringGradleSync.set(true)
142

143
  // Link sqlite for Kotlin native projects
144
  linkSqlite.set(true)
145
}