Column extensions eqOrIsNull and neqOrIsNotNull

0.16.5

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.16.6
+
+* `Startup`:
+    * `Launcher`:
+        * Improvements in `StartLauncherPlugin#start` methods
+        * Add opportunity to pass second argument on `JVM` platform as log level
+* `Repos`:
+    * `Ktor`:
+        * `Client`:
+            * All clients repos got opportunity to customize their flows
+    * `Exposed`:
+        * Extensions `eqOrIsNull` and `neqOrIsNotNull` for `Column`
+
+## 0.16.5
+
+* `Versions`:
+    * `Ktor`: `2.2.1` -> `2.2.2`
+
+## 0.16.4
+
+* `Coroutines`:
+    * Create `launchInCurrentThread`
+
+## 0.16.3
+
+* `Startup`:
+    * `Launcher`:
+        * All starting API have been moved into `StartLauncherPlugin` and do not require serialize/deserialize cycle for now
+
 ## 0.16.2
 
 * `Versions`:

coroutines/build.gradle

@@ -22,6 +22,7 @@ kotlin {
             dependencies {
                 api libs.kt.coroutines.android
             }
+            dependsOn(jvmMain)
         }
     }
 }

coroutines/src/jvmMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchInCurrentThread.kt

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+
+fun <T> launchInCurrentThread(block: suspend CoroutineScope.() -> T): T {
+    val scope = CoroutineScope(Dispatchers.Unconfined)
+    return scope.launchSynchronously(block)
+}

coroutines/src/jvmMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSynchronously.kt

@@ -6,7 +6,7 @@ fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T
     var result: Result<T>? = null
     val objectToSynchronize = Object()
     synchronized(objectToSynchronize) {
-        launch {
+        launch(start = CoroutineStart.UNDISPATCHED) {
             result = safelyWithResult(block)
         }.invokeOnCompletion {
             synchronized(objectToSynchronize) {

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/LaunchInCurrentThreadTests.kt

@@ -0,0 +1,47 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class LaunchInCurrentThreadTests {
+    @Test
+    fun simpleTestThatLaunchInCurrentThreadWorks() {
+        val expectedResult = 10
+        val result = launchInCurrentThread {
+            expectedResult
+        }
+        assertEquals(expectedResult, result)
+    }
+    @Test
+    fun simpleTestThatSeveralLaunchInCurrentThreadWorks() {
+        val testData = 0 until 100
+
+        testData.forEach {
+            val result = launchInCurrentThread {
+                it
+            }
+            assertEquals(it, result)
+        }
+    }
+    @Test
+    fun simpleTestThatLaunchInCurrentThreadWillCorrectlyHandleSuspensionsWorks() {
+        val testData = 0 until 100
+
+        suspend fun test(data: Any): Any {
+            return withContext(Dispatchers.Default) {
+                delay(1)
+                data
+            }
+        }
+
+        testData.forEach {
+            val result = launchInCurrentThread {
+                test(it)
+            }
+            assertEquals(it, result)
+        }
+    }
+}

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.16.2
+version=0.16.6
-android_code_version=170
+android_code_version=174

gradle/libs.versions.toml

@@ -13,7 +13,7 @@ jb-dokka = "1.7.20"
 klock = "3.4.0"
 uuid = "0.6.0"
 
-ktor = "2.2.1"
+ktor = "2.2.2"
 
 gh-release = "2.4.1"
 

ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/client/NewFlowsWebsockets.kt

@@ -19,7 +19,7 @@ import kotlinx.coroutines.isActive
  * connection. Must return true in case if must be reconnected. By default always reconnecting
  */
 @Warning("This feature is internal and should not be used directly. It is can be changed without any notification and warranty on compile-time or other guaranties")
-inline fun <reified T : Any> openBaseWebSocketFlow(
+inline fun <T : Any> openBaseWebSocketFlow(
     noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
     noinline webSocketSessionRequest: suspend SendChannel<T>.() -> Unit
 ): Flow<T> {
@@ -57,7 +57,7 @@ inline fun <reified T : Any> HttpClient.openWebSocketFlow(
 ): Flow<T> {
     pluginOrNull(WebSockets) ?: error("Plugin $WebSockets must be installed for using createStandardWebsocketFlow")
 
-    return openBaseWebSocketFlow<T>(checkReconnection) {
+    return openBaseWebSocketFlow(checkReconnection) {
         val block: suspend DefaultClientWebSocketSession.() -> Unit = {
             while (isActive) {
                 send(receiveDeserialized<T>())

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/ColumnEqOrNull.kt

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.repos.exposed
+
+import org.jetbrains.exposed.sql.Column
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.isNotNull
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.isNull
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.neq
+
+fun <T> Column<T?>.eqOrIsNull(
+    value: T?
+) = if (value == null) {
+    isNull()
+} else {
+    eq(value)
+}
+
+fun <T> Column<T?>.neqOrIsNotNull(
+    value: T?
+) = if (value == null) {
+    isNotNull()
+} else {
+    neq(value)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorCRUDRepoClient.kt

@@ -1,12 +1,17 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
+import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ktor.common.crud.deletedObjectsIdsFlowRouting
+import dev.inmo.micro_utils.repos.ktor.common.crud.newObjectsFlowRouting
+import dev.inmo.micro_utils.repos.ktor.common.crud.updatedObjectsFlowRouting
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
+import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 
 class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
@@ -21,6 +26,15 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
             baseUrl: String,
             httpClient: HttpClient,
             contentType: ContentType,
+            newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, newObjectsFlowRouting),
+            ),
+            updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
+            ),
+            deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
+            ),
             noinline idSerializer: suspend (IdType) -> String
         ) = KtorCRUDRepoClient(
             KtorReadCRUDRepoClient(
@@ -35,7 +49,10 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
             KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(
                 baseUrl,
                 httpClient,
-                contentType
+                contentType,
+                newObjectsFlow,
+                updatedObjectsFlow,
+                deletedObjectsIdsFlow
             )
         )
 
@@ -44,11 +61,23 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
             subpart: String,
             httpClient: HttpClient,
             contentType: ContentType,
+            newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, newObjectsFlowRouting),
+            ),
+            updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
+            ),
+            deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
+            ),
             noinline idSerializer: suspend (IdType) -> String
         ) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
+            newObjectsFlow,
+            updatedObjectsFlow,
+            deletedObjectsIdsFlow,
             idSerializer
         )
     }
@@ -80,11 +109,23 @@ inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepo
     subpart: String,
     httpClient: HttpClient,
     contentType: ContentType,
+    newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, newObjectsFlowRouting),
+    ),
+    updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
+    ),
+    deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
+    ),
     noinline idSerializer: suspend (IdType) -> String
 ) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
     buildStandardUrl(baseUrl, subpart),
     httpClient,
     contentType,
+    newObjectsFlow,
+    updatedObjectsFlow,
+    deletedObjectsIdsFlow,
     idSerializer
 )
 

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorWriteCrudRepoClient.kt

@@ -53,19 +53,22 @@ class KtorWriteCrudRepoClient<ObjectType, IdType, InputValue> (
         inline operator fun <reified ObjectType, reified IdType, reified InputValue> invoke(
             baseUrl: String,
             httpClient: HttpClient,
-            contentType: ContentType
+            contentType: ContentType,
+            newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, newObjectsFlowRouting),
+            ),
+            updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
+            ),
+            deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
+            ),
         ) = KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(
             baseUrl,
             httpClient,
-            httpClient.createStandardWebsocketFlow(
+            newObjectsFlow,
-                buildStandardUrl(baseUrl, newObjectsFlowRouting),
+            updatedObjectsFlow,
-            ),
+            deletedObjectsIdsFlow,
-            httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
-            ),
-            httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
-            ),
             {
                 contentType(contentType)
                 setBody(it)

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/value/KtorKeyValueRepoClient.kt

@@ -1,10 +1,14 @@
 package dev.inmo.micro_utils.repos.ktor.client.key.value
 
+import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ktor.common.key_value.onNewValueRoute
+import dev.inmo.micro_utils.repos.ktor.common.key_value.onValueRemovedRoute
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.http.encodeURLQueryComponent
+import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 
 class KtorKeyValueRepoClient<Key, Value> (
@@ -20,6 +24,12 @@ class KtorKeyValueRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline idSerializer: suspend (Key) -> String,
+            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            onValueRemoved: Flow<Key> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValueRepoClient(
             KtorReadKeyValueRepoClient(
@@ -28,7 +38,9 @@ class KtorKeyValueRepoClient<Key, Value> (
             KtorWriteKeyValueRepoClient(
                 baseUrl,
                 httpClient,
-                contentType
+                contentType,
+                onNewValue,
+                onValueRemoved
             )
         )
         inline operator fun <reified Key, reified Value> invoke(
@@ -37,12 +49,20 @@ class KtorKeyValueRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline idSerializer: suspend (Key) -> String,
+            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            onValueRemoved: Flow<Key> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValueRepoClient(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
             idSerializer,
+            onNewValue,
+            onValueRemoved,
             valueSerializer
         )
     }

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/value/KtorWriteKeyValueRepoClient.kt

@@ -60,17 +60,19 @@ class KtorWriteKeyValueRepoClient<Key, Value>(
         inline operator fun <reified Key, reified Value> invoke(
             baseUrl: String,
             httpClient: HttpClient,
-            contentType: ContentType
+            contentType: ContentType,
+            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            onValueRemoved: Flow<Key> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
         ) = KtorWriteKeyValueRepoClient<Key, Value>(
             baseUrl,
             httpClient,
             contentType,
-            httpClient.createStandardWebsocketFlow(
+            onNewValue,
-                buildStandardUrl(baseUrl, onNewValueRoute),
+            onValueRemoved,
-            ),
-            httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
             typeInfo<List<Key>>(),
             typeInfo<List<Value>>(),
             typeInfo<Map<Key, Value>>()

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/values/KtorKeyValuesRepoClient.kt

@@ -1,10 +1,15 @@
 package dev.inmo.micro_utils.repos.ktor.client.key.values
 
+import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.onDataClearedRoute
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.onNewValueRoute
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.onValueRemovedRoute
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.http.encodeURLQueryComponent
+import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 
 class KtorKeyValuesRepoClient<Key, Value> (
@@ -20,6 +25,15 @@ class KtorKeyValuesRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline keySerializer: suspend (Key) -> String,
+            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
+            onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onDataClearedRoute),
+            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValuesRepoClient(
             KtorReadKeyValuesRepoClient(
@@ -32,7 +46,10 @@ class KtorKeyValuesRepoClient<Key, Value> (
             KtorWriteKeyValuesRepoClient(
                 baseUrl,
                 httpClient,
-                contentType
+                contentType,
+                onNewValue,
+                onValueRemoved,
+                onDataCleared
             )
         )
         inline operator fun <reified Key : Any, reified Value : Any> invoke(
@@ -41,12 +58,24 @@ class KtorKeyValuesRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline keySerializer: suspend (Key) -> String,
+            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
+            onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onDataClearedRoute),
+            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValuesRepoClient(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
             keySerializer,
+            onNewValue,
+            onValueRemoved,
+            onDataCleared,
             valueSerializer
         )
     }
@@ -59,13 +88,25 @@ inline fun <reified Key : Any, reified Value : Any> KtorKeyValuesRepoClient(
     keySerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: StringFormat,
+    onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, onNewValueRoute),
+    ),
+    onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, onValueRemovedRoute),
+    ),
+    onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, onDataClearedRoute),
+    ),
 ) = KtorKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
     {
         serialFormat.encodeToString(keySerializer, it).encodeURLQueryComponent()
-    }
+    },
+    onNewValue,
+    onValueRemoved,
+    onDataCleared
 ) {
     serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
 }
@@ -77,13 +118,25 @@ inline fun <reified Key : Any, reified Value : Any> KtorKeyValuesRepoClient(
     keySerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: BinaryFormat,
+    onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, onNewValueRoute),
+    ),
+    onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, onValueRemovedRoute),
+    ),
+    onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
+        buildStandardUrl(baseUrl, onDataClearedRoute),
+    ),
 ) = KtorKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
     {
         serialFormat.encodeHex(keySerializer, it)
-    }
+    },
+    onNewValue,
+    onValueRemoved,
+    onDataCleared
 ) {
     serialFormat.encodeHex(valueSerializer, it)
 }

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/values/KtorWriteKeyValuesRepoClient.kt

@@ -84,20 +84,23 @@ class KtorWriteKeyValuesRepoClient<Key : Any, Value : Any>(
         inline operator fun <reified Key : Any, reified Value : Any> invoke(
             baseUrl: String,
             httpClient: HttpClient,
-            contentType: ContentType
+            contentType: ContentType,
+            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
+            onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onDataClearedRoute),
+            ),
         ) = KtorWriteKeyValuesRepoClient<Key, Value>(
             baseUrl,
             httpClient,
             contentType,
-            httpClient.createStandardWebsocketFlow(
+            onNewValue,
-                buildStandardUrl(baseUrl, onNewValueRoute),
+            onValueRemoved,
-            ),
+            onDataCleared,
-            httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
-            httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onDataClearedRoute),
-            ),
             typeInfo<Key>(),
             typeInfo<Value>(),
             typeInfo<Map<Key, List<Value>>>()

startup/launcher/src/commonMain/kotlin/Start.kt

@@ -1,10 +1,8 @@
 package dev.inmo.micro_utils.startup.launcher
 
-import dev.inmo.kslog.common.i
+import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin.setupDI
 import kotlinx.serialization.json.JsonObject
 import org.koin.core.KoinApplication
-import org.koin.core.context.startKoin
-import org.koin.dsl.module
 
 /**
  * Will create [KoinApplication], init, load modules using [StartLauncherPlugin] and start plugins using the same base
@@ -13,19 +11,7 @@ import org.koin.dsl.module
  * @param rawConfig It is expected that this [JsonObject] will contain serialized [Config] ([StartLauncherPlugin] will
  * deserialize it in its [StartLauncherPlugin.setupDI]
  */
+@Deprecated("Fully replaced with StartLauncherPlugin#start", ReplaceWith("StartLauncherPlugin.start(rawConfig)", "dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin"))
 suspend fun start(rawConfig: JsonObject) {
-    with(StartLauncherPlugin) {
+    StartLauncherPlugin.start(rawConfig)
-        logger.i("Start initialization")
-        val koinApp = KoinApplication.init()
-        koinApp.modules(
-            module {
-                setupDI(rawConfig)
-            }
-        )
-        logger.i("Modules loaded")
-        startKoin(koinApp)
-        logger.i("Koin started")
-        startPlugin(koinApp.koin)
-        logger.i("App has been setup")
-    }
 }

startup/launcher/src/commonMain/kotlin/StartLauncherPlugin.kt

@@ -4,6 +4,8 @@ import dev.inmo.kslog.common.i
 import dev.inmo.kslog.common.taggedLogger
 import dev.inmo.kslog.common.w
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin.setupDI
+import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin.startPlugin
 import dev.inmo.micro_utils.startup.plugin.StartPlugin
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -12,7 +14,11 @@ import kotlinx.coroutines.launch
 import kotlinx.serialization.SerialFormat
 import kotlinx.serialization.StringFormat
 import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.decodeFromJsonElement
+import kotlinx.serialization.json.jsonObject
 import org.koin.core.Koin
+import org.koin.core.KoinApplication
+import org.koin.core.context.startKoin
 import org.koin.core.module.Module
 import org.koin.dsl.binds
 import org.koin.dsl.module
@@ -23,26 +29,20 @@ import org.koin.dsl.module
 object StartLauncherPlugin : StartPlugin {
     internal val logger = taggedLogger(this)
 
-    /**
+    fun Module.setupDI(config: Config, rawJsonObject: JsonObject? = null) {
-     * Will deserialize [Config] from [config], register it in receiver [Module] (as well as [CoroutineScope] and
+        val rawJsonObject = rawJsonObject ?: defaultJson.encodeToJsonElement(Config.serializer(), config).jsonObject
-     * [kotlinx.serialization.json.Json])
-     *
-     * Besides, in this method will be called [StartPlugin.setupDI] on each plugin from [Config.plugins]. In case when
-     * some plugin will not be loaded correctly it will be reported throw the [logger]
-     */
-    override fun Module.setupDI(config: JsonObject) {
-        val pluginsConfig = defaultJson.decodeFromJsonElement(Config.serializer(), config)
 
-        single { pluginsConfig }
+        single { rawJsonObject }
+        single { config }
         single { CoroutineScope(Dispatchers.Default) }
         single { defaultJson } binds arrayOf(StringFormat::class, SerialFormat::class)
 
         includes(
-            pluginsConfig.plugins.mapNotNull {
+            config.plugins.mapNotNull {
                 runCatching {
                     module {
                         with(it) {
-                            setupDI(config)
+                            setupDI(rawJsonObject)
                         }
                     }
                 }.onFailure { e ->
@@ -52,11 +52,28 @@ object StartLauncherPlugin : StartPlugin {
         )
     }
 
+    /**
+     * Will deserialize [Config] from [config], register it in receiver [Module] (as well as [CoroutineScope] and
+     * [kotlinx.serialization.json.Json])
+     *
+     * Besides, in this method will be called [StartPlugin.setupDI] on each plugin from [Config.plugins]. In case when
+     * some plugin will not be loaded correctly it will be reported throw the [logger]
+     */
+    override fun Module.setupDI(config: JsonObject) {
+        logger.i("Koin for current module has started setup")
+        setupDI(
+            defaultJson.decodeFromJsonElement(Config.serializer(), config),
+            config
+        )
+        logger.i("Koin for current module has been setup")
+    }
+
     /**
      * Takes [CoroutineScope] and [Config] from the [koin], and call starting of each plugin from [Config.plugins]
      * ASYNCHRONOUSLY. Just like in [setupDI], in case of fail in some plugin it will be reported using [logger]
      */
     override suspend fun startPlugin(koin: Koin) {
+        logger.i("Start starting of subplugins")
         val scope = koin.get<CoroutineScope>()
         koin.get<Config>().plugins.map { plugin ->
             scope.launch {
@@ -66,11 +83,61 @@ object StartLauncherPlugin : StartPlugin {
                         startPlugin(koin)
                     }
                 }.onFailure { e ->
-                    logger.w("Unable to load bot part of $plugin", e)
+                    logger.w("Unable to start plugin $plugin", e)
                 }.onSuccess {
                     logger.i("Complete loading of $plugin")
                 }
             }
         }.joinAll()
+        logger.i("Complete subplugins start")
+    }
+
+    /**
+     * Will create [KoinApplication], init, load modules using [StartLauncherPlugin] and start plugins using the same base
+     * plugin. It is basic [start] method which accepts both [config] and [rawConfig] which suppose to be the same or
+     * at least [rawConfig] must contain serialized variant of [config]
+     *
+     * @param rawConfig It is expected that this [JsonObject] will contain serialized [Config] ([StartLauncherPlugin] will
+     * deserialize it in its [StartLauncherPlugin.setupDI]
+     */
+    suspend fun start(config: Config, rawConfig: JsonObject) {
+
+        logger.i("Start initialization")
+        val koinApp = KoinApplication.init()
+        koinApp.modules(
+            module {
+                setupDI(config, rawConfig)
+            }
+        )
+        logger.i("Modules loaded")
+        startKoin(koinApp)
+        logger.i("Koin started")
+        startPlugin(koinApp.koin)
+        logger.i("App has been setup")
+
+    }
+
+    /**
+     * Call [start] with deserialized [Config] as config and [rawConfig] as is
+     *
+     * @param rawConfig It is expected that this [JsonObject] will contain serialized [Config]
+     */
+    suspend fun start(rawConfig: JsonObject) {
+
+        start(defaultJson.decodeFromJsonElement(Config.serializer(), rawConfig), rawConfig)
+
+    }
+
+    /**
+     * Call [start] with deserialized [Config] as is and serialize it to [JsonObject] to pass as the first parameter
+     * to the basic [start] method
+     *
+     * @param config Will be converted to [JsonObject] as raw config. That means that all plugins from [config] will
+     * receive serialized version of [config] in [StartPlugin.setupDI] method
+     */
+    suspend fun start(config: Config) {
+
+        start(config, defaultJson.encodeToJsonElement(Config.serializer(), config).jsonObject)
+
     }
 }

startup/launcher/src/commonTest/kotlin/StartupLaunchingTests.kt

@@ -1,7 +1,7 @@
 import dev.inmo.micro_utils.startup.launcher.Config
 import dev.inmo.micro_utils.startup.launcher.HelloWorldPlugin
+import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin
 import dev.inmo.micro_utils.startup.launcher.defaultJson
-import dev.inmo.micro_utils.startup.launcher.start
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.json.jsonObject
@@ -23,7 +23,7 @@ class StartupLaunchingTests {
 
         runTest {
             val  job = launch {
-                start(emptyJson)
+                StartLauncherPlugin.start(emptyJson)
             }
             job.join()
         }
@@ -37,7 +37,7 @@ class StartupLaunchingTests {
 
         runTest {
             val  job = launch {
-                start(emptyJson)
+                StartLauncherPlugin.start(emptyJson)
             }
             job.join()
         }

startup/launcher/src/jsMain/kotlin/PluginsStarter.kt

@@ -5,6 +5,7 @@ import dev.inmo.kslog.common.i
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.jsonObject
 
+@Deprecated("Useless due to including of the same functionality in StrtLauncherPlugin")
 object PluginsStarter {
     init {
         KSLog.default = KSLog("Launcher")
@@ -15,19 +16,10 @@ object PluginsStarter {
      * app inside of [dev.inmo.micro_utils.startup.plugin.StartPluginSerializer] using its
      * [dev.inmo.micro_utils.startup.plugin.StartPluginSerializer.registerPlugin] method
      */
-    suspend fun startPlugins(json: JsonObject) {
+    suspend fun startPlugins(json: JsonObject) = StartLauncherPlugin.start(json)
-        start(json)
-    }
     /**
      * Will convert [config] to [JsonObject] with auto registration of [dev.inmo.micro_utils.startup.plugin.StartPlugin]s
      * in [dev.inmo.micro_utils.startup.plugin.StartPluginSerializer]
      */
-    suspend fun startPlugins(config: Config) {
+    suspend fun startPlugins(config: Config) = StartLauncherPlugin.start(config)
-
-        KSLog.i("Start convert config to JSON")
-        val json = defaultJson.encodeToJsonElement(Config.serializer(), config).jsonObject
-        KSLog.i("Config has been read")
-
-        start(json)
-    }
 }

startup/launcher/src/jvmMain/kotlin/Main.kt

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.startup.launcher
 
 import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.i
 import kotlinx.serialization.json.jsonObject
 import java.io.File
@@ -23,15 +24,30 @@ import java.io.File
  * In that case in `build/distributions` folder you will be able to find zip and tar files with all required
  * tools for application running (via their `bin/app_name` binary). In that case yoy will not need to pass
  * `--args=...` and launch will look like `./bin/app_name sample.config.json`
+ *
+ * ## Debug mode
+ *
+ * You may pass the second parameter, one of [LogLevel] enum variants to setup [KSLog] minimal logging level. Sample:
+ *
+ * ```bash
+ * ./gradlew run --args="sample.config.json DEBUG" // enable debugging output
+ * ```
+ *
+ * OR
+ * ```bash
+ * ./gradlew run --args="sample.config.json WARNING" // enable logging since WARNING
+ * ```
+ *
+ * **Default level is [LogLevel.INFO]**
  */
 suspend fun main(args: Array<String>) {
 
-    KSLog.default = KSLog("Launcher")
+    KSLog.default = KSLog("Launcher", args.getOrNull(1) ?.let { LogLevel.valueOf(it) } ?: LogLevel.INFO)
     val (configPath) = args
     val file = File(configPath)
     KSLog.i("Start read config from ${file.absolutePath}")
     val json = defaultJson.parseToJsonElement(file.readText()).jsonObject
     KSLog.i("Config has been read")
 
-    start(json)
+    StartLauncherPlugin.start(json)
 }

startup/template/README.md

@@ -0,0 +1,10 @@
+# How to use
+
+In case you have multiplatform project and wish to use startup plugin, this template may help you to create new modules.
+
+1. Copy-paste whole template folder (you may clone this folder to your project and actualize some data to copy your prepared template)
+2. Replace `group_name` by your project (or root module) group name
+3. Replace `module_name` by the name of your new module name
+
+You may read about the `build.gradle` structure in these templates in project
+[KotlinMultiplatformProjectTemplate](https://github.com/InsanusMokrassar/KotlinMultiplatformProjectTemplate).

startup/template/client/build.gradle

@@ -0,0 +1,18 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+    alias(libs.plugins.compose)
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":${rootProject.name}.module_name.common")
+            }
+        }
+    }
+}

startup/template/client/src/commonMain/kotlin/ClientPlugin.kt

@@ -0,0 +1,15 @@
+package group_name.module_name.client
+
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object ClientPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+    }
+}

startup/template/client/src/jsMain/kotlin/ClientJSPlugin.kt

@@ -0,0 +1,20 @@
+package group_name.module_name.client
+
+import group_name.module_name.common.CommonJSPlugin
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object ClientJSPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with(CommonJSPlugin) { setupDI(config) }
+        with(ClientPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonJSPlugin.startPlugin(koin)
+        ClientPlugin.startPlugin(koin)
+    }
+}

startup/template/client/src/jsMain/kotlin/JSModuleLoader.kt

@@ -0,0 +1,9 @@
+package group_name.module_name.client
+
+import dev.inmo.micro_utils.startup.plugin.createStartupPluginAndRegister
+
+@ExperimentalStdlibApi
+@EagerInitialization
+@JsExport
+@ExperimentalJsExport
+private val jsModuleLoader = createStartupPluginAndRegister("template.ClientJSPlugin") { ClientJSPlugin }

startup/template/client/src/jvmMain/kotlin/ClientJVMPlugin.kt

@@ -0,0 +1,21 @@
+package group_name.module_name.client
+
+import group_name.module_name.common.CommonJVMPlugin
+import group_name.module_name.common.CommonJVMPlugin.setupDI
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object ClientJVMPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with(CommonJVMPlugin) { setupDI(config) }
+        with(ClientPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonJVMPlugin.startPlugin(koin)
+        ClientPlugin.startPlugin(koin)
+    }
+}

startup/template/client/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="group_name.module_name.client"/>

startup/template/client/src/main/kotlin/ClientAndroidPlugin.kt

@@ -0,0 +1,21 @@
+package group_name.module_name.client
+
+import group_name.module_name.common.CommonAndroidPlugin
+import group_name.module_name.common.CommonAndroidPlugin.setupDI
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object ClientAndroidPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with(CommonAndroidPlugin) { setupDI(config) }
+        with(ClientPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonAndroidPlugin.startPlugin(koin)
+        ClientPlugin.startPlugin(koin)
+    }
+}

startup/template/common/build.gradle

@@ -0,0 +1,7 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"

startup/template/common/src/commonMain/kotlin/CommonPlugin.kt

@@ -0,0 +1,11 @@
+package group_name.module_name.common
+
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.module.Module
+
+object CommonPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+
+    }
+}

startup/template/common/src/commonMain/kotlin/Constants.kt

@@ -0,0 +1 @@
+package group_name.module_name.common

startup/template/common/src/jsMain/kotlin/CommonJSPlugin.kt

@@ -0,0 +1,17 @@
+package group_name.module_name.common
+
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object CommonJSPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with (CommonPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonPlugin.startPlugin(koin)
+    }
+}

startup/template/common/src/jsMain/kotlin/JSModuleLoader.kt

@@ -0,0 +1,9 @@
+package group_name.module_name.common
+
+import dev.inmo.micro_utils.startup.plugin.createStartupPluginAndRegister
+
+@ExperimentalStdlibApi
+@EagerInitialization
+@JsExport
+@ExperimentalJsExport
+private val jsModuleLoader = createStartupPluginAndRegister("template.CommonJSPlugin") { CommonJSPlugin }

startup/template/common/src/jvmMain/kotlin/CommonJVMPlugin.kt

@@ -0,0 +1,17 @@
+package group_name.module_name.common
+
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object CommonJVMPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with (CommonPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonPlugin.startPlugin(koin)
+    }
+}

startup/template/common/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="group_name.module_name.common"/>

startup/template/common/src/main/kotlin/CommonAndroidPlugin.kt

@@ -0,0 +1,17 @@
+package group_name.module_name.common
+
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object CommonAndroidPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with (CommonPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonPlugin.startPlugin(koin)
+    }
+}

startup/template/server/build.gradle

@@ -0,0 +1,16 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+}
+
+apply from: "$mppJavaProjectPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":${rootProject.name}.module_name.common")
+            }
+        }
+    }
+}

startup/template/server/src/commonMain/kotlin/ServerPlugin.kt

@@ -0,0 +1,15 @@
+package group_name.module_name.server
+
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object ServerPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+    }
+}

startup/template/server/src/jvmMain/kotlin/ServerJVMPlugin.kt

@@ -0,0 +1,20 @@
+package group_name.module_name.server
+
+import group_name.module_name.common.CommonJVMPlugin
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+object ServerJVMPlugin : StartPlugin {
+    override fun Module.setupDI(config: JsonObject) {
+        with(CommonJVMPlugin) { setupDI(config) }
+        with(ServerPlugin) { setupDI(config) }
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        CommonJVMPlugin.startPlugin(koin)
+        ServerPlugin.startPlugin(koin)
+    }
+}