Solution: UserDetailsRepository

This is a possible solution:

class UserDetailsRepository(
    private val client: UserDataClient,
    private val userDatabase: UserDetailsDatabase,
    private val backgroundScope: CoroutineScope,
) {
    suspend fun getUserDetails(): UserDetails =
        coroutineScope {
            val stored = userDatabase.load()
            if (stored != null) {
                return@coroutineScope stored
            }
            val name = async { client.getName() }
            val friends = async { client.getFriends() }
            val profile = async { client.getProfile() }
            val details = UserDetails(
                name = name.await(),
                friends = friends.await(),
                profile = profile.await(),
            )
            backgroundScope.launch { userDatabase.save(details) }
            details
        }
}

coroutineScope can either wrap whole function, or just async and await.

This problem can be also solved without the last async call. In such a case, the behavior of this function would remain the same, but I would consider it less readable.

class UserDetailsRepository(
    private val client: UserDataClient,
    private val userDatabase: UserDetailsDatabase,
    private val backgroundScope: CoroutineScope,
) {
    suspend fun getUserDetails(): UserDetails {
        val stored = userDatabase.load()
        if (stored != null) {
            return stored
        }
        val details = coroutineScope {
            val name = async { client.getName() }
            val friends = async { client.getFriends() }
            val profile = client.getProfile()
            UserDetails(
                name = name.await(),
                friends = friends.await(),
                profile = profile,
            )
        }
        backgroundScope.launch { userDatabase.save(details) }
        return details
    }
}

Example solution in playground

import kotlinx.coroutines.*
import kotlinx.coroutines.test.currentTime
import kotlinx.coroutines.test.runTest
import org.junit.Test
import kotlin.test.assertEquals

class UserDetailsRepository(
    private val client: UserDataClient,
    private val userDatabase: UserDetailsDatabase,
    private val backgroundScope: CoroutineScope,
) {
    suspend fun getUserDetails(): UserDetails =
        coroutineScope {
            val stored = userDatabase.load()
            if (stored != null) {
                return@coroutineScope stored
            }
            val name = async { client.getName() }
            val friends = async { client.getFriends() }
            val profile = async { client.getProfile() }
            val details = UserDetails(
                name = name.await(),
                friends = friends.await(),
                profile = profile.await(),
            )
            backgroundScope.launch { userDatabase.save(details) }
            details
        }
}

interface UserDataClient {
    suspend fun getName(): String
    suspend fun getFriends(): List<Friend>
    suspend fun getProfile(): Profile
}

interface UserDetailsDatabase {
    suspend fun load(): UserDetails?
    suspend fun save(user: UserDetails)
}

data class UserDetails(
    val name: String,
    val friends: List<Friend>,
    val profile: Profile
)

data class Friend(val id: String)
data class Profile(val description: String)

class UserDetailsRepositoryTest {

    @Test
    fun `should fetch details asynchronously`() = runTest {
        // given
        val client = object : UserDataClient {
            override suspend fun getName(): String {
                delay(100)
                return "Ben"
            }

            override suspend fun getFriends(): List<Friend> {
                delay(200)
                return listOf(Friend("friend-id-1"))
            }

            override suspend fun getProfile(): Profile {
                delay(300)
                return Profile("Example description")
            }
        }
        val database = InMemoryDatabase()
        val repo = UserDetailsRepository(client, database, backgroundScope)

        // when
        val details = repo.getUserDetails()

        // then
        assertEquals("Ben", details.name)
        assertEquals("friend-id-1", details.friends.single().id)
        assertEquals("Example description", details.profile.description)
        assertEquals(300, currentTime)
    }

    @Test
    fun `should save details to database asynchronously`() = runTest {
        // given
        val client = object : UserDataClient {
            override suspend fun getName(): String {
                delay(100)
                return "Ben"
            }

            override suspend fun getFriends(): List<Friend> {
                delay(100)
                return listOf(Friend("friend-id-1"))
            }

            override suspend fun getProfile(): Profile {
                delay(100)
                return Profile("Example description")
            }
        }
        val database = InMemoryDatabase(saveTime = 1_000)
        val repo = UserDetailsRepository(client, database, backgroundScope)

        // when
        repo.getUserDetails()

        // then
        assertEquals(100, currentTime)

        // when
        backgroundScope.coroutineContext.job.children.forEach { it.join() }

        // then
        assertEquals(1_100, currentTime)
    }

    @Test
    fun `should load from database`() = runTest {
        // given
        val database = InMemoryDatabase(loadTime = 10)
        database.save(UserDetails("Ben", listOf(Friend("friend-id-1")), Profile("Example description")))
        val client = object : UserDataClient {
            override suspend fun getName(): String {
                error("Should not be called")
            }

            override suspend fun getFriends(): List<Friend> {
                error("Should not be called")
            }

            override suspend fun getProfile(): Profile {
                error("Should not be called")
            }
        }
        val repo = UserDetailsRepository(client, database, backgroundScope)

        // when
        val details = repo.getUserDetails()

        // then
        assertEquals("Ben", details.name)
        assertEquals("friend-id-1", details.friends.single().id)
        assertEquals("Example description", details.profile.description)
        assertEquals(10, currentTime)
    }

    class InMemoryDatabase(
        private val saveTime: Long = 0,
        private val loadTime: Long = 0,
    ) : UserDetailsDatabase {
        private var stored: UserDetails? = null
        override suspend fun load(): UserDetails? {
            delay(loadTime)
            return stored
        }
        override suspend fun save(user: UserDetails) {
            delay(saveTime)
            stored = user
        }
    }
}