feat: create home module

.github/workflows/katana.yml

@@ -55,6 +55,13 @@ jobs:
           gradle-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
       - name: Assemble Katana
         run: ./gradlew assembleDebug --no-daemon --stacktrace
+      - name: Upload debug artifacts
+        uses: actions/[email protected]
+        with:
+          name: Katana v${{ github.run_number }}
+          path: |
+            ${{ vars.ANDROID_DEBUG_APK }}
+          retention-days: 7
       - name: Upload compose reports artifact
         uses: actions/[email protected]
         if: always()
@@ -64,24 +71,6 @@ jobs:
             **/build/compose-metrics
             **/build/compose-reports
           retention-days: 7
-      - name: Upload Android APK
-        uses: rnkdsh/[email protected]
-        id: diawi_android
-        with:
-          token: ${{ secrets.DIAWI_TOKEN }}
-          file: ${{ vars.ANDROID_DEBUG_APK }}
-      - name: Post comment with Diawi link
-        uses: peter-evans/[email protected]
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body: |
-            | Android                                       | iOS      |
-            |:---------------------------------------------:|:--------:|
-            | [Download APK (v${{ github.run_number }})][1] | Not yet. |
-            | ![2]                                          | Not yet. |
-
-            [1]: ${{ steps.diawi_android.outputs.url }}
-            [2]: https://api.qrserver.com/v1/create-qr-code/?size=200x200&data=${{ steps.diawi_android.outputs.url }}
 
   static-analysis:
     name: Static analysis

build-logic/katana-convention/src/main/kotlin/dev/alvr/katana/buildlogic/mp/mobile/data/KatanaMultiplatformDataPreferencesPlugin.kt

@@ -14,6 +14,7 @@ internal class KatanaMultiplatformDataPreferencesPlugin : Plugin<Project> {
 
     override fun apply(target: Project) = with(target) {
         apply(plugin = "katana.multiplatform.mobile")
+        apply(plugin = "org.jetbrains.kotlin.plugin.serialization")
 
         with(extensions) {
             configure<KotlinMultiplatformExtension> { configureMultiplatform() }

build-logic/katana-convention/src/main/kotlin/dev/alvr/katana/buildlogic/mp/mobile/ui/KatanaMultiplatformComposePlugin.kt

@@ -91,6 +91,8 @@ internal class KatanaMultiplatformComposePlugin : Plugin<Project> {
 
         kotlinCompilerPluginArgs.set(
             buildList {
+                add("experimentalStrongSkipping=${composePluginEnabled("katana.strongSkipping")}")
+
                 if (composePluginEnabled("katana.enableComposeCompilerMetrics")) {
                     add("metricsDestination=${composePluginDir("compose-metrics")}")
                 }

build.gradle.kts

@@ -16,4 +16,5 @@ plugins {
     alias(libs.plugins.ksp) apply false
     alias(libs.plugins.mokkery) apply false
     alias(libs.plugins.sentry) apply false
+    alias(libs.plugins.serialization) apply false
 }

common/session/data/build.gradle.kts

@@ -1,6 +1,5 @@
 plugins {
     id("katana.multiplatform.data.preferences")
-    alias(libs.plugins.serialization)
 }
 
 katanaMultiplatform {

common/session/data/src/commonMain/kotlin/dev/alvr/katana/common/session/data/di/module.kt

@@ -19,7 +19,7 @@ private val sourcesModule = module {
     singleOf(::SessionLocalSourceImpl).bind<SessionLocalSource>()
 }
 
-val dataPreferencesSessionModule = module {
+val commonSessionDataModule = module {
     includes(dataStoreModule(), repositoriesModule, sourcesModule)
 }
 

common/session/data/src/commonTest/kotlin/dev/alvr/katana/common/session/data/datastore/SessionDataStoreTest.kt

@@ -8,7 +8,7 @@ import dev.alvr.katana.common.session.data.di.deleteDataStoreFiles
 import dev.alvr.katana.common.session.data.di.testDataStoreModule
 import dev.alvr.katana.common.session.data.models.Session
 import dev.alvr.katana.common.session.domain.models.AnilistToken
-import dev.alvr.katana.core.tests.KoinExtension
+import dev.alvr.katana.core.tests.koinExtension
 import io.kotest.core.spec.style.FreeSpec
 import io.kotest.core.test.TestCase
 import io.kotest.matchers.equals.shouldBeEqual
@@ -55,9 +55,9 @@ internal class SessionDataStoreTest : FreeSpec(), KoinTest {
         }
     }
 
-    override fun extensions() = listOf(KoinExtension(testDataStoreModule()))
-
     override suspend fun beforeEach(testCase: TestCase) {
         deleteDataStoreFiles()
     }
+
+    override fun extensions() = listOf(koinExtension(testDataStoreModule()))
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/di/module.kt

@@ -18,6 +18,6 @@ private val useCasesModule = module {
     factoryOf(::SaveSessionUseCase)
 }
 
-val domainSessionModule = module {
+val commonSessionDomainModule = module {
     includes(useCasesModule)
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/usecases/ClearActiveSessionUseCase.kt

@@ -1,10 +1,12 @@
 package dev.alvr.katana.common.session.domain.usecases
 
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.EitherUseCase
 
 class ClearActiveSessionUseCase(
+    dispatcher: KatanaDispatcher,
     private val repository: SessionRepository,
-) : EitherUseCase<Unit, Unit> {
-    override suspend fun invoke(params: Unit) = repository.clearActiveSession()
+) : EitherUseCase<Unit, Unit>(dispatcher) {
+    override suspend fun run(params: Unit) = repository.clearActiveSession()
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/usecases/DeleteAnilistTokenUseCase.kt

@@ -1,10 +1,12 @@
 package dev.alvr.katana.common.session.domain.usecases
 
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.EitherUseCase
 
 class DeleteAnilistTokenUseCase(
+    dispatcher: KatanaDispatcher,
     private val repository: SessionRepository,
-) : EitherUseCase<Unit, Unit> {
-    override suspend fun invoke(params: Unit) = repository.deleteAnilistToken()
+) : EitherUseCase<Unit, Unit>(dispatcher) {
+    override suspend fun run(params: Unit) = repository.deleteAnilistToken()
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/usecases/GetAnilistTokenUseCase.kt

@@ -2,10 +2,12 @@ package dev.alvr.katana.common.session.domain.usecases
 
 import dev.alvr.katana.common.session.domain.models.AnilistToken
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.OptionUseCase
 
 class GetAnilistTokenUseCase(
+    dispatcher: KatanaDispatcher,
     private val repository: SessionRepository,
-) : OptionUseCase<Unit, AnilistToken> {
-    override suspend fun invoke(params: Unit) = repository.getAnilistToken()
+) : OptionUseCase<Unit, AnilistToken>(dispatcher) {
+    override suspend fun run(params: Unit) = repository.getAnilistToken()
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/usecases/LogOutUseCase.kt

@@ -1,10 +1,12 @@
 package dev.alvr.katana.common.session.domain.usecases
 
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.EitherUseCase
 
 class LogOutUseCase(
+    dispatcher: KatanaDispatcher,
     private val repository: SessionRepository,
-) : EitherUseCase<Unit, Unit> {
-    override suspend fun invoke(params: Unit) = repository.logout()
+) : EitherUseCase<Unit, Unit>(dispatcher) {
+    override suspend fun run(params: Unit) = repository.logout()
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/usecases/ObserveActiveSessionUseCase.kt

@@ -1,10 +1,12 @@
 package dev.alvr.katana.common.session.domain.usecases
 
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.FlowEitherUseCase
 
 class ObserveActiveSessionUseCase(
+    dispatcher: KatanaDispatcher,
     private val repository: SessionRepository,
-) : FlowEitherUseCase<Unit, Boolean>() {
+) : FlowEitherUseCase<Unit, Boolean>(dispatcher) {
     override fun createFlow(params: Unit) = repository.sessionActive
 }

common/session/domain/src/commonMain/kotlin/dev/alvr/katana/common/session/domain/usecases/SaveSessionUseCase.kt

@@ -2,10 +2,12 @@ package dev.alvr.katana.common.session.domain.usecases
 
 import dev.alvr.katana.common.session.domain.models.AnilistToken
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.EitherUseCase
 
 class SaveSessionUseCase(
+    dispatcher: KatanaDispatcher,
     private val repository: SessionRepository,
-) : EitherUseCase<AnilistToken, Unit> {
-    override suspend fun invoke(token: AnilistToken) = repository.saveSession(token)
+) : EitherUseCase<AnilistToken, Unit>(dispatcher) {
+    override suspend fun run(params: AnilistToken) = repository.saveSession(params)
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/ClearActiveSessionUseCaseTest.kt

@@ -4,20 +4,27 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class ClearActiveSessionUseCaseTest : FreeSpec() {
+internal class ClearActiveSessionUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = ClearActiveSessionUseCase(repo)
+    private lateinit var useCase: ClearActiveSessionUseCase
 
     init {
         "successfully clearing the session" {
@@ -37,4 +44,10 @@ internal class ClearActiveSessionUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = ClearActiveSessionUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/DeleteAnilistTokenUseCaseTest.kt

@@ -4,20 +4,27 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class DeleteAnilistTokenUseCaseTest : FreeSpec() {
+internal class DeleteAnilistTokenUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = DeleteAnilistTokenUseCase(repo)
+    private lateinit var useCase: DeleteAnilistTokenUseCase
 
     init {
         "successfully deleting the token" {
@@ -37,4 +44,10 @@ internal class DeleteAnilistTokenUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = DeleteAnilistTokenUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/GetAnilistTokenUseCaseTest.kt

@@ -4,19 +4,26 @@ import arrow.core.none
 import arrow.core.some
 import dev.alvr.katana.common.session.domain.anilistTokenMock
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeNone
 import dev.alvr.katana.core.tests.shouldBeSome
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class GetAnilistTokenUseCaseTest : FreeSpec() {
+internal class GetAnilistTokenUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = GetAnilistTokenUseCase(repo)
+    private lateinit var useCase: GetAnilistTokenUseCase
 
     init {
         "successfully getting the token" {
@@ -31,4 +38,10 @@ internal class GetAnilistTokenUseCaseTest : FreeSpec() {
             verifySuspend { repo.getAnilistToken() }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = GetAnilistTokenUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/LogOutUseCaseTest.kt

@@ -4,20 +4,27 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class LogOutUseCaseTest : FreeSpec() {
+internal class LogOutUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = LogOutUseCase(repo)
+    private lateinit var useCase: LogOutUseCase
 
     init {
         "successfully saving the session" {
@@ -37,4 +44,10 @@ internal class LogOutUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = LogOutUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }