KMP #04: Membuat Repository & Domain Layer di Kotlin Multiplatform
Sekarang kita akan melanjutkan project Weather App dengan membangun struktur yang lebih rapi. Kita akan memisahkan kode yang bertanggung jawab mengambil data dari API dengan kode yang merepresentasikan business logic aplikasi.
Kenapa ini penting?
Bayangkan kalau seluruh proses request API, parsing JSON, pengolahan data, dan business logic kita letakkan dalam satu class. Semakin banyak fitur yang ditambahkan, semakin sulit juga kode tersebut untuk dipelihara dan diuji.
Karena itu, pada artikel kali ini kita akan mengenal Repository Pattern dan Domain Layer. Keduanya akan menjadi fondasi sebelum kita mulai menghubungkan shared module dengan UI native Android dan iOS.
Apa yang Akan Kita Buat?
Pada akhir artikel ini, kita akan mempunyai beberapa komponen baru di shared module:
- Weather sebagai domain model untuk data cuaca.
- WeatherRepository sebagai kontrak pengambilan data.
- WeatherRepositoryImpl sebagai implementasi repository.
- ForecastMapper untuk mengubah response API menjadi domain model.
- GetWeatherUseCase sebagai representasi aksi untuk mendapatkan data cuaca.
- Error handling dasar dan unit test menggunakan kotlin.test.
Semua komponen tersebut akan kita tempatkan di shared module. Dengan begitu, Android dan iOS bisa menggunakan business logic yang sama tanpa harus mengimplementasikan proses pengambilan data dua kali.
Mengenal Data Layer dan Domain Layer
1. Data Layer
Data Layer bertanggung jawab menyediakan data untuk aplikasi. Dalam project kita, sumber data utamanya adalah Open-Meteo API.
Layer ini akan menangani komunikasi dengan API, menerima response, dan mengubah data tersebut menjadi model yang dibutuhkan aplikasi.
Komponen yang akan kita gunakan antara lain:
- WeatherApiClient untuk melakukan HTTP request.
- DTO untuk merepresentasikan response API.
- Mapper untuk mengubah DTO menjadi domain model.
- WeatherRepositoryImpl untuk mengimplementasikan kontrak repository.
2. Domain Layer
Domain Layer berisi model dan aturan bisnis yang dibutuhkan aplikasi. Layer ini tidak perlu mengetahui bagaimana HTTP request dilakukan atau bagaimana JSON diparsing.
Untuk tahap ini, kita akan membuat:
- Weather sebagai domain model.
- WeatherRepository sebagai interface.
- GetWeatherUseCase sebagai use case.
Perhatikan bahwa WeatherRepository merupakan interface di Domain Layer, sedangkan implementasinya berada di Data Layer. Dengan pemisahan ini, business logic tidak perlu bergantung langsung pada Ktor Client.
(Domain Interface)"] IMPL["WeatherRepositoryImpl"] API["WeatherApiClient"] SERVER["Open-Meteo API"] MAPPER["ForecastMapper"] MODEL["Weather Domain Model"] UC --> REPO IMPL -. implements .-> REPO IMPL --> API API --> SERVER SERVER --> API API --> MAPPER MAPPER --> MODEL MODEL --> IMPL
Diagram di atas menunjukkan bahwa Domain Layer hanya bergantung pada kontrak repository. Detail implementasi networking berada di Data Layer.
Mengenal Repository Pattern
Repository Pattern merupakan pendekatan untuk memisahkan cara aplikasi memperoleh data dari bagian aplikasi yang menggunakan data tersebut.
Misalnya, saat ini kita mengambil data cuaca dari Open-Meteo API. Nantinya kita mungkin ingin menambahkan local database agar aplikasi tetap bisa menampilkan data ketika perangkat sedang offline.
Kalau kode yang mengambil data tersebar di banyak tempat, perubahan tersebut akan membuat proses pengembangan menjadi lebih rumit.
Dengan Repository Pattern, bagian lain dari aplikasi cukup berkomunikasi melalui satu kontrak. Implementasinya dapat dikembangkan tanpa harus mengubah seluruh bagian yang menggunakan data tersebut.
Untuk Weather App, kita akan menggunakan dua komponen utama:
- WeatherRepository: mendefinisikan operasi untuk mendapatkan data cuaca.
- WeatherRepositoryImpl: mengambil data melalui WeatherApiClient dan mengubah response menjadi domain model.
Let's Code!
1. Membuat Domain Model
Pertama, kita akan membuat model yang digunakan oleh Domain Layer.
Buat package domain.model di shared module, kemudian buat file Weather.kt.
package com.muliamaulana.weatherapp.domain.model
data class Weather(
val latitude: Double,
val longitude: Double,
val temperature: Double,
val weatherCode: Int
)
Model ini menyimpan informasi dasar yang kita butuhkan untuk menampilkan kondisi cuaca saat ini.
Kita menggunakan data class karena Kotlin sudah menyediakan beberapa fungsi yang berguna, seperti equals(), hashCode(), dan copy().
Untuk saat ini modelnya masih sederhana. Nantinya kita bisa mengembangkannya untuk mendukung lokasi, kondisi cuaca, dan prakiraan tujuh hari sesuai kebutuhan aplikasi.
Hal yang perlu diperhatikan adalah domain model tidak harus sama dengan DTO dari API. Domain model merepresentasikan kebutuhan aplikasi, sedangkan DTO mengikuti struktur response dari server.
2. Membuat WeatherRepository
Selanjutnya, kita akan membuat kontrak repository yang digunakan oleh Domain Layer.
Buat package domain.repository, kemudian tambahkan file WeatherRepository.kt.
package com.muliamaulana.weatherapp.domain.repository
import com.muliamaulana.weatherapp.domain.model.Weather
interface WeatherRepository {
suspend fun getForecast(
latitude: Double,
longitude: Double
): Result<Weather>
}
Kita menggunakan suspend karena proses pengambilan data dilakukan secara asynchronous menggunakan coroutine.
Sementara itu, Result<Weather> memungkinkan fungsi ini mengembalikan hasil sukses yang berisi objek Weather, atau hasil gagal yang menyimpan exception.
Dengan kontrak ini, Domain Layer tidak perlu mengetahui apakah data berasal dari HTTP API, database lokal, atau sumber data lainnya.
Untuk tutorial ini kita menggunakan kotlin.Result bawaan Kotlin. Pada aplikasi yang lebih besar, kita juga bisa menggunakan sealed class khusus untuk mendefinisikan jenis error yang lebih terstruktur.
3. Membuat DTO dan Mapper
Sekarang kita masuk ke Data Layer.
Pada artikel sebelumnya kita sudah membuat WeatherApiClient untuk melakukan request ke Open-Meteo. Kita akan menggunakan kembali client tersebut, bukan membuat networking baru.
Untuk contoh ini, kita menggunakan response yang berisi koordinat dan kondisi cuaca saat ini. Jika DTO sudah dibuat pada artikel sebelumnya, gunakan kembali DTO tersebut dan sesuaikan mapper dengan struktur yang tersedia.
Bentuk DTO yang digunakan dalam contoh ini adalah sebagai berikut.
package com.muliamaulana.weatherapp.data.dto
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
@Serializable
data class ForecastResponse(
val latitude: Double,
val longitude: Double,
val current: CurrentWeatherDto
)
@Serializable
data class CurrentWeatherDto(
@SerialName("temperature_2m")
val temperature: Double,
@SerialName("weather_code")
val weatherCode: Int
)
DTO tersebut mengasumsikan request Open-Meteo menggunakan parameter current=temperature_2m,weather_code. Nama field dan struktur JSON harus sesuai dengan request yang digunakan oleh WeatherApiClient.
Berikutnya, buat package data.mapper dan file ForecastMapper.kt.
package com.muliamaulana.weatherapp.data.mapper
import com.muliamaulana.weatherapp.data.dto.ForecastResponse
import com.muliamaulana.weatherapp.domain.model.Weather
fun ForecastResponse.toDomain(): Weather {
return Weather(
latitude = latitude,
longitude = longitude,
temperature = current.temperature,
weatherCode = current.weatherCode
)
}
Fungsi toDomain() merupakan extension function yang mengubah DTO menjadi domain model.
Dengan menggunakan mapper, komponen lain tidak perlu mengetahui struktur JSON yang digunakan oleh Open-Meteo. Jika response API berubah, penyesuaian bisa dilakukan pada DTO dan mapper selama informasi yang dibutuhkan aplikasi tetap tersedia.
4. Membuat WeatherRepositoryImpl
Setelah model dan kontrak repository tersedia, kita bisa membuat implementasinya.
Buat package data.repository, kemudian tambahkan file WeatherRepositoryImpl.kt.
package com.muliamaulana.weatherapp.data.repository
import com.muliamaulana.weatherapp.data.mapper.toDomain
import com.muliamaulana.weatherapp.domain.model.Weather
import com.muliamaulana.weatherapp.domain.repository.WeatherRepository
class WeatherRepositoryImpl(
private val api: WeatherApiClient
) : WeatherRepository {
override suspend fun getForecast(
latitude: Double,
longitude: Double
): Result<Weather> {
return try {
Result.success(
api.fetchForecast(
latitude = latitude,
longitude = longitude
).toDomain()
)
} catch (exception: kotlinx.coroutines.CancellationException) {
throw exception
} catch (exception: Exception) {
Result.failure(exception)
}
}
}
Contoh tersebut menggunakan asumsi bahwa WeatherApiClient menyediakan fungsi fetchForecast() yang mengembalikan ForecastResponse. Sesuaikan nama fungsi dan package dengan implementasi pada artikel sebelumnya.
Ada beberapa hal penting dari implementasi ini.
Dependency injection melalui constructor.
Repository menerima WeatherApiClient dari luar. Dengan begitu, repository tidak perlu membuat HTTP client sendiri. Pendekatan ini juga memudahkan kita mengganti dependency ketika melakukan testing.
Mapping response.
Response API langsung diubah menjadi domain model menggunakan toDomain(). Bagian lain dari aplikasi cukup menggunakan model Weather.
Error handling.
Jika request atau proses parsing gagal, repository mengembalikan Result.failure(). Namun, CancellationException tetap dilempar kembali agar pembatalan coroutine tidak dianggap sebagai kegagalan request biasa.
Untuk menggunakan kode tersebut, pastikan WeatherApiClient dan DTO sudah tersedia di shared module. Kita hanya perlu menyesuaikan import dan nama fungsi, bukan membuat ulang networking yang sudah berfungsi.
5. Mengenal Error Handling
Dalam aplikasi yang mengambil data dari API, request tidak selalu berhasil. Koneksi internet bisa terputus, server bisa mengembalikan HTTP error, atau response JSON tidak sesuai dengan format yang diharapkan.
Karena itu, kita perlu memahami beberapa kondisi berikut:
- Network error: request gagal karena masalah koneksi atau transport.
- HTTP error: server mengembalikan status HTTP yang menunjukkan kegagalan.
- Parsing error: response tidak dapat diubah menjadi DTO yang diharapkan.
- Not found: server mengembalikan status 404 jika resource yang diminta memang tidak ditemukan.
Pada Open-Meteo, kita tidak boleh menganggap semua kegagalan request sebagai not found. Endpoint forecast dengan koordinat tertentu memiliki perilaku yang berbeda dari endpoint geocoding yang mencari lokasi berdasarkan nama.
Pada tahap ini, kita menyimpan exception dalam Result.failure() agar pemanggil bisa memeriksa kegagalan. Penanganan yang lebih spesifik dapat ditambahkan kemudian dengan memetakan exception Ktor dan status HTTP menjadi jenis error aplikasi.
Yang terpenting, kita tidak boleh mengubah kegagalan request menjadi objek cuaca palsu atau nilai default yang seolah-olah merupakan response valid.
6. Membuat GetWeatherUseCase
Repository sudah tersedia. Sekarang kita akan membuat use case yang menjadi pintu masuk untuk kebutuhan mendapatkan data cuaca.
Buat package domain.usecase, kemudian tambahkan file GetWeatherUseCase.kt.
package com.muliamaulana.weatherapp.domain.usecase
import com.muliamaulana.weatherapp.domain.model.Weather
import com.muliamaulana.weatherapp.domain.repository.WeatherRepository
class GetWeatherUseCase(
private val repository: WeatherRepository
) {
suspend operator fun invoke(
latitude: Double,
longitude: Double
): Result<Weather> {
return repository.getForecast(
latitude = latitude,
longitude = longitude
)
}
}
Mungkin teman-teman bertanya, kenapa kita masih membutuhkan Use Case kalau sudah ada Repository?
Repository bertanggung jawab menyediakan data, sedangkan Use Case merepresentasikan aksi yang dibutuhkan aplikasi.
Saat ini GetWeatherUseCase memang hanya meneruskan request ke repository. Namun, nantinya kita bisa menambahkan validasi input atau aturan bisnis lain tanpa menempatkan logic tersebut di UI.
Kita juga menggunakan operator fun invoke. Dengan begitu, use case dapat dipanggil seperti fungsi biasa.
val result = getWeatherUseCase(
latitude = -6.2088,
longitude = 106.8456
)
Koordinat tersebut merupakan contoh lokasi Jakarta. Pemanggilan di atas mengasumsikan instance getWeatherUseCase sudah dibuat dan dependency repository sudah diberikan.
7. Memahami Alur Request
Setelah semua komponen dibuat, alur pengambilan data cuaca menjadi lebih jelas.
Diagram ini memperlihatkan bahwa pemanggil tidak harus berkomunikasi langsung dengan WeatherApiClient. Kita sudah memiliki lapisan abstraksi yang memisahkan kebutuhan aplikasi dari implementasi networking.
Pada artikel berikutnya, Android akan menggunakan GetWeatherUseCase melalui ViewModel. Sementara itu, iOS akan menggunakan shared logic yang sama melalui lapisan integrasi Swift.
8. Menambahkan Unit Test
Sekarang kita akan menguji implementasi repository. Tujuannya adalah memastikan response API dapat diubah menjadi domain model dengan benar.
Untuk test repository, kita bisa menggunakan MockEngine dari Ktor agar request tidak benar-benar dikirim ke internet.
Pastikan kotlin.test dan Ktor Mock sudah tersedia pada source set commonTest. Gunakan versi dependency yang selaras dengan Ktor Client yang sudah dipakai project.
kotlin {
sourceSets {
commonTest.dependencies {
implementation(kotlin("test"))
implementation("io.ktor:ktor-client-mock:$ktorVersion")
}
}
}
Placeholder $ktorVersion harus disesuaikan dengan version catalog atau konfigurasi dependency project teman-teman.
Agar MockEngine dapat digunakan, WeatherApiClient harus menerima HttpClient melalui constructor atau factory. Dengan begitu, test dapat memberikan client yang menggunakan engine tiruan.
Misalnya, jika client sebelumnya belum mendukung dependency injection, struktur dasarnya dapat disesuaikan menjadi seperti ini. Pertahankan implementasi request dan parsing yang sudah dibuat pada artikel sebelumnya.
class WeatherApiClient(
private val client: HttpClient
) {
suspend fun fetchForecast(
latitude: Double,
longitude: Double
): ForecastResponse {
TODO("Gunakan implementasi WeatherApiClient sebelumnya")
}
}
Kode di atas hanya menunjukkan bentuk constructor yang dibutuhkan untuk testing. Jangan mengganti implementasi networking yang sudah berfungsi dengan TODO.
Selanjutnya, kita dapat menulis test menggunakan response JSON tiruan. Contoh berikut mengasumsikan client melakukan request ke endpoint forecast dan menggunakan konfigurasi Content Negotiation yang sesuai.
package com.muliamaulana.weatherapp.data.repository
import com.muliamaulana.weatherapp.data.network.WeatherApiClient
import com.muliamaulana.weatherapp.domain.model.Weather
import io.ktor.client.HttpClient
import io.ktor.client.engine.mock.MockEngine
import io.ktor.client.engine.mock.respond
import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.http.HttpHeaders
import io.ktor.http.HttpStatusCode
import io.ktor.http.headersOf
import io.ktor.serialization.kotlinx.json.json
import kotlinx.serialization.json.Json
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
class WeatherRepositoryImplTest {
@Test
fun `getForecast returns mapped weather`() = runTest {
val mockEngine = MockEngine {
respond(
content = """
{
"latitude": -6.2,
"longitude": 106.8,
"current": {
"temperature_2m": 30.5,
"weather_code": 1
}
}
""".trimIndent(),
status = HttpStatusCode.OK,
headers = headersOf(
HttpHeaders.ContentType,
"application/json"
)
)
}
val httpClient = HttpClient(mockEngine) {
install(ContentNegotiation) {
json(Json {
ignoreUnknownKeys = true
})
}
}
try {
val api = WeatherApiClient(httpClient)
val repository = WeatherRepositoryImpl(api)
val result = repository.getForecast(
latitude = -6.2,
longitude = 106.8
)
assertTrue(result.isSuccess)
assertEquals(
Weather(
latitude = -6.2,
longitude = 106.8,
temperature = 30.5,
weatherCode = 1
),
result.getOrThrow()
)
} finally {
httpClient.close()
}
}
}
Test tersebut mengasumsikan DTO, endpoint, dan fungsi fetchForecast() sesuai dengan implementasi client sebelumnya. Jika nama package atau struktur response berbeda, sesuaikan test dengan project yang sedang kita bangun.
Perhatikan beberapa bagian penting:
- MockEngine memberikan response tanpa mengakses internet.
- ContentNegotiation dan kotlinx.serialization melakukan parsing JSON.
- Repository mengubah DTO menjadi domain model.
- assertEquals() memastikan hasil mapping sesuai dengan nilai yang diharapkan.
- httpClient.close() menutup client setelah test selesai.
Jangan lupa menambahkan dependency kotlinx-coroutines-test pada commonTest jika belum tersedia, karena contoh test menggunakan runTest.
9. Menguji Error Handling
Selain kondisi sukses, kita juga perlu memastikan repository mengembalikan kegagalan ketika server mengirimkan HTTP error.
Contoh berikut mensimulasikan response HTTP 500. Test ini mengasumsikan Ktor Client dikonfigurasi menggunakan expectSuccess = true, atau client secara eksplisit memeriksa status HTTP dan melempar exception ketika request gagal.
@Test
fun `getForecast returns failure on server error`() = runTest {
val mockEngine = MockEngine {
respond(
content = """{"error": true}""",
status = HttpStatusCode.InternalServerError,
headers = headersOf(
HttpHeaders.ContentType,
"application/json"
)
)
}
val httpClient = HttpClient(mockEngine) {
expectSuccess = true
install(ContentNegotiation) {
json(Json {
ignoreUnknownKeys = true
})
}
}
try {
val api = WeatherApiClient(httpClient)
val repository = WeatherRepositoryImpl(api)
val result = repository.getForecast(
latitude = -6.2,
longitude = 106.8
)
assertTrue(result.isFailure)
} finally {
httpClient.close()
}
}
Test ini memastikan bahwa kegagalan HTTP tidak dianggap sebagai data cuaca yang valid.
Jika client kita menggunakan konfigurasi status response yang berbeda, sesuaikan implementasi dan test agar status HTTP gagal benar-benar menghasilkan exception yang diteruskan ke repository.
Nantinya, kita dapat mengembangkan test untuk network error, parsing error, dan cancellation. Untuk saat ini, kita sudah mempunyai fondasi pengujian pada jalur sukses dan kegagalan server.
10. Menjalankan Unit Test
Setelah implementasi selesai, kita bisa menjalankan unit test shared module dari terminal di root project.
./gradlew :shared:allTests
Task yang tersedia bisa berbeda tergantung konfigurasi target Kotlin Multiplatform. Jika task tersebut tidak tersedia, periksa daftar Gradle task untuk source set dan target testing yang sudah dikonfigurasi.
Jika test gagal, periksa kembali beberapa hal berikut:
- Versi dependency Ktor harus konsisten.
- Struktur DTO harus sesuai dengan JSON yang digunakan pada test.
- WeatherApiClient harus menggunakan client yang diinjeksi.
- Konfigurasi Content Negotiation dan JSON serialization harus tersedia.
- HTTP error harus ditangani sesuai konfigurasi client.
Struktur Project Setelah Refactoring
Sampai di sini, struktur shared module kita sudah mulai berkembang. Secara konseptual, strukturnya menjadi seperti berikut.
shared/
└── src/
├── commonMain/
│ └── kotlin/
│ ├── domain/
│ │ ├── model/
│ │ │ └── Weather.kt
│ │ ├── repository/
│ │ │ └── WeatherRepository.kt
│ │ └── usecase/
│ │ └── GetWeatherUseCase.kt
│ └── data/
│ ├── dto/
│ │ └── ForecastResponse.kt
│ ├── mapper/
│ │ └── ForecastMapper.kt
│ ├── network/
│ │ └── WeatherApiClient.kt
│ └── repository/
│ └── WeatherRepositoryImpl.kt
└── commonTest/
└── kotlin/
└── data/
└── repository/
└── WeatherRepositoryImplTest.kt
Nama package dan folder dapat disesuaikan dengan project yang sudah dibuat pada artikel sebelumnya. Yang terpenting adalah pemisahan tanggung jawab antara Domain Layer dan Data Layer tetap terjaga.
Bagaimana Android dan iOS Menggunakan Shared Logic?
Inilah salah satu manfaat utama Kotlin Multiplatform. Kita bisa berbagi model, repository, networking, dan business logic tanpa harus berbagi UI.
Android akan menggunakan Jetpack Compose, sedangkan iOS akan menggunakan SwiftUI. Kedua platform dapat memanfaatkan shared logic yang sama melalui lapisan integrasi masing-masing.
Jadi kita tidak perlu memindahkan UI ke Compose Multiplatform hanya untuk berbagi business logic. Pendekatan tutorial ini tetap menggunakan Shared Logic, Native UI.
Kesimpulan
Pada artikel kelima ini kita sudah mulai memisahkan kode Weather App menggunakan Repository Pattern dan Domain Layer.
Kita sudah membuat:
- Weather sebagai domain model.
- WeatherRepository sebagai kontrak pengambilan data.
- WeatherRepositoryImpl sebagai implementasi repository.
- ForecastMapper untuk mengubah DTO menjadi domain model.
- GetWeatherUseCase sebagai representasi aksi untuk mendapatkan data cuaca.
- Error handling dasar dan unit test dengan kotlin.test serta Ktor MockEngine.
Pemisahan ini membantu kita menjaga business logic agar tidak bergantung langsung pada detail networking maupun UI platform tertentu.
Pada artikel berikutnya, kita akan mulai masuk ke fase UI native Android. Kita akan menghubungkan shared module dengan Android app, membuat WeatherViewModel, dan mengelola UI state menggunakan StateFlow.
Seperti biasa, source code project akan disertakan dalam repository GitHub dengan tag berdasarkan artikel agar teman-teman bisa mengikuti setiap tahap pengembangan.
Source code: Repository Weather App KMP
Sekian, terima kasih.

0 Komentar
Post a Comment
Please leave your comments, critiques or suggestions.
Because your opinion means a lot for this blog :)