Auto-generates Ktor HTTP client implementations from annotated interfaces via KSP, including factory-extension creation to eliminate boilerplate; supports all HTTP methods, parameter annotations, multipart and form requests.
Ktor Generator is a powerful KSP (Kotlin Symbol Processing) library that automates the creation of Ktor HTTP client implementations for your Kotlin Multiplatform projects. By simply annotating an interface, you can eliminate the boilerplate code required for API service definitions.
It includes:
Note: Please replace x.y.z with the latest version.
In your module-level build.gradle.kts file (e.g., shared/build.gradle.kts):
plugins {
// Make sure you have the KSP plugin applied
id("com.google.devtools.ksp")
}
// ...
dependencies {
// Add the annotations library
implementation("io.github.the-best-is-best:ktorgenerator-annotations:x.y.z")
// Add the KSP processor
ksp("io.github.the-best-is-best:ktor-generator-processor:x.y.z")
}
Ensure the generated code is included in your source sets. This allows your project to see the code created by the KSP processor.
kotlin {
sourceSets.all {
kotlin.srcDir("build/generated/ksp/$name/kotlin")
}
}
*Note: The path might need to be adjusted based on your project structure, but
build/generated/ksp/$name/kotlin covers most standard KMP setups._
@ApiService: Marks an interface to be processed. Ktor Generator will create an implementation
for it.@GET(path: String)@POST(path: String)@PUT(path: String)@DELETE(path: String)@PATCH(path: String)@HEAD(path: String)@Headers(vararg val value: String): Add multiple static headers to a request.@Multipart: Denotes a multipart request.@FormUrlEncoded: Denotes a URL-encoded form request.@TextResponse: Makes the function return the raw response body as a String.Create an interface and annotate it with @ApiService. Define your API endpoints as functions with
HTTP method and parameter annotations.
In your application's setup code (e.g., in your DI setup or application entry point), configure the
KtorGeneratorClient with your base URL and a Ktor HttpClient instance.
// commonMain/kotlin/com/example/di/NetworkModule.kt
package com.example.di
import io.github.tbib.ktorgenerator.annotations.engine.KtorGeneratorClient
io.ktor.client.*
io.ktor.client.plugins.contentnegotiation.*
io.ktor.serialization.kotlinx.json.*
kotlinx.serialization.json.Json
{
ktorClient = HttpClient {
install(ContentNegotiation) {
json(Json {
prettyPrint =
isLenient =
ignoreUnknownKeys =
})
}
}
KtorGeneratorClient.baseUrl =
KtorGeneratorClient.ktorClient = ktorClient
}
After building the project, KSP will generate the implementation and a create<YourInterfaceName>
extension function. You can then get your API service instance directly from KtorGeneratorClient.
// After initialization in your ViewModel or Presenter
val myApi: MyApiService = KtorGeneratorClient.createMyApiService()
// Now you can make API calls
suspend fun fetchSomeUser() {
val user = myApi.getUser("123")
println("Fetched user: $user")
}
@ApiService annotation.@GET, @POST, @PUT, @DELETE, @PATCH, @HEAD,
@OPTIONS.@Path, @Query, Body, @Header,
@Part, @Field, and @FieldMap.@FormUrlEncoded and @Multipart.@OPTIONS(path: String)@Path(value: String): Replace a placeholder in the request URL path (e.g., users/{id}).@Query(value: String): Add a query parameter to the URL.@Body: Use the annotated parameter as the request body.@Header(value: String): Add a request header.@Field(value: String): A single field in a URL-encoded form.@FieldMap: A Map of key-value pairs for a URL-encoded form.@Part(value: String): A single part in a multipart request.// commonMain/kotlin/com/example/api/MyApiService.kt
package com.example.api
import io.github.tbib.ktorgenerator.annotations.annotations.*
// Assume User and Post data classes exist
// data class User(...)
// data class Post(...)
interface MyApiService {
suspend fun getUser( userId: String): User
suspend fun createUser( user: User)
suspend fun getPostsByAuthor( authorId: String): List<Post>
}
Surfaced from shared tags and platforms — no rankings paid for.