Architecture: MVVM, MVI and Clean

// Data source: Room
@Dao
interface OrderDao {
    @Query("SELECT * FROM orders WHERE customerId = :customerId ORDER BY createdAt DESC")
    fun observeOrders(customerId: String): Flow<List<OrderEntity>>

    @Upsert suspend fun upsertAll(orders: List<OrderEntity>)
}

// Repository: the only class the rest of the app asks for orders
class OrderRepository @Inject constructor(
    private val dao: OrderDao,
    private val api: OrdersApi,
    @IoDispatcher private val io: CoroutineDispatcher,
) {
    fun orders(customerId: String): Flow<List<Order>> =
        dao.observeOrders(customerId).map { rows -> rows.map(OrderEntity::toDomain) }

    suspend fun refresh(customerId: String) = withContext(io) {
        val fresh = api.orders(customerId)                 // network DTOs
        dao.upsertAll(fresh.map(OrderDto::toEntity))       // the Flow above emits automatically
    }
}

// Domain layer: a rule two screens need
class CanCancelOrderUseCase @Inject constructor(private val clock: Clock) {
    operator fun invoke(order: Order): Boolean =
        order.status == OrderStatus.PLACED &&
            Duration.between(order.createdAt, clock.instant()) < Duration.ofHours(1)
}

// UI layer: the ViewModel combines them into UI state
@HiltViewModel
class OrdersViewModel @Inject constructor(
    private val repository: OrderRepository,
    private val canCancel: CanCancelOrderUseCase,
    session: Session,
) : ViewModel() {
    private val customerId = session.customerId

    val uiState: StateFlow<OrdersUiState> = repository.orders(customerId)
        .map { orders -> OrdersUiState.Loaded(orders.map { OrderRow(it, canCancel = canCancel(it)) }) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), OrdersUiState.Loading)

    init { viewModelScope.launch { runCatching { repository.refresh(customerId) } } }
}

data class OrdersUiState(
    val orders: List<OrderRow> = emptyList(),
    val isRefreshing: Boolean = false,
    val refreshFailed: Boolean = false,
    val filter: OrderFilter = OrderFilter.All,
)

sealed interface OrdersAction {
    data object Refresh : OrdersAction
    data class SetFilter(val filter: OrderFilter) : OrdersAction
    data class Cancel(val id: OrderId) : OrdersAction
}

@HiltViewModel
class OrdersViewModel @Inject constructor(
    private val repository: OrderRepository,
    private val canCancel: CanCancelOrderUseCase,
    private val session: Session,
) : ViewModel() {
    private val filter = MutableStateFlow(OrderFilter.All)
    private val refresh = MutableStateFlow(RefreshStatus.Idle)

    val uiState: StateFlow<OrdersUiState> = combine(
        repository.orders(session.customerId), filter, refresh,
    ) { orders, filter, refresh ->
        OrdersUiState(
            orders = orders.filter(filter::matches).map { OrderRow(it, canCancel(it)) },
            isRefreshing = refresh == RefreshStatus.Running,
            refreshFailed = refresh == RefreshStatus.Failed,
            filter = filter,
        )
    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), OrdersUiState())

    fun onAction(action: OrdersAction) {
        when (action) {
            OrdersAction.Refresh -> viewModelScope.launch {
                refresh.value = RefreshStatus.Running
                refresh.value = runCatching { repository.refresh(session.customerId) }
                    .fold({ RefreshStatus.Idle }, { RefreshStatus.Failed })
            }
            is OrdersAction.SetFilter -> filter.value = action.filter
            is OrdersAction.Cancel -> viewModelScope.launch { repository.cancel(action.id) }
        }
    }
}