Refactor to context-params

androidApp/build.gradle.kts

@@ -1,4 +1,5 @@
 import app.futured.kmptemplate.gradle.configuration.ProjectSettings
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     alias(libs.plugins.android.application)
@@ -14,6 +15,9 @@ plugins {
 
 kotlin {
     jvmToolchain(ProjectSettings.Kotlin.JvmToolchainVersion)
+    compilerOptions {
+        jvmTarget = JvmTarget.fromTarget(ProjectSettings.Android.KotlinJvmTargetNum)
+    }
 }
 
 android {
@@ -89,10 +93,6 @@ android {
         targetCompatibility = ProjectSettings.Android.JavaCompatibility
     }
 
-    kotlinOptions {
-        jvmTarget = ProjectSettings.Android.KotlinJvmTargetNum
-    }
-
     lint {
         textReport = true // Write a text report to the console (Useful for CI logs)
         xmlReport = true // Write XML report
@@ -111,7 +111,7 @@ dependencies {
     implementation(projects.shared.app)
     implementation(projects.shared.feature)
     implementation(projects.shared.platform)
-    implementation(projects.shared.arkitektDecompose)
+    implementation(projects.shared.arkitektDecompose.architecture)
     implementation(projects.shared.resources)
 
     implementation(platform(libs.androidx.compose.bom))

gradle.properties

@@ -1,9 +1,9 @@
 #Gradle
 org.gradle.jvmargs=-Xmx6g -Xms256m -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dkotlin.daemon.jvm.options=-XX:MaxMetaspaceSize=1g
 org.gradle.parallel=true
-org.gradle.caching=true
+org.gradle.caching=false
 org.gradle.configureondemand=true
-org.gradle.configuration-cache=true
+org.gradle.configuration-cache=false
 # Use this flag carefully in case some of the plugins are not fully compatible.
 org.gradle.configuration-cache.problems=warn
 

gradle/libs.versions.toml

@@ -1,34 +1,34 @@
 [versions]
 agp = "8.9.0"
-kotlin = "2.1.10"
-ksp = "2.1.10-1.0.31" # Must be compatible with: `kotlin`
+kotlin = "2.2.0"
+ksp = "2.2.0-2.0.2" # Must be compatible with: `kotlin`
 desugarLibs = "2.1.5"
 androidxLifecycle = "2.8.6"
 androidxComposeBom = "2024.10.00"
 jetbrainsComposeRuntime = "1.7.0" # Needs to align with version in Compose BOM as closely as possible
 androidxActivity = "1.9.2"
 decompose = "3.1.0"
 essenty = "2.1.0"
-koin = "3.5.6"
-koinAnnotations = "1.4.0" # Must be compatible with: `ksp`
-kotlinx-coroutines = "1.8.1"
+koin = "4.1.0"
+koinAnnotations = "2.1.0" # Must be compatible with: `ksp`
+kotlinx-coroutines = "1.10.2"
 kotlinx-immutableCollections = "0.3.8"
 kotlinx-dateTime = "0.6.1"
 ktlintGradlePlugin = "12.2.0"
 ktlint = "1.5.0"
 detektGradlePlugin = "1.23.8"
 composeLint = "1.3.1"
-apollo = "4.0.0"
-ktorfit = "2.4.0" # Must be compatible with: `ksp`
-ktor = "3.1.0" # Must be compatible with: `ktorfit`
+apollo = "4.3.1"
+ktorfit = "2.6.1" # Must be compatible with: `ksp`
+ktor = "3.2.1" # Must be compatible with: `ktorfit`
 kotlinx-serialization = "1.8.0" # Must be compatible with: `kotlin`
 timber = "5.0.1"
-kermit = "2.0.2"
-skie = "0.10.1" # Must be compatible with: `kotlin`
+kermit = "2.0.6"
+skie = "0.10.4" # Must be compatible with: `kotlin`
 buildkonfig = "0.15.2"
 nsExceptionKt = "1.0.0-BETA-7"
 datastore = "1.1.1"
-moko-resources = "0.24.5"
+moko-resources = "0.25.0"
 baselineProfile = "1.3.0"
 junit = "1.2.1"
 espressoCore = "3.6.1"

settings.gradle.kts

@@ -19,7 +19,7 @@ rootProject.name = "KMP_Futured_template"
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
 
 include(":androidApp")
-include(":shared:arkitekt-decompose")
+include(":shared:arkitekt-decompose:architecture")
 include(":shared:arkitekt-decompose:annotation")
 include(":shared:arkitekt-decompose:processor")
 include(":shared:arkitekt-cr-usecases")

shared/app/build.gradle.kts

@@ -47,7 +47,7 @@ kotlin {
             isStatic = true
 
             export(projects.shared.platform)
-            export(projects.shared.arkitektDecompose)
+            export(projects.shared.arkitektDecompose.architecture)
             export(projects.shared.feature)
             export(projects.shared.resources)
 
@@ -88,7 +88,7 @@ kotlin {
         iosMain {
             dependencies {
                 api(projects.shared.platform)
-                api(projects.shared.arkitektDecompose)
+                api(projects.shared.arkitektDecompose.architecture)
                 api(projects.shared.feature)
                 api(projects.shared.resources)
 

shared/arkitekt-cr-usecases/build.gradle.kts

@@ -21,6 +21,10 @@ kotlin {
     iosArm64()
     iosSimulatorArm64()
 
+    compilerOptions {
+        freeCompilerArgs.add("-Xcontext-parameters")
+    }
+
     sourceSets {
         commonMain {
             dependencies {

shared/arkitekt-cr-usecases/src/commonMain/kotlin/app/futured/arkitekt/crusecases/FlowUseCase.kt

@@ -1,11 +1,21 @@
 package app.futured.arkitekt.crusecases
 
-import app.futured.arkitekt.crusecases.scope.FlowUseCaseExecutionScope
+import app.futured.arkitekt.crusecases.error.UseCaseErrorHandler
+import app.futured.arkitekt.crusecases.scope.CoroutineScopeOwner
+import app.futured.arkitekt.crusecases.scope.FlowUseCaseConfig
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.onStart
+import kotlin.coroutines.cancellation.CancellationException
 
 /**
- * Base [Flow] use case meant to use in [FlowUseCaseExecutionScope] implementations
+ * Base [Flow] use case meant to use in [CoroutineScopeOwner] implementations
  */
 abstract class FlowUseCase<ARGS, T> {
 
@@ -20,3 +30,110 @@ abstract class FlowUseCase<ARGS, T> {
      */
     abstract fun build(args: ARGS): Flow<T>
 }
+
+/**
+ * Asynchronously executes use case and consumes data from flow on UI thread.
+ * By default all previous pending executions are canceled, this can be changed
+ * by [config]. When suspend function in use case finishes, onComplete is called
+ * on UI thread. This version is gets initial arguments by [args].
+ *
+ * In case that an error is thrown during the execution of [FlowUseCase] then
+ * [UseCaseErrorHandler.globalOnErrorLogger] is called with the error as an argument.
+ *
+ * @param args Arguments used for initial use case initialization.
+ * @param config [FlowUseCaseConfig] used to process results of internal
+ * Flow and to set configuration options.
+ **/
+context(coroutineScopeOwner: CoroutineScopeOwner)
+fun <ARGS, T : Any?> FlowUseCase<ARGS, T>.execute(
+    args: ARGS,
+    config: FlowUseCaseConfig.Builder<T, T>.() -> Unit,
+) {
+    val flowUseCaseConfig = FlowUseCaseConfig.Builder<T, T>().run {
+        config.invoke(this)
+        return@run build()
+    }
+
+    if (flowUseCaseConfig.disposePrevious) {
+        job?.cancel()
+    }
+
+    job = build(args)
+        .flowOn(coroutineScopeOwner.getWorkerDispatcher())
+        .onStart { flowUseCaseConfig.onStart() }
+        .onEach { flowUseCaseConfig.onNext(it) }
+        .onCompletion { error ->
+            when {
+                error is CancellationException -> {
+                    // ignore this exception
+                }
+
+                error != null -> {
+                    UseCaseErrorHandler.globalOnErrorLogger(error)
+                    flowUseCaseConfig.onError(error)
+                }
+
+                else -> flowUseCaseConfig.onComplete()
+            }
+        }
+        .catch { /* handled in onCompletion */ }
+        .launchIn(coroutineScopeOwner.viewModelScope)
+}
+
+context(coroutineScopeOwner: CoroutineScopeOwner)
+fun <T : Any?> FlowUseCase<Unit, T>.execute(config: FlowUseCaseConfig.Builder<T, T>.() -> Unit) =
+    execute(Unit, config)
+
+context(coroutineScopeOwner: CoroutineScopeOwner)
+fun <T : Any?, M : Any?> FlowUseCase<Unit, T>.executeMapped(config: FlowUseCaseConfig.Builder<T, M>.() -> Unit) =
+    executeMapped(Unit, config)
+
+/**
+ * Asynchronously executes use case and consumes data from flow on UI thread.
+ * By default all previous pending executions are canceled, this can be changed
+ * by [config]. When suspend function in use case finishes, onComplete is called
+ * on UI thread. This version is gets initial arguments by [args].
+ *
+ * In case that an error is thrown during the execution of [FlowUseCase] then
+ * [UseCaseErrorHandler.globalOnErrorLogger] is called with the error as an argument.
+ *
+ * @param args Arguments used for initial use case initialization.
+ * @param config [FlowUseCaseConfig] used to process results of internal
+ * Flow and to set configuration options.
+ **/
+context(coroutineScopeOwner: CoroutineScopeOwner)
+fun <ARGS, T : Any?, M : Any?> FlowUseCase<ARGS, T>.executeMapped(
+    args: ARGS,
+    config: FlowUseCaseConfig.Builder<T, M>.() -> Unit,
+) {
+    val flowUseCaseConfig = FlowUseCaseConfig.Builder<T, M>().run {
+        config.invoke(this)
+        return@run build()
+    }
+
+    if (flowUseCaseConfig.disposePrevious) {
+        job?.cancel()
+    }
+
+    job = build(args)
+        .flowOn(coroutineScopeOwner.getWorkerDispatcher())
+        .onStart { flowUseCaseConfig.onStart() }
+        .mapNotNull { flowUseCaseConfig.onMap?.invoke(it) }
+        .onEach { flowUseCaseConfig.onNext(it) }
+        .onCompletion { error ->
+            when {
+                error is CancellationException -> {
+                    // ignore this exception
+                }
+
+                error != null -> {
+                    UseCaseErrorHandler.globalOnErrorLogger(error)
+                    flowUseCaseConfig.onError(error)
+                }
+
+                else -> flowUseCaseConfig.onComplete()
+            }
+        }
+        .catch { /* handled in onCompletion */ }
+        .launchIn(coroutineScopeOwner.viewModelScope)
+}

shared/arkitekt-cr-usecases/src/commonMain/kotlin/app/futured/arkitekt/crusecases/UseCase.kt

@@ -1,10 +1,17 @@
 package app.futured.arkitekt.crusecases
 
-import app.futured.arkitekt.crusecases.scope.SingleUseCaseExecutionScope
+import app.futured.arkitekt.crusecases.error.UseCaseErrorHandler
+import app.futured.arkitekt.crusecases.scope.CoroutineScopeOwner
+import app.futured.arkitekt.crusecases.scope.UseCaseConfig
+import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlin.coroutines.cancellation.CancellationException
 
 /**
- * Base Coroutine use case meant to use in [SingleUseCaseExecutionScope] implementations
+ * Base Coroutine use case meant to use in [CoroutineScopeOwner] implementations
  */
 abstract class UseCase<ARGS, T> {
 
@@ -18,3 +25,95 @@ abstract class UseCase<ARGS, T> {
      */
     abstract suspend fun build(args: ARGS): T
 }
+
+/**
+ * Asynchronously executes use case and saves it's Deferred. By default, all previous
+ * pending executions are canceled, this can be changed by the [config].
+ * This version is used for use cases without initial arguments.
+ *
+ * @param config [UseCaseConfig] used to process results of internal
+ * Coroutine and to set configuration options.
+ */
+context(coroutineScopeOwner: CoroutineScopeOwner)
+fun <T : Any?> UseCase<Unit, T>.execute(config: UseCaseConfig.Builder<T>.() -> Unit) =
+    execute(Unit, config)
+
+/**
+ * Asynchronously executes use case and saves it's Deferred. By default, all previous
+ * pending executions are canceled, this can be changed by the [config].
+ * This version gets initial arguments by [args].
+ *
+ * In case that an error is thrown during the execution of [UseCase] then [UseCaseErrorHandler.globalOnErrorLogger]
+ * is called with the error as an argument.
+ *
+ * @param args Arguments used for initial use case initialization.
+ * @param config [UseCaseConfig] used to process results of internal
+ * Coroutine and to set configuration options.
+ */
+context(coroutineScopeOwner: CoroutineScopeOwner)
+fun <ARGS, T : Any?> UseCase<ARGS, T>.execute(
+    args: ARGS,
+    config: UseCaseConfig.Builder<T>.() -> Unit,
+) {
+    val useCaseConfig = UseCaseConfig.Builder<T>().run {
+        config.invoke(this)
+        return@run build()
+    }
+    if (useCaseConfig.disposePrevious) {
+        deferred?.cancel()
+    }
+
+    useCaseConfig.onStart()
+    deferred = coroutineScopeOwner.viewModelScope
+        .async(context = coroutineScopeOwner.getWorkerDispatcher(), start = CoroutineStart.LAZY) {
+            build(args)
+        }
+        .also {
+            coroutineScopeOwner.viewModelScope.launch(Dispatchers.Main) {
+                try {
+                    useCaseConfig.onSuccess(it.await())
+                } catch (cancellation: CancellationException) {
+                    // do nothing - this is normal way of suspend function interruption
+                } catch (error: Throwable) {
+                    UseCaseErrorHandler.globalOnErrorLogger(error)
+                    useCaseConfig.onError(error)
+                }
+            }
+        }
+}
+
+/**
+ * Synchronously executes use case and saves it's Deferred. By default all previous
+ * pending executions are canceled, this can be changed by the [cancelPrevious].
+ * This version gets initial arguments by [args].
+ *
+ * [UseCaseErrorHandler.globalOnErrorLogger] is not used in this version of the execute
+ * method since it is recommended to call all execute methods with [Result] return type
+ * from [UseCaseExecutionScope.launchWithHandler] method,
+ * where [UseCaseErrorHandler.globalOnErrorLogger] is used.
+ *
+ * @param args Arguments used for initial use case initialization.
+ * @return [Result] that encapsulates either a successful result with [Success] or a failed result with [Error]
+ */
+@Suppress("TooGenericExceptionCaught")
+context(coroutineScopeOwner: CoroutineScopeOwner)
+suspend fun <ARGS, T : Any?> UseCase<ARGS, T>.execute(
+    args: ARGS,
+    cancelPrevious: Boolean = true,
+): Result<T> {
+    if (cancelPrevious) {
+        deferred?.cancel()
+    }
+
+    return try {
+        val newDeferred = coroutineScopeOwner.viewModelScope.async(coroutineScopeOwner.getWorkerDispatcher(), CoroutineStart.LAZY) {
+            build(args)
+        }.also { deferred = it }
+
+        Result.success(newDeferred.await())
+    } catch (exception: CancellationException) {
+        throw exception
+    } catch (exception: Throwable) {
+        Result.failure(exception)
+    }
+}