android-arquitectura-limpia

Files (1)

• SKILL.md

SKILL.md (first lines)

## Module Structure

```
app/
├── di/                         # Hilt modules
├── navigation/
data/
├── remote/
│   ├── api/                    # Retrofit interfaces
│   ├── dto/                    # Network models
│   └── mapper/                 # DTO → Entity mappers
├── local/
│   ├── dao/                    # Room DAOs
│   ├── entity/                 # DB entities
│   └── mapper/
├── repository/                 # Repository implementations
domain/
├── model/                      # Domain models
├── repository/                 # Repository interfaces
├── usecase/                    # Use cases
feature/
├── login/
│   ├── LoginScreen.kt
│   ├── LoginViewModel.kt
│   └── LoginUiState.kt
├── dashboard/
└── settings/
```

## Domain Layer

### Model

```kotlin
data class User(
    val id: String,
    val email: String,
    val name: String,
    val avatarUrl: String?,
)
```

### Repository Interface

```kotlin
interface UserRepository {
    suspend fun getById(id: String): Result<User>
    suspend fun search(query: String, page: Int): Result<PagedResult<User>>
    suspend fun save(user: User): Result<User>
}
```

### Use Case

```kotlin
class GetUserUseCase @Inject constructor(
    private val repository: UserRepository,
) {
    suspend operator fun invoke(id: String): Result<User> =
        repository.getById(id)
}

class SearchUsersUseCase @Inject constructor(
    private val repository: UserRepository,
) {
    suspend operator fun invoke(query: String, page: Int = 1): Result<PagedResult<User>> {
        if (query.isBlank()) return Result.failure(ValidationException("Query cannot be empty"))
        return repository.search(query.trim(), page)
    }
}
```

## Data Layer

### API (Retrofit)

```kotlin
interface UserApi {
    @GET("users/{id}")
    suspend fun getUser(@Path("id") id: String): UserDto

    @GET("users")
    suspend fun searchUsers(
        @Query("q") query: String,
        @Query("page") page: Int,
        @Query("per_page") perPage: Int = 20,
    ): PagedResponse<UserDto>
}

@Serializable
data class UserDto(
    @SerialName("id") val id: String,
    @SerialName("email") val email: String,
    @SerialName("name") val name: String,
    @SerialName("avatar_url") val avatarUrl: String? = null,
)

fun UserDto.toDomain() = User(id = id, email = email, name = name, avatarUrl = avatarUrl)
```

### Repository Implementation

```kotlin
class UserRepositoryImpl @Inject constructor(
    private val api: UserApi,
    private val dao: UserDao,
) : UserRepository {

    override suspend fun getById(id: String): Result<User> = runCatching {
        // Cache-first strategy
        dao.getById(id)?.toDomain() ?: api.getUser(id).also {
            dao.insert(it.toEntity())
        }.toDomain()
    }

    override suspend fun search(query: String, page: Int): Result<PagedResult<User>> = runCatching {
        val response = api.searchUsers(query, page)
        response.items.map { it.toDomain() }.let {
            PagedResult(items = it, total = response.total, page = page)

From tontojil/PerfeckCode, MIT.

More from tontojil/PerfeckCode