Merge pull request #119 from InsanusMokrassar/10.9.0

10.9.0

.github/workflows/build.yml

@@ -8,9 +8,9 @@ jobs:
 
     steps:
       - uses: actions/checkout@v2
-      - name: Set up JDK 1.8
+      - name: Set up JDK 17
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 17
       - name: Build with Gradle
         run: ./gradlew build

.gitignore

@@ -10,5 +10,7 @@ build/
 out/
 
 local.properties
+local.*
+local.*/
 config.json
 secret.gradle

CHANGELOG.md

@@ -1,5 +1,668 @@
 # Changelog
 
+## 10.9.0
+
+* `Versions`:
+    * `kotlin`: `2.2.20`
+    * `microutils`: `0.26.6`
+    * `tgbotapi`: `30.0.0`
+    * `koin`: `4.1.1`
+
+## 10.8.0
+
+* `Versions`:
+    * `kotlin`: `2.2.10`
+    * `microutils`: `0.26.3`
+    * `tgbotapi`: `28.0.1`
+
+## 10.7.0
+
+* `Versions`:
+  * `kotlin`: `2.2.0`
+  * `serialization`: `1.9.0`
+  * `microutils`: `0.26.2`
+  * `tgbotapi`: `27.1.1`
+  * `koin`: `4.1.0`
+
+## 10.6.0
+
+* `Versions`:
+  * `microutils`: `0.25.8`
+  * `tgbotapi`: `26.0.0`
+  * `sqlite`: `3.50.1.0`
+
+## 10.5.0
+
+* `Versions`:
+  * `kotlin`: `2.1.20`
+  * `serialization`: `1.8.1`
+  * `coroutines`: `1.10.2`
+  * `microutils`: `0.25.5`
+  * `tgbotapi`: `24.0.2`
+  * `exposed`: `0.61.0`
+  * `sqlite`: `3.49.1.0`
+  * `koin`: `4.0.4`
+
+## 10.4.0
+
+* `Versions`:
+  * `microutils`: `0.24.6`
+  * `tgbotapi`: `23.2.0`
+  * `exposed`: `0.59.0`
+  * `sqlite`: `3.49.0.0`
+
+## 10.3.1
+
+* `Versions`:
+  * `kotlin`: `2.1.10`
+  * `serialization`: `1.8.0`
+  * `coroutines`: `1.10.1`
+  * `microutils`: `0.24.5`
+  * `tgbotapi`: `23.1.2`
+  * `exposed`: `0.58.0`
+  * `sqlite`: `3.48.0.0`
+  * `koin`: `4.0.2`
+
+## 10.3.0
+
+* `Versions`:
+  * `microutils`: `0.23.2`
+  * `tgbotapi`: `22.0.0`
+  * `exposed`: `0.57.0`
+
+## 10.2.1
+
+* `Versions`:
+  * `tgbotapi`: `21.0.1`
+* `Bot`:
+  * Now all `CombinedSubcontextInitialAction.SubItem`s will be taken from `Koin` to setup root `subcontextInitialAction`
+
+## 10.2.0
+
+* `Versions`:
+  * `kotlin`: `2.1.0`
+  * `microutils`: `0.23.1`
+  * `tgbotapi`: `21.0.0`
+  * `exposed`: `0.56.0`
+  * `sqlite`: `3.47.1.0`
+
+## 10.1.1
+
+* `Versions`:
+  * `tgbotapi`: `20.0.1`
+
+## 10.1.0
+
+* `Versions`:
+  * `kotlin`: `2.0.21`
+  * `serialization`: `1.7.3`
+  * `coroutines`: `1.9.0`
+  * `microutils`: `0.23.0`
+  * `tgbotapi`: `20.0.0`
+  * `exposed`: `0.55.0`
+  * `sqlite`: `3.47.0.0`
+  * `koin`: `4.0.0`
+
+## 10.0.0
+
+**OVERALL LOGIC OF PLAGUBOT INITIALIZATION AND WORK HAS BEEN CHANGED**
+
+First of all, since this update `PlaguBot` will use default `StartPlugin` logic and will be built on top of it.
+All special methods of `Plugin` will be called from one of `PlaguBot` initialization phases:
+
+* `setupBotClient` will be called from `single` initialization of `telegramBot` (in `setupDI` phase)
+* `setupBotPlugin` will be called from `startPlugin` method in time of `buildBehaviourWithFSM` initialization
+
+* `Plugin`:
+  * Extension `Module.setupDI(Database,JsonObject)` has been dropped. Use `database` extension in `Module.setupDI(JsonObject)`
+* `Bot`:
+  * `dev.inmo.plagubot.config.Config` lost its `plugins` section. Now you may retrieve plugins from `Koin` only
+  * `defaultJsonFormat` became `Warning` feature due to the fact of its fully default nature
+  * `PlaguBot` lost old `start` method and took two new: with `args` as `Array<String>` and `initialConfig` as `JsonObject`
+
+**Migration:**
+
+* If you are running bot and doing it using `StartPlugin` launcher, add `dev.inmo.plagubot.PlaguBot` explicitly
+* In plugins: replace your `setupDI` overrides with `Database` as argument by the same one, but `database` will be
+available as extension in `single` or `factory` calls (as extension to `Scope` and `Koin`)
+
+## 9.3.0
+
+* `Bot`:
+  * Now bot is not built-in into `PlaguBot` and setted up as all other `Koin` dependencies
+  * Now it is possible to use `testServer` parameter for bots out of the box
+* `Plugin`:
+  * New method `setupBotClient` with arguments to let plugin setup bot more freely
+
+## 9.2.0
+
+* `Versions`:
+  * `kotlin`: `2.0.20`
+  * `serialization`: `1.7.2`
+  * `microutils`: `0.22.2`
+  * `tgbotapi`: `18.1.0`
+  * `exposed`: `0.54.0`
+  * `sqlite`: `3.46.1.0`
+
+## 9.1.0
+
+* `Versions`:
+  * `tgbotapi`: `17.0.0`
+
+## 9.0.0
+
+* `Versions`:
+  * `Kotlin`: `2.0.10`
+  * `Serialization`: `1.7.1`
+  * `MicroUtils`: `0.22.0`
+  * `tgbotapi`: `16.0.0`
+  * `Exposed`: `0.53.0`
+
+## 8.5.1
+
+* `Versions`:
+  * `MicroUtils`: `0.21.4`
+  * `tgbotapi`: `15.2.0`
+
+## 8.5.0
+
+* `Versions`:
+  * `MicroUtils`: `0.21.2`
+  * `tgbotapi`: `15.1.0`
+
+## 8.4.0
+
+* `Versions`:
+  * `Coroutines`: `1.8.1`
+  * `MicroUtils`: `0.21.1`
+  * `tgbotapi`: `15.0.0`
+  * `Exposed`: `0.51.1`
+
+## 8.3.0
+
+* `Versions`:
+  * `Serialization`: `1.6.3`
+  * `MicroUtils`: `0.20.45`
+  * `tgbotapi`: `12.0.1`
+  * `Exposed`: `0.49.0`
+  * `SQLite`: `3.45.3.0`
+  * `Koin`: `3.5.6`
+
+## 8.2.0
+
+* `Versions`:
+  * `Coroutines`: `1.8.0`
+  * `tgbotapi`: `10.1.0`
+  * `MicroUtils`: `0.20.35`
+
+## 8.1.1
+
+* `Versions`:
+  * `tgbotapi`: `10.0.1`
+  * `MicroUtils`: `0.20.32`
+  * `Exposed`: `0.47.0`
+
+## 8.1.0
+
+* Integrate `dev.inmo:micro_utils.startup` into project
+
+## 8.0.0
+
+* `Versions`:
+  * `tgbotapi`: `10.0.0`
+  * `MicroUtils`: `0.20.26`
+  * `Exposed`: `0.46.0`
+
+## 7.4.2
+
+* `Versions`:
+  * `Kotlin`: `1.9.22`
+  * `tgbotapi`: `9.4.3`
+  * `MicroUtils`: `0.20.23`
+  * `Koin`: `3.5.7`
+
+## 7.4.1
+
+* `Versions`:
+  * `Serialization`: `1.6.2`
+  * `tgbotapi`: `9.4.2`
+  * `Exposed`: `0.45.0`
+  * `SQLite`: `3.44.1.0`
+  * `MicroUtils`: `0.20.19`
+  * `uuid`: `0.8.2`
+  * `ktor`: `2.3.7`
+
+## 7.3.0
+
+* `Versions`:
+  * `Kotlin`: `1.9.21`
+  * `Serialization`: `1.6.1`
+  * `tgbotapi`: `9.4.1`
+  * `ktor`: `2.3.6`
+  * `KSLog`: Removed explicit dependency, now it is declared in tgbotapi
+  * `MicroUtils`: `0.20.15`
+
+## 7.2.3
+
+* `Versions`:
+  * `tgbotapi`: `9.2.2`
+  * `exposed`: `0.44.0`
+  * `koin`: `3.5.0`
+  * `ktor`: `2.3.5`
+
+## 7.2.2
+
+* `Bot`:
+  * Now you may customize both `onStart` and `onUpdate` conflicts resolvers
+
+## 7.2.1
+
+* `Versions`:
+  * `tgbotapi`: `9.2.1`
+  * `ktor`: `2.3.4`
+
+## 7.2.0
+
+* `Version`:
+  * `tgbotapi`: `9.2.0`
+  * `kslog`: `1.1.2`
+  * `sqlite`: `3.43.0.0`
+
+## 7.1.0
+
+* `Version`:
+  * `microutils`: `0.19.9`
+  * `tgbotapi`: `9.1.0`
+  * `ktor`: `2.3.3`
+  * `coroutines`: `1.7.3`
+  * `koin`: `3.4.3`
+
+## 7.0.0
+
+* `Version`:
+  * `microutils`: `0.19.7`
+  * `tgbotapi`: `9.0.0`
+  * `ktor`: `2.3.2`
+  * `coroutines`: `1.7.2`
+
+## 6.1.0
+
+* `Version`:
+  * `kotlin`: `1.8.22`
+  * `microutils`: `0.19.4`
+  * `tgbotapi`: `8.1.0`
+  * `koin`: `3.4.2`
+  * `sqlite`: `3.42.0.0`
+
+## 6.0.1
+
+* `Version`:
+  * `microutils`: `0.19.2`
+  * `tgbotapi`: `8.0.1`
+  * `uuid`: `0.7.1`
+  * `ktor`: `2.3.1`
+  * `koin`: `3.4.1`
+
+## 6.0.0
+
+* `Versions`:
+  * `microutils`: `0.19.1`
+  * `tgbotapi`: `8.0.0`
+  * `klock`: `4.0.3`
+
+## 5.1.3
+
+* `Versions`:
+  * `serialization`: `1.5.1`
+  * `microutils`: `0.18.4`
+  * `tgbotapi`: `7.1.3`
+
+## 5.1.2
+
+* `Versions`:
+  * `microutils`: `0.18.1`
+  * `tgbotapi`: `7.1.2`
+
+## 5.1.1
+
+* `Versions`:
+    * `kotlin`: `1.8.21`
+    * `microutils`: `0.18.0`
+    * `tgbotapi`: `7.1.1`
+
+## 5.1.0
+
+* `Versions`:
+  * `tgbotapi`: `7.1.0`
+  * `sqlite`: `3.41.2.1`
+
+## 5.0.2
+
+* `Versions`:
+  * `kotlin`: `1.8.20`
+  * `microutils`: `0.17.8`
+  * `tgbotapi`: `7.0.2`
+  * `kslog`: `1.1.1`
+  * `ktor`: `2.3.0`
+  * `koin`: `3.4.0`
+
+## 5.0.1
+
+* `Versions`:
+  * `tgbotapi`: `7.0.1`
+
+## 5.0.0
+
+* `Versions`:
+  * `tgbotapi`: `7.0.0`
+  * `microutils`: `0.17.5`
+
+## 4.1.0
+
+* `Versions`:
+  * `tgbotapi`: `6.1.0`
+  * `microutils`: `0.17.3`
+
+## 4.0.3
+
+* `Versions`:
+  * `tgbotapi`: `6.0.3`
+  * `microutils`: `0.17.2`
+
+## 4.0.2
+
+* `Versions`:
+  * `tgbotapi`: `6.0.2`
+
+## 4.0.1
+
+* `Versions`:
+  * `tgbotapi`: `6.0.1`
+  * `microutils`: `17.0.1`
+  * `ktor`: `2.2.4`
+
+## 4.0.0
+
+* `Versions`:
+  * `kotlin`: `1.8.10`
+  * `tgbotapi`: `6.0.0`
+  * `microutils`: `0.17.0`
+
+## 3.5.0
+
+* `Versions`:
+  * `tgbotapi`: `5.2.0`
+  * `microutils`: `0.16.10`
+  * `koin`: `3.3.2`
+
+## 3.4.1
+
+* `setupBotPlugin` now works synchronously
+
+## 3.4.0
+
+* `Versions`:
+  * `tgbotapi`: `5.1.0`
+  * `microutils`: `0.16.8`
+  * `ktor`: `2.2.3`
+
+## 3.3.1
+
+* `Versions`:
+    * `tgbotapi`: `5.0.1`
+    * `microutils`: `0.16.6`
+    * `ktor`: `2.2.2`
+
+## 3.3.0
+
+* `Versions`:
+    * `tgbotapi`: `5.0.0`
+
+## 3.2.3
+
+* `Versions`:
+  * `tgbotapi`: `4.2.3`
+  * `microutils`: `0.16.4`
+
+## 3.2.2
+
+* `Versions`:
+  * `tgbotapi`: `4.2.2`
+  * `microutils`: `0.16.2`
+
+## 3.2.1
+
+* `Versions`:
+  * `tgbotapi`: `4.2.1`
+  * `microutils`: `0.16.0`
+  * `ktor`: `2.2.1`
+
+## 3.2.0
+
+* `Versions`:
+  * `kotlin`: `1.7.22`
+  * `tgbotapi`: `4.2.0`
+  * `microutils`: `0.15.0`
+  * `kslog`: `0.5.4`
+  * `sqlite`: `3.40.0.0`
+
+## 3.1.4
+
+* `Versions`:
+  * `tgbotapi`: `4.1.3`
+  * `microutils`: `0.14.4`
+
+## 3.1.3
+
+* `Versions`:
+  * `tgbotapi`: `4.1.2`
+
+## 3.1.2
+
+* `Versions`:
+  * `microutils`: `0.14.2`
+  * `exposed`: `0.41.1`
+
+## 3.1.1
+
+* `Versions`:
+  * `tgbotapi`: `4.1.1`
+
+## 3.1.0
+
+* `Versions`:
+  * `kotlin`: `1.7.21`
+  * `microutils`: `0.14.1`
+  * `tgbotapi`: `4.1.0`
+  * `klock`: `3.4.0`
+  * `uuid`: `0.6.0`
+
+## 3.0.0
+
+* `Versions`:
+  * `microutils`: `0.14.0`
+  * `tgbotapi`: `4.0.0`
+  * `kslog`: `0.5.3`
+  * `exposed`: `0.40.1`
+  * `klock`: `3.3.1`
+
+## 2.4.1
+
+* `Versions`:
+  * `microutils`: `0.13.2`
+  * `tgbotapi`: `3.3.1`
+  * `klock`: `3.3.0`
+  * `ktor`: `2.1.3`
+  * `koin`: `3.2.2`
+
+## 2.4.0
+
+* `Versions`:
+  * `kotlin`: `1.7.20`
+  * `serialization`: `1.4.1`
+  * `tgbotapi`: `3.3.0`
+  * `microutils`: `0.13.1`
+  * `klock`: `3.2.0`
+  * `ktor`: `2.1.2`
+
+## 2.3.4
+
+* `Versions`:
+  * `tgbotapi`: `3.2.7`
+  * `microutils`: `0.12.16`
+
+## 2.3.3
+
+* `Versions`:
+  * `tgbotapi`: `3.2.6`
+  * `sqlite`: `3.39.3.0`
+
+## 2.3.2
+
+* `Versions`:
+  * `tgbotapi`: `3.2.3`
+  * `microutils`: `0.12.13`
+  * `kslog`: `0.5.2`
+
+## 2.3.1
+
+* `Versions`:
+  * `klock`: `3.1.0`
+  * `tgbotapi`: `3.2.1`
+  * `microutils`: `0.12.11`
+  * `ktor`: `2.1.1`
+
+## 2.3.0
+
+* `Bot`:
+  * Add option `reconnectOptions` in database config
+
+## 2.2.0
+
+* `Versions`:
+  * `serialization`: `1.4.0`
+  * `tgbotapi`: `3.2.0`
+  * `microutils`: `0.12.4`
+  * `kslog`: `0.5.1`
+
+## 2.1.1
+
+* `Bot`:
+  * Now it is possible to get bot from `koin`
+
+## 2.1.0
+
+* `Versions`:
+  * `tgbotapi`: `3.1.1`
+  * `ktor`: `2.1.0`
+  * `microutils`: `0.12.1`
+* `Plugins`:
+  * New fum of `Plugin` with `BehaviourContextWithFSM` receiver
+* `Bot`:
+  * Now bot uses `buildBehaviourWithFSM` to be able to setup bot with FSM
+
+## 2.0.0
+
+* `Versions`:
+  * `kotlin`: `1.7.10`
+  * `serialization`: `1.4.0-RC`
+  * `tgbotapi`: `3.0.2`
+  * `kslog`: `0.5.0`
+  * `uuid`: `0.5.0`
+  * `exposed`: `0.39.2`
+  * `microutils`: `0.12.0`
+
+## 1.4.1
+
+* `Versions`:
+  * `tgbotapi`: `2.2.2`
+  * `kslog`: `0.4.2`
+
+## 1.4.0
+
+* `Versions`:
+  * `kslog`: `0.4.1`
+
+## 1.3.1
+
+* `Versions`:
+  * `tgbotapi`: `2.2.1`
+  * `microutils`: `0.11.13`
+
+## 1.3.0
+
+* `Versions`
+  * `tgbotapi`: `2.2.0`
+
+## 1.2.3
+
+* `Versions`
+  * `tgbotapi`: `2.1.3`
+
+## 1.2.2
+
+* `Versions`
+  * `tgbotapi`: `2.1.2`
+  * `microutils`: `0.11.12`
+  * `coroutines`: `1.6.3`
+  * `ktor`: `2.0.3`
+
+## 1.2.1
+
+* `Versions`
+  * `tgbotapi`: `2.1.1`
+  * `microutils`: `0.11.6`
+  * `kslog`: `0.3.2`
+
+## 1.2.0
+
+* `Versions`
+  * `tgbotapi`: `2.1.0`
+
+## 1.1.2
+
+* `Versions`
+  * `tgbotapi`: `2.0.3`
+  * `microutils`: `0.11.3`
+  * `kslog`: `0.3.1`
+* `Plugin`:
+  * Now it is possible to use `object`s of plugins instead of classes
+
+## 1.1.1
+
+* `Versions`
+  * `coroutines`: `1.6.2`
+  * `tgbotapi`: `2.0.2`
+  * `microutils`: `0.11.0`
+  * `ktor`: `2.0.2`
+  * `uuid`: `0.4.1`
+
+## 1.1.0
+
+* `Versions`
+  * `tgbotapi`: `2.0.0`
+  * `microutils`: `0.10.5`
+* `Plugin`:
+  * All plugins will be loaded in parallel
+
+## 1.0.0
+
+* `Versions`
+  * `kotlin`: `1.6.21`
+  * `coroutines`: `1.6.1`
+  * `serialization`: `1.3.3`
+  * `exposed`: `0.38.2`
+  * `tgbotapi`: `1.1.0`
+  * `microutils`: `0.10.4`
+* `Common`:
+  * ___ALL THE SDI/KLASSINDEX FUNCTIONALITY HAS BEEN REMOVED___
+* `Plugin`:
+  * Now plugins must have empty constructor
+  * Now plugins may provide realization of two methods: `setupDI` and `setupBotPlugin`
+* `PlaguBot`:
+  * `Config` now is simple serializable `data class`
+  * `PlaguBot` now is more simple as a plugin
+
 ## 0.5.1
 
 * `Versions`

README.md

@@ -16,3 +16,43 @@ You can create your bot using
 
 That is a set of libraries for plagubots. Look at the
 [PlaguBot Plugin template](https://insanusmokrassar.github.io/PlaguBotPluginTemplate/) to find how to create your bot.
+
+### Technical help
+
+#### FSM
+
+In this bot has been used variant with FSM. That means that you may use all the [Behaviour Builder with FSM](https://bookstack.inmo.dev/books/telegrambotapi/page/behaviour-builder-with-fsm) functionality. In case you wish to setup states repo, you should use the next code in the `setupDI` of your plugin:
+
+```kotlin
+single<StatesManager<State>> {
+    // setup your manager and return here
+    // Default is:
+    DefaultStatesManager(
+        InMemoryDefaultStatesManagerRepo()
+    )
+}
+```
+
+Besides, you may setup handling errors lambda in the same function:
+
+```kotlin
+single<StateHandlingErrorHandler<State>> {
+    { state, e ->
+        logger.eS(e) { "Unable to handle state $state" } // logging by default
+        null // you should return new state or null, default callback will return null
+    }
+}
+```
+
+#### Subcontext initial actions
+
+Bot will take all the `CombinedSubcontextInitialAction.SubItem`s from `Koin` to include it in root of
+`behaviourBuilder`. To create your own subitem:
+
+```kotlin
+singleWithRandomQualifier<CombinedSubcontextInitialAction.SubItem> {
+    CombinedSubcontextInitialAction.SubItem {
+        // do some action or throw error to rerun on next round
+    }
+}
+```

bot/build.gradle

@@ -1,8 +1,8 @@
 plugins {
     id 'org.jetbrains.kotlin.jvm'
     id "org.jetbrains.kotlin.plugin.serialization"
-    id "org.jetbrains.kotlin.kapt"
     id 'application'
+    id "com.google.devtools.ksp"
 }
 
 project.group="$group"
@@ -11,21 +11,20 @@ project.version="$version"
 apply from: "publish.gradle"
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
-    api "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_runtime_version"
-    api "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
-    api "org.jetbrains.exposed:exposed-jdbc:$kotlin_exposed_version"
+    implementation libs.kt.stdlib
+    api libs.kt.coroutines
+    api libs.kt.serialization
+    api libs.jb.exposed.jdbc
 
-    api "dev.inmo:tgbotapi:$tgbotapi_version"
-    api "dev.inmo:sdi:$sdi_version"
-    api "dev.inmo:micro_utils.repos.exposed:$microutils_version"
+    api libs.tgbotapi
+    api libs.tgbotapi.behaviourBuilder.fsm
+    api libs.microutils.repos.exposed
+    api libs.microutils.koin
+    api libs.microutils.startup.launcher
 
-    api "com.github.matfax.klassindex:library:$klassindex_version"
-    kapt "com.github.matfax.klassindex:processor:$klassindex_version"
-    api "org.xerial:sqlite-jdbc:$sqlite_version"
+    api libs.sqlite
 
-    testImplementation "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+    testImplementation libs.kt.test.junit
 
     api project(":plagubot.plugin")
 }
@@ -34,15 +33,11 @@ application {
     mainClassName = 'dev.inmo.plagubot.AppKt'
 }
 
-kapt {
-    arguments {
-        arg("com.github.matfax.klassindex.IndexSubclasses", "dev.inmo.plagubot.Plugin")
-        arg("com.github.matfax.klassindex.IndexAnnotated", "dev.inmo.sdi.SDIIncluded")
-    }
-}
-
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+ksp { // this generator do not require any arguments and we should left `ksp` empty
 }
 

bot/pubconf.kpsb

@@ -1 +0,0 @@
-{"bintrayConfig":{"repo":"PlaguBot","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/PlaguBot","autoPublish":true,"overridePublish":true},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/PlaguBot/LICENSE"}],"mavenConfig":{"name":"PlaguBot Bot","description":"Base PlaguBot project","url":"https://github.com/InsanusMokrassar/PlaguBot","vcsUrl":"ssh://git@github.com/InsanusMokrassar/PlaguBot.git","includeGpgSigning":true,"publishToMavenCentral":true,"developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"JVM"}

bot/publish.gradle

@@ -1,14 +1,14 @@
+
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
 
 
 task javadocJar(type: Jar) {
     from javadoc
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 task sourcesJar(type: Jar) {
     from sourceSets.main.allSource
-    classifier = 'sources'
+    archiveClassifier = 'sources'
 }
 
 publishing {
@@ -50,33 +50,69 @@ publishing {
                     
                 }
             }
-            
-                repositories {
-                    maven {
-                        name = "bintray"
-                        url = uri("https://api.bintray.com/maven/${project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')}/PlaguBot/${project.name}/;publish=1;override=1")
-                        credentials {
-                            username = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
-                            password = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
-                        }
-                    }
-                    
-                    maven {
-                        name = "sonatype"
-                        url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-                        credentials {
-                            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-                            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-                        }
-                    }
-                    
+        }
+    }
+    repositories {
+        if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
+            maven {
+                name = "InmoNexus"
+                url = uri("https://nexus.inmo.dev/repository/maven-releases/")
+        
+                credentials {
+                    username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                    password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
                 }
-            
+            }
+        }
+        if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+            maven {
+                name = "sonatype"
+                url = uri("https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/")
+        
+                credentials {
+                    username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                    password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                }
+            }
         }
     }
 }
 
-signing {
-    useGpgCmd()
-    sign publishing.publications
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+
+    signing {
+        useGpgCmd()
+
+        sign publishing.publications
+    }
+
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
+    // Workaround to make test tasks use sign
+    project.getTasks().withType(Sign.class).configureEach { signTask ->
+        def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
+        def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
+        // These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
+
+        // Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def debugTestTask = tasks.findByName("linkDebugTest$pubName")
+        if (debugTestTask != null) {
+            signTask.mustRunAfter(debugTestTask)
+        }
+        // Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def testTask = tasks.findByName("compileTestKotlin$pubName")
+        if (testTask != null) {
+            signTask.mustRunAfter(testTask)
+        }
+    }
 }

bot/publish.kpsb

@@ -0,0 +1 @@
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/PlaguBot/LICENSE"}],"mavenConfig":{"name":"PlaguBot Bot","description":"Base PlaguBot project","url":"https://github.com/InsanusMokrassar/PlaguBot","vcsUrl":"ssh://git@github.com/InsanusMokrassar/PlaguBot.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}},"type":"JVM"}

bot/src/main/kotlin/dev/inmo/plagubot/App.kt

@@ -1,18 +1,11 @@
 package dev.inmo.plagubot
 
-import dev.inmo.plagubot.config.*
-import kotlinx.coroutines.*
 import kotlinx.serialization.InternalSerializationApi
-import java.io.File
 
 /**
  * This method by default expects one argument in [args] field: path to config
  */
 @InternalSerializationApi
 suspend fun main(args: Array<String>) {
-    val (configPath) = args
-    val file = File(configPath)
-    val config = configAndPluginsConfigJsonFormat.decodeFromString(PluginsConfigurationSerializer, file.readText()) as Config
-
-    PlaguBot(config).start().join()
+    PlaguBot.start(args).join()
 }

bot/src/main/kotlin/dev/inmo/plagubot/HelloPlugin.kt

@@ -1,16 +0,0 @@
-package dev.inmo.plagubot
-
-import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import org.jetbrains.exposed.sql.Database
-
-@Serializable
-@SerialName("Hello")
-data class HelloPlugin(
-    val parameter: String
-) : Plugin {
-    override suspend fun BehaviourContext.invoke(database: Database) {
-        println(parameter)
-    }
-}

bot/src/main/kotlin/dev/inmo/plagubot/KoinExtensions.kt

@@ -0,0 +1,28 @@
+package dev.inmo.plagubot
+
+import org.koin.core.Koin
+import org.koin.core.definition.Definition
+import org.koin.core.module.Module
+import org.koin.core.qualifier.Qualifier
+import org.koin.core.qualifier.StringQualifier
+import org.koin.core.scope.Scope
+
+
+val Scope.plagubot: PlaguBot
+    get() = get()
+
+val Koin.plagubot: PlaguBot
+    get() = get()
+
+private val pluginsQualifier = StringQualifier("plagubotPlugins")
+internal fun Module.singlePlugins(
+    createdAtStart: Boolean = false,
+    definition: Definition<List<Plugin>>
+) = single(pluginsQualifier, createdAtStart, definition)
+val Scope.plugins: List<Plugin>
+    get() = get(pluginsQualifier)
+
+val Koin.plugins: List<Plugin>
+    get() = get(pluginsQualifier)
+
+

bot/src/main/kotlin/dev/inmo/plagubot/OnStartContextsConflictResolver.kt

@@ -0,0 +1,16 @@
+package dev.inmo.plagubot
+
+import dev.inmo.micro_utils.fsm.common.State
+
+fun interface OnStartContextsConflictResolver {
+    /**
+     * @param old Old state which is currently placed on the [State.context]
+     * @param new New state pretend to replace [old] one
+     * @return Should return:
+     *
+     * * Null in case when current realization unable to resolve conflict
+     * * False when current realization knows that [new] [State] must **not** replace [old] one
+     * * True when current realization knows that [new] [State] must replace [old] one
+     */
+    suspend operator fun invoke(old: State, new: State): Boolean?
+}

bot/src/main/kotlin/dev/inmo/plagubot/OnUpdateContextsConflictResolver.kt

@@ -0,0 +1,20 @@
+package dev.inmo.plagubot
+
+import dev.inmo.micro_utils.fsm.common.State
+
+fun interface OnUpdateContextsConflictResolver {
+    /**
+     * This method will be called when [sourceStateWithOldContext] [State.context] and [newStateWithNewContext] are not equal and currently there is
+     * launched [currentStateOnNewContext] state on the chain with [State.context] from [currentStateOnNewContext]
+     *
+     * @param sourceStateWithOldContext Old state where from [newStateWithNewContext] came
+     * @param newStateWithNewContext New state with changing [State.context] (it is different with [sourceStateWithOldContext] [State.context])
+     * @param currentStateOnNewContext State which is currently running on [newStateWithNewContext] [State.context]
+     * @return Should return:
+     *
+     * * Null in case when current realization unable to resolve conflict
+     * * False when [currentStateOnNewContext] **should not** be stopped in favor to [newStateWithNewContext]
+     * * True when [currentStateOnNewContext] **should** be stopped in favor to [newStateWithNewContext]
+     */
+    suspend operator fun invoke(sourceStateWithOldContext: State, newStateWithNewContext: State, currentStateOnNewContext: State): Boolean?
+}

bot/src/main/kotlin/dev/inmo/plagubot/PlaguBot.kt

@@ -1,55 +1,167 @@
 package dev.inmo.plagubot
 
-import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
+import dev.inmo.kslog.common.*
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.fsm.common.State
+import dev.inmo.micro_utils.fsm.common.StatesManager
+import dev.inmo.micro_utils.fsm.common.managers.*
+import dev.inmo.micro_utils.koin.getAllDistinct
+import dev.inmo.micro_utils.pagination.utils.getAll
+import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin
 import dev.inmo.plagubot.config.*
-import dev.inmo.tgbotapi.bot.Ktor.telegramBot
-import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.bot.ktor.KtorRequestsExecutorBuilder
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.webhook.deleteWebhook
 import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.types.botCommandsLimit
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.startGettingOfUpdatesByLongPolling
 import kotlinx.coroutines.*
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.Transient
-import org.jetbrains.exposed.sql.Database
-
-const val DefaultPlaguBotParamsKey = "plagubot"
-val Map<String, Any>.plagubot
-    get() = get(DefaultPlaguBotParamsKey) as? PlaguBot
+import kotlinx.serialization.json.*
+import org.koin.core.Koin
+import org.koin.core.module.Module
+import org.koin.core.scope.Scope
+import java.io.File
 
+@OptIn(Warning::class)
 @Serializable
-data class PlaguBot(
-    @Serializable(PluginsConfigurationSerializer::class)
-    private val config: Config
-) : Plugin {
-    @Transient
-    private val bot = telegramBot(config.botToken)
-    @Transient
-    private val paramsMap = config.params ?.toMap() ?: emptyMap()
-    @Transient
-    private val database = config.params ?.database ?: config.database.database
-
-    override suspend fun getCommands(): List<BotCommand> = config.plugins.flatMap {
-        it.getCommands()
+object PlaguBot : Plugin {
+    override fun KtorRequestsExecutorBuilder.setupBotClient(scope: Scope, params: JsonObject) {
+        scope.plugins.filter { it !== this@PlaguBot }.forEach {
+            with(it) {
+                setupBotClient(scope, params)
+            }
+        }
     }
 
-    override suspend fun BehaviourContext.invoke(database: Database, params: Map<String, Any>) {
-        config.plugins.forEach {
-            it.apply { invoke(database, params) }
+    override fun Module.setupDI(config: JsonObject) {
+        single { get<Json>().decodeFromJsonElement(Config.serializer(), config) }
+        single { config }
+        single { get<Config>().databaseConfig }
+        single { get<Config>().databaseConfig.database }
+        single { this@PlaguBot }
+        singlePlugins { get<dev.inmo.micro_utils.startup.launcher.Config>().plugins.filterIsInstance<Plugin>() }
+        single {
+            val config = get<Config>()
+            telegramBot(
+                token = config.botToken,
+                testServer = config.testServer,
+                apiUrl = config.botApiServer
+            ) {
+                setupBotClient(this@single, get<JsonObject>())
+            }
         }
-        val commands = getCommands()
-        val futureUnavailable = commands.drop(botCommandsLimit.last)
-        if (futureUnavailable.isNotEmpty()) {
-            println("Next commands are out of range in setting command request and will be unavailable from autocompleting: $futureUnavailable")
-        }
-        safelyWithoutExceptions { setMyCommands(commands.take(botCommandsLimit.last)) }
     }
 
     /**
-     * This method will create an [Job] which will be the main [Job] of ran instance
+     * Getting all [OnStartContextsConflictResolver], [OnUpdateContextsConflictResolver], [StatesManager] and [DefaultStatesManagerRepo]
+     * and pass them into [buildBehaviourWithFSM] on top of [TelegramBot] took from [koin]. In time of
+     * [buildBehaviourWithFSM] configuration will call [setupBotPlugin] and [deleteWebhook].
+     *
+     * After all preparation, the result of [buildBehaviourWithFSM] will be passed to [startGettingOfUpdatesByLongPolling]
+     * as [CoroutineScope] and [UpdatesFilter].
+     *
+     * The [Job] took from [startGettingOfUpdatesByLongPolling] will be used to prevent app stopping by calling [Job.join]
+     * on it
      */
-    suspend fun start(
-        scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-    ): Job = bot.buildBehaviourWithLongPolling(scope) {
-        invoke(database, paramsMap)
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        val scope = koin.get<CoroutineScope>()
+
+        lateinit var behaviourContext: BehaviourContext
+        val onStartContextsConflictResolver by lazy { koin.getAllDistinct<OnStartContextsConflictResolver>() }
+        val onUpdateContextsConflictResolver by lazy { koin.getAllDistinct<OnUpdateContextsConflictResolver>() }
+        val bot = koin.get<TelegramBot>()
+        bot.buildBehaviourWithFSM(
+            scope = scope,
+            defaultExceptionsHandler = {
+                logger.e("Something went wrong", it)
+            },
+            statesManager = koin.getOrNull<StatesManager<State>>() ?: DefaultStatesManager(
+                koin.getOrNull<DefaultStatesManagerRepo<State>>() ?: InMemoryDefaultStatesManagerRepo<State>(),
+                onStartContextsConflictResolver = { old, new -> onStartContextsConflictResolver.firstNotNullOfOrNull { it(old, new) } ?: false },
+                onUpdateContextsConflictResolver = { old, new, currentNew -> onUpdateContextsConflictResolver.firstNotNullOfOrNull { it(old, new, currentNew) } ?: false }
+            ),
+            onStateHandlingErrorHandler = koin.getOrNull<StateHandlingErrorHandler<State>>() ?: { state, e ->
+                logger.eS(e) { "Unable to handle state $state" }
+                null
+            },
+            subcontextInitialAction = CombinedSubcontextInitialAction(koin.getAllDistinct()).subcontextInitialAction
+        ) {
+            logger.i("Start setup of bot part")
+            behaviourContext = this
+            setupBotPlugin(koin)
+            deleteWebhook()
+        }.start()
+        logger.i("Behaviour builder has been setup")
+
+        bot.startGettingOfUpdatesByLongPolling(scope = behaviourContext, updatesFilter = behaviourContext).also {
+            logger.i("Long polling has been started")
+        }.join()
+    }
+
+    /**
+     * Initializing [Plugin]s from [koin] took by [plugins] extension. [PlaguBot] itself will be filtered out from
+     * list of plugins to be inited
+     */
+    override suspend fun BehaviourContextWithFSM<State>.setupBotPlugin(koin: Koin) {
+        koin.plugins.filter { it !== this@PlaguBot }.forEach { plugin ->
+            runCatchingSafely {
+                logger.i("Start loading of $plugin")
+                with(plugin) {
+                    setupBotPlugin(koin)
+                }
+            }.onFailure { e ->
+                logger.w("Unable to load bot part of $plugin", e)
+            }.onSuccess {
+                logger.i("Complete loading of $plugin")
+            }
+        }
+    }
+
+    /**
+     * Starting plugins system using [StartLauncherPlugin.start]. In time of parsing [initialJson] [PlaguBot] may
+     * add itself in its `plugins` section in case of its absence there. So, by launching this [start] it is guaranteed
+     * that [PlaguBot] will be in list of plugins to be loaded by [StartLauncherPlugin]
+     */
+    suspend fun start(initialJson: JsonObject): Job {
+        val initialConfig = defaultJsonFormat.decodeFromJsonElement(dev.inmo.micro_utils.startup.launcher.Config.serializer(), initialJson)
+
+        KSLog.i("Config has been read")
+
+        // Adding of PlaguBot when it absent in config
+        val (resultJson, resultConfig) = if (PlaguBot in initialConfig.plugins) {
+            KSLog.i("Initial config contains PlaguBot, pass config as is to StartLauncherPlugin")
+            initialJson to initialConfig
+        } else {
+            KSLog.i("Start fixing of PlaguBot absence. If PlaguBot has been skipped by some reason, use dev.inmo.micro_utils.startup.launcher.main as startup point or StartLauncherPlugin directly")
+            val resultJson = JsonObject(
+                initialJson + Pair("plugins", JsonArray(initialJson["plugins"]!!.jsonArray + JsonPrimitive(PlaguBot::class.qualifiedName!!)))
+            )
+            val resultConfig = defaultJsonFormat.decodeFromJsonElement(dev.inmo.micro_utils.startup.launcher.Config.serializer(), resultJson)
+            resultJson to resultConfig
+        }
+
+        KSLog.i("Config initialization done. Passing config to StartLauncherPlugin")
+        return StartLauncherPlugin.start(
+            resultConfig,
+            resultJson
+        ).koin.get<CoroutineScope>().coroutineContext.job
+    }
+
+    /**
+     * Accepts single argument in [args] which will be interpreted as [File] path with [StartLauncherPlugin]
+     * configuration content. After reading of that file as [JsonObject] will pass it in [start] with [JsonObject] as
+     * argument
+     */
+    suspend fun start(args: Array<String>): Job {
+        KSLog.default = KSLog("PlaguBot")
+        val (configPath) = args
+        val file = File(configPath)
+        KSLog.i("Start read config from ${file.absolutePath}")
+
+        val initialJson = defaultJsonFormat.parseToJsonElement(file.readText()).jsonObject
+        return start(initialJson)
     }
 }

bot/src/main/kotlin/dev/inmo/plagubot/PluginsHolder.kt

@@ -1,25 +0,0 @@
-package dev.inmo.plagubot
-
-import dev.inmo.plagubot.config.PluginsConfigurationSerializer
-import dev.inmo.plagubot.config.SimplePluginsConfiguration
-import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
-import dev.inmo.tgbotapi.types.BotCommand
-import kotlinx.serialization.Serializable
-import org.jetbrains.exposed.sql.Database
-
-@Serializable
-data class PluginsHolder(
-    @Serializable(PluginsConfigurationSerializer::class)
-    private val pluginsConfiguration: SimplePluginsConfiguration
-) : Plugin {
-    override suspend fun getCommands(): List<BotCommand> = pluginsConfiguration.plugins.flatMap {
-        it.getCommands()
-    }
-
-    override suspend fun BehaviourContext.invoke(database: Database, params: Map<String, Any>) {
-        val finalParams = pluginsConfiguration.params ?.plus(params) ?: params
-        pluginsConfiguration.plugins.forEach {
-            it.apply { invoke(database, finalParams) }
-        }
-    }
-}

bot/src/main/kotlin/dev/inmo/plagubot/config/Config.kt

@@ -1,15 +1,18 @@
 package dev.inmo.plagubot.config
 
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
 import dev.inmo.plagubot.Plugin
-import dev.inmo.sdi.Module
-import kotlinx.serialization.Contextual
+import dev.inmo.tgbotapi.utils.telegramBotAPIDefaultUrl
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
+@Warning("This API is internal and can be changed without notifications or mentions of changes")
 @Serializable
 data class Config(
-    override val plugins: List<@Contextual Plugin>,
-    val database: DatabaseConfig = DatabaseConfig(),
     val botToken: String,
-    @Contextual
-    override val params: Module? = null
-) : PluginsConfiguration
+    @SerialName("database")
+    val databaseConfig: DatabaseConfig = DatabaseConfig(),
+    val botApiServer: String = telegramBotAPIDefaultUrl,
+    val testServer: Boolean = false
+)

bot/src/main/kotlin/dev/inmo/plagubot/config/DBConnectOptions.kt

@@ -0,0 +1,9 @@
+package dev.inmo.plagubot.config
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class DBConnectOptions(
+    val attempts: Int = 3,
+    val delay: Long = 1000L
+)

bot/src/main/kotlin/dev/inmo/plagubot/config/DatabaseConfig.kt

@@ -1,32 +1,43 @@
 package dev.inmo.plagubot.config
 
-import dev.inmo.sdi.SDIIncluded
+import dev.inmo.kslog.common.e
+import dev.inmo.kslog.common.logger
+import kotlinx.coroutines.delay
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.transactions.transactionManager
+import org.koin.core.scope.Scope
 import org.sqlite.JDBC
+import java.lang.Exception
 import java.sql.Connection
 
-const val defaultDatabaseParamsName = "defaultDatabase"
-inline val Map<String, Any>.database: Database?
-    get() = (get(defaultDatabaseParamsName) as? DatabaseConfig) ?.database
+inline val Scope.database: Database?
+    get() = getOrNull<Database>()
 
 @Serializable
-@SDIIncluded
 data class DatabaseConfig(
     val url: String = "jdbc:sqlite:file:test?mode=memory&cache=shared",
     val driver: String = JDBC::class.qualifiedName!!,
     val username: String = "",
-    val password: String = ""
+    val password: String = "",
+    val reconnectOptions: DBConnectOptions? = DBConnectOptions()
 ) {
     @Transient
-    val database: Database = Database.connect(
-        url,
-        driver,
-        username,
-        password
-    ).also {
-        it.transactionManager.defaultIsolationLevel = Connection.TRANSACTION_SERIALIZABLE // Or Connection.TRANSACTION_READ_UNCOMMITTED
-    }
+    val database: Database = (0 until (reconnectOptions ?.attempts ?: 1)).firstNotNullOfOrNull {
+        runCatching {
+            Database.connect(
+                url,
+                driver,
+                username,
+                password
+            ).also {
+                it.transactionManager.defaultIsolationLevel = Connection.TRANSACTION_SERIALIZABLE // Or Connection.TRANSACTION_READ_UNCOMMITTED
+                it.connector().close()
+            }
+        }.onFailure {
+            logger.e(it)
+            Thread.sleep(reconnectOptions ?.delay ?: return@onFailure)
+        }.getOrNull()
+    } ?: error("Unable to create database")
 }

bot/src/main/kotlin/dev/inmo/plagubot/config/JsonFormat.kt

@@ -0,0 +1,9 @@
+package dev.inmo.plagubot.config
+
+import dev.inmo.micro_utils.common.Warning
+import kotlinx.serialization.json.Json
+
+@Warning("This format will not be configured throw StartPlugin system. Use it will caution, it has no any configured things")
+val defaultJsonFormat = Json {
+    ignoreUnknownKeys = true
+}

bot/src/main/kotlin/dev/inmo/plagubot/config/PluginsConfiguration.kt

@@ -1,190 +0,0 @@
-package dev.inmo.plagubot.config
-
-import com.github.matfax.klassindex.KlassIndex
-import dev.inmo.plagubot.Plugin
-import dev.inmo.plagubot.PluginSerializer
-import dev.inmo.sdi.Module
-import dev.inmo.sdi.ModuleSerializer
-import kotlinx.serialization.*
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.*
-import kotlinx.serialization.modules.*
-import kotlin.reflect.KClass
-
-@InternalSerializationApi
-internal inline fun <T : Plugin> KClass<T>.includeIn(builder: PolymorphicModuleBuilder<Plugin>) = builder.subclass(this, serializer())
-
-@InternalSerializationApi
-internal val configAndPluginsConfigJsonFormat: Json
-    get() = Json {
-        ignoreUnknownKeys = true
-        serializersModule = SerializersModule {
-            polymorphic(Plugin::class) {
-                KlassIndex.getSubclasses(Plugin::class).flatMap { kclass ->
-                    kclass.includeIn(this)
-                    kclass.annotations.mapNotNull { it as? SerialName }.map {
-                        it.value to kclass.serializer()
-                    } + listOfNotNull(
-                        kclass.simpleName ?.let {
-                            it to kclass.serializer()
-                        }
-                    )
-                }.toMap().let {
-                    default { requiredType ->
-                        it[requiredType]
-                    }
-                }
-            }
-        }
-    }
-
-internal interface PluginsConfiguration {
-    val plugins: List<Plugin>
-    val params: Module?
-}
-
-@Serializable
-data class SimplePluginsConfiguration(
-    override val plugins: List<@Contextual Plugin>,
-    @Contextual
-    override val params: Module? = null
-) : PluginsConfiguration
-
-
-internal val DefaultModuleSerializer = ModuleSerializer(emptyList()) {
-
-}
-
-@Serializer(Plugin::class)
-internal class InternalPluginSerializer(
-    private val params: Module
-) : KSerializer<Plugin> {
-    override val descriptor: SerialDescriptor = PluginSerializer.descriptor
-
-    @OptIn(InternalSerializationApi::class)
-    override fun deserialize(decoder: Decoder): Plugin {
-        val asJson = JsonElement.serializer().deserialize(decoder)
-
-        return if (asJson is JsonPrimitive) {
-            params[asJson.jsonPrimitive.content] as Plugin
-        } else {
-            val jsonFormat = ((decoder as? JsonDecoder)?.json ?: configAndPluginsConfigJsonFormat)
-            jsonFormat.decodeFromJsonElement(PluginSerializer, asJson)
-        }
-    }
-
-    @OptIn(InternalSerializationApi::class)
-    override fun serialize(encoder: Encoder, value: Plugin) {
-        params.keys.firstOrNull { params[it] === value } ?.also {
-            encoder.encodeString(it)
-        } ?: PluginSerializer.serialize(encoder, value)
-    }
-}
-
-@Serializer(Module::class)
-internal class InternalModuleSerializer(
-    private val original: JsonElement?,
-    private val params: Module
-) : KSerializer<Module> {
-    override val descriptor: SerialDescriptor = PluginSerializer.descriptor
-
-    @OptIn(InternalSerializationApi::class)
-    override fun deserialize(decoder: Decoder): Module {
-        val asJson = JsonElement.serializer().deserialize(decoder)
-
-        return if (asJson == original) {
-            params
-        } else {
-            configAndPluginsConfigJsonFormat.decodeFromJsonElement(DefaultModuleSerializer, asJson)
-        }
-    }
-
-    @OptIn(InternalSerializationApi::class)
-    override fun serialize(encoder: Encoder, value: Module) = DefaultModuleSerializer.serialize(encoder, value)
-}
-
-internal fun internalPluginSerializerSerializersModule(
-    internalPluginSerializer: InternalPluginSerializer,
-    internalModuleSerializer: InternalModuleSerializer?
-) = SerializersModule {
-    contextual(internalPluginSerializer)
-    contextual(internalModuleSerializer ?: return@SerializersModule)
-}
-
-@Serializer(PluginsConfiguration::class)
-internal object PluginsConfigurationSerializer : KSerializer<PluginsConfiguration> {
-    private val jsonSerializer = JsonObject.serializer()
-    private val moduleSerializer = ModuleSerializer()
-    override val descriptor: SerialDescriptor = jsonSerializer.descriptor
-
-    @OptIn(InternalSerializationApi::class)
-    override fun deserialize(decoder: Decoder): PluginsConfiguration {
-        val json = jsonSerializer.deserialize(decoder)
-        val jsonFormat = (decoder as? JsonDecoder) ?.json ?: configAndPluginsConfigJsonFormat
-        val paramsRow = json["params"]
-
-        val resultJsonFormat = if (paramsRow != null && paramsRow != JsonNull) {
-            val params = jsonFormat.decodeFromJsonElement(
-                moduleSerializer,
-                paramsRow
-            )
-
-            val pluginsSerializer = InternalPluginSerializer(params)
-            val moduleSerializer = InternalModuleSerializer(paramsRow, params)
-            Json(jsonFormat) {
-                serializersModule = decoder.serializersModule.overwriteWith(
-                    internalPluginSerializerSerializersModule(pluginsSerializer, moduleSerializer)
-                )
-            }
-        } else {
-            jsonFormat
-        }
-        return try {
-            resultJsonFormat.decodeFromJsonElement(
-                Config.serializer(),
-                json
-            )
-        } catch (e: SerializationException) {
-            resultJsonFormat.decodeFromJsonElement(
-                SimplePluginsConfiguration.serializer(),
-                json
-            )
-        }
-    }
-
-    @OptIn(InternalSerializationApi::class)
-    override fun serialize(encoder: Encoder, value: PluginsConfiguration) {
-        val params = value.params
-        val serializer = when (value) {
-            is Config -> Config.serializer()
-            is SimplePluginsConfiguration -> SimplePluginsConfiguration.serializer()
-            else -> return
-        }
-        if (params != null) {
-            val pluginsSerializer = InternalPluginSerializer(params)
-
-            val jsonFormat = Json(configAndPluginsConfigJsonFormat) {
-                serializersModule = encoder.serializersModule.overwriteWith(
-                    internalPluginSerializerSerializersModule(pluginsSerializer, null)
-                )
-            }
-
-            jsonSerializer.serialize(
-                encoder,
-                when (value) {
-                    is Config -> jsonFormat.encodeToJsonElement(Config.serializer(), value)
-                    is SimplePluginsConfiguration -> jsonFormat.encodeToJsonElement(SimplePluginsConfiguration.serializer(), value)
-                    else -> return
-                } as JsonObject
-            )
-        } else {
-            when (value) {
-                is Config -> Config.serializer().serialize(encoder, value)
-                is SimplePluginsConfiguration -> SimplePluginsConfiguration.serializer().serialize(encoder, value)
-                else -> return
-            }
-        }
-    }
-}

bot/src/main/kotlin/dev/inmo/plagubot/config/StateHandlingErrorHandler.kt

@@ -0,0 +1,3 @@
+package dev.inmo.plagubot.config
+
+typealias StateHandlingErrorHandler<T> = suspend (T, Throwable) -> T?

bot/src/test/kotlin/dev/inmo/plagubot/config/ConfigTest.kt

@@ -1,40 +0,0 @@
-package dev.inmo.plagubot.config
-
-import dev.inmo.plagubot.HelloPlugin
-import kotlinx.serialization.InternalSerializationApi
-import org.junit.Test
-import kotlin.test.assertEquals
-
-class ConfigTest {
-    @InternalSerializationApi
-    @Test
-    fun testThatPluginPassedToParamsWillBeCorrectlyUsedInPlugins() {
-        val rawConfig = """
-            {
-              "database": {
-              },
-              "botToken": "",
-              "plugins": [
-                "helloPlugin"
-              ],
-              "params": {
-                "helloPlugin": {"type": "dev.inmo.plagubot.HelloPlugin", "parameter": "Example"}
-              }
-            }
-        """.trimIndent()
-        val config = configAndPluginsConfigJsonFormat.decodeFromString(PluginsConfigurationSerializer, rawConfig) as Config
-
-        assert(config.plugins.size == 1)
-        assert(config.plugins.first() is HelloPlugin)
-        assert((config.plugins.first() as HelloPlugin).parameter == "Example")
-
-        val redecoded = configAndPluginsConfigJsonFormat.decodeFromString(
-            PluginsConfigurationSerializer,
-            configAndPluginsConfigJsonFormat.encodeToString(PluginsConfigurationSerializer, config)
-        ) as Config
-        assertEquals(config.database, redecoded.database)
-        assertEquals(config.plugins, redecoded.plugins)
-        assertEquals(config.botToken, redecoded.botToken)
-        assertEquals(config.params ?.toMap(), redecoded.params ?.toMap())
-    }
-}

build.gradle

@@ -1,22 +1,41 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
         maven { url "https://plugins.gradle.org/m2/" }
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
+        classpath libs.buildscript.kt.gradle
+        classpath libs.buildscript.kt.serialization
+        classpath libs.buildscript.gh.release
+        classpath libs.buildscript.ksp
+    }
+}
+
+plugins {
+    alias(libs.plugins.nmcp.aggregation)
+}
+
+
+if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+    nmcpAggregation {
+        centralPortal {
+            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+            validationTimeout = Duration.ofHours(4)
+            publishingType = System.getenv('PUBLISHING_TYPE') != "" ? System.getenv('PUBLISHING_TYPE') : "USER_MANAGED"
+        }
+
+        publishAllProjectsProbablyBreakingProjectIsolation()
     }
 }
 
 allprojects {
     repositories {
         mavenCentral()
-        jcenter()
         mavenLocal()
         maven { url 'https://jitpack.io' }
+        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
     }
 }
 

github_release.gradle

@@ -11,22 +11,29 @@ private String getCurrentVersionChangelog() {
     return changelogDataOS.toString().trim()
 }
 
-if (new File(projectDir, "secret.gradle").exists()) {
-    apply from: './secret.gradle'
+def githubTokenVariableName = "GITHUB_RELEASE_TOKEN"
+def githubTokenVariableFromEnv = System.getenv(githubTokenVariableName)
+
+def secretFile = new File(projectDir, "secret.gradle")
+if (secretFile.exists() || project.hasProperty(githubTokenVariableName) || (githubTokenVariableFromEnv != "" && githubTokenVariableFromEnv != null)) {
+    if (secretFile.exists()) {
+        apply from: './secret.gradle'
+    }
     apply plugin: "com.github.breadmoirai.github-release"
+    def githubReleaseToken = project.hasProperty(githubTokenVariableName) ? project.property(githubTokenVariableName).toString() : githubTokenVariableFromEnv
 
     githubRelease {
-        token "${project.property('GITHUB_RELEASE_TOKEN')}"
+        token githubReleaseToken
 
         releaseAssets.from('bot/build/distributions')
 
-        owner "InsanusMokrassar"
-        repo "PlaguBot"
+        owner = "InsanusMokrassar"
+        repo = "PlaguBot"
 
-        tagName "${project.version}"
-        releaseName "${project.version}"
-        targetCommitish "${project.version}"
+        tagName = "v${project.version}"
+        releaseName = "${project.version}"
+        targetCommitish = "${project.version}"
 
-        body getCurrentVersionChangelog()
+        body = getCurrentVersionChangelog()
     }
 }

gradle.properties

@@ -4,19 +4,5 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 
-kotlin_version=1.6.10
-kotlin_coroutines_version=1.6.0
-kotlin_serialisation_runtime_version=1.3.2
-kotlin_exposed_version=0.37.2
-
-sdi_version=0.6.0
-tgbotapi_version=0.38.4
-microutils_version=0.9.5
-klassindex_version=4.1.0-rc.1
-
-sqlite_version=3.36.0.3
-
-github_release_plugin_version=2.2.12
-
 group=dev.inmo
-version=0.5.1
+version=10.9.0

gradle/libs.versions.toml

@@ -0,0 +1,56 @@
+[versions]
+
+kt = "2.2.20"
+kt-serialization = "1.9.0"
+kt-coroutines = "1.10.2"
+
+microutils = "0.26.6"
+tgbotapi = "30.0.0"
+
+ksp = "2.2.20-2.0.4"
+
+jb-exposed = "0.61.0"
+jb-dokka = "2.1.0"
+
+sqlite = "3.50.1.0"
+
+gh-release = "2.5.2"
+
+koin = "4.1.1"
+
+nmcp = "1.2.0"
+
+[libraries]
+
+kt-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kt" }
+
+kt-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kt-coroutines" }
+kt-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kt-serialization" }
+
+tgbotapi = { module = "dev.inmo:tgbotapi", version.ref = "tgbotapi" }
+tgbotapi-behaviourBuilder-fsm = { module = "dev.inmo:tgbotapi.behaviour_builder.fsm", version.ref = "tgbotapi" }
+microutils-repos-exposed = { module = "dev.inmo:micro_utils.repos.exposed", version.ref = "microutils" }
+microutils-koin = { module = "dev.inmo:micro_utils.koin", version.ref = "microutils" }
+microutils-koin-generator = { module = "dev.inmo:micro_utils.koin.generator", version.ref = "microutils" }
+microutils-startup-launcher = { module = "dev.inmo:micro_utils.startup.launcher", version.ref = "microutils" }
+microutils-startup-plugin = { module = "dev.inmo:micro_utils.startup.plugin", version.ref = "microutils" }
+
+koin = { module = "io.insert-koin:koin-core", version.ref = "koin" }
+
+jb-exposed-jdbc = { module = "org.jetbrains.exposed:exposed-jdbc", version.ref = "jb-exposed" }
+
+sqlite = { module = "org.xerial:sqlite-jdbc", version.ref = "sqlite" }
+
+
+kt-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kt" }
+
+
+buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }
+buildscript-kt-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kt" }
+buildscript-jb-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "jb-dokka" }
+buildscript-gh-release = { module = "com.github.breadmoirai:github-release", version.ref = "gh-release" }
+buildscript-ksp = { module = "com.google.devtools.ksp:symbol-processing-gradle-plugin", version.ref = "ksp" }
+
+[plugins]
+
+nmcp-aggregation = { id = "com.gradleup.nmcp.aggregation", version.ref = "nmcp" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

plugin/build.gradle

@@ -9,14 +9,17 @@ project.version="$version"
 apply from: "publish.gradle"
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    api "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_runtime_version"
+    implementation libs.kt.stdlib
+    api libs.kt.serialization
 
-    api "dev.inmo:tgbotapi:$tgbotapi_version"
-    api "dev.inmo:micro_utils.repos.exposed:$microutils_version"
+    api libs.tgbotapi
+    api libs.microutils.repos.exposed
+    api libs.microutils.startup.plugin
+
+    api libs.koin
 }
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

plugin/pubconf.kpsb

@@ -1 +0,0 @@
-{"bintrayConfig":{"repo":"PlaguBot","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/PlaguBot","autoPublish":true,"overridePublish":true},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/PlaguBot/LICENSE"}],"mavenConfig":{"name":"PlaguBot Plugin","description":"Base dependency for whole PlaguBot project","url":"https://github.com/InsanusMokrassar/PlaguBot","vcsUrl":"ssh://git@github.com/InsanusMokrassar/PlaguBot.git","includeGpgSigning":true,"publishToMavenCentral":true,"developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"JVM"}

plugin/publish.gradle

@@ -1,14 +1,14 @@
+
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
 
 
 task javadocJar(type: Jar) {
     from javadoc
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 task sourcesJar(type: Jar) {
     from sourceSets.main.allSource
-    classifier = 'sources'
+    archiveClassifier = 'sources'
 }
 
 publishing {
@@ -50,33 +50,69 @@ publishing {
                     
                 }
             }
-            
-                repositories {
-                    maven {
-                        name = "bintray"
-                        url = uri("https://api.bintray.com/maven/${project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')}/PlaguBot/${project.name}/;publish=1;override=1")
-                        credentials {
-                            username = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
-                            password = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
-                        }
-                    }
-                    
-                    maven {
-                        name = "sonatype"
-                        url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-                        credentials {
-                            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-                            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-                        }
-                    }
-                    
+        }
+    }
+    repositories {
+        if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
+            maven {
+                name = "InmoNexus"
+                url = uri("https://nexus.inmo.dev/repository/maven-releases/")
+        
+                credentials {
+                    username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                    password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
                 }
-            
+            }
+        }
+        if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+            maven {
+                name = "sonatype"
+                url = uri("https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/")
+        
+                credentials {
+                    username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                    password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                }
+            }
         }
     }
 }
 
-signing {
-    useGpgCmd()
-    sign publishing.publications
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+
+    signing {
+        useGpgCmd()
+
+        sign publishing.publications
+    }
+
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
+    // Workaround to make test tasks use sign
+    project.getTasks().withType(Sign.class).configureEach { signTask ->
+        def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
+        def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
+        // These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
+
+        // Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def debugTestTask = tasks.findByName("linkDebugTest$pubName")
+        if (debugTestTask != null) {
+            signTask.mustRunAfter(debugTestTask)
+        }
+        // Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def testTask = tasks.findByName("compileTestKotlin$pubName")
+        if (testTask != null) {
+            signTask.mustRunAfter(testTask)
+        }
+    }
 }

plugin/publish.kpsb

@@ -0,0 +1 @@
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/PlaguBot/LICENSE"}],"mavenConfig":{"name":"PlaguBot Plugin","description":"Base dependency for whole PlaguBot project","url":"https://github.com/InsanusMokrassar/PlaguBot","vcsUrl":"ssh://git@github.com/InsanusMokrassar/PlaguBot.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}},"type":"JVM"}

plugin/src/main/kotlin/dev/inmo/plagubot/HelloPlugin.kt

@@ -0,0 +1,62 @@
+package dev.inmo.plagubot
+
+import dev.inmo.kslog.common.*
+import dev.inmo.micro_utils.fsm.common.State
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.sendMessage
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitTextMessage
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import kotlinx.coroutines.flow.first
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.module.Module
+
+@Serializable
+@SerialName("Hello")
+object HelloPlugin : Plugin {
+    @Serializable
+    data class HelloPluginConfig(
+        val print: String
+    )
+
+    override fun Module.setupDI(config: JsonObject) {
+        registerConfig<HelloPluginConfig>("helloPlugin") { null }
+    }
+
+    private sealed interface InternalFSMState : State {
+        override val context: IdChatIdentifier
+        data class DidntSaidHello(override val context: IdChatIdentifier) : InternalFSMState
+        data class SaidHelloOnce(override val context: IdChatIdentifier) : InternalFSMState
+    }
+
+    override suspend fun startPlugin(koin: Koin) {
+        super.startPlugin(koin)
+        logger.i { "This logic called BEFORE the bot will be started and setup" }
+    }
+
+    override suspend fun BehaviourContextWithFSM<State>.setupBotPlugin(koin: Koin) {
+        val toPrint = koin.configOrNull<HelloPluginConfig>() ?.print ?: "Hello :)"
+        logger.d { toPrint }
+        logger.dS { getMe().toString() }
+        onCommand("hello_world") {
+            startChain(InternalFSMState.DidntSaidHello(it.chat.id))
+        }
+
+        strictlyOn { state: InternalFSMState.DidntSaidHello ->
+            sendMessage(state.context, toPrint)
+            InternalFSMState.SaidHelloOnce(state.context)
+        }
+
+        strictlyOn { state: InternalFSMState.SaidHelloOnce ->
+            val message = waitTextMessage().first()
+            reply(message, "Sorry, I can answer only this: $toPrint")
+            InternalFSMState.SaidHelloOnce(state.context)
+        }
+    }
+}

plugin/src/main/kotlin/dev/inmo/plagubot/KoinDatabaseExtensions.kt

@@ -0,0 +1,11 @@
+package dev.inmo.plagubot
+
+import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.scope.Scope
+
+val Scope.database: Database
+    get() = get()
+
+val Koin.database: Database
+    get() = get()

plugin/src/main/kotlin/dev/inmo/plagubot/KoinExtensions.kt

@@ -0,0 +1,55 @@
+package dev.inmo.plagubot
+
+import kotlinx.serialization.InternalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.serializer
+import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.module.Module
+import org.koin.core.scope.Scope
+import kotlin.reflect.KClass
+
+/**
+ * Using [single] to register `T` with serializer [configSerializer]
+ *
+ * @param default Will be used if [field] is absent as an alternative way of config allocation. If null passed, error
+ * will be thrown
+ */
+inline fun <reified T> Module.registerConfig(configSerializer: KSerializer<T>, field: String?, noinline default: (Scope.(JsonObject) -> T?)? = null) {
+    single {
+        val fieldValue = get<JsonObject>().let {
+            if (field == null) {
+                it
+            } else {
+                it[field] ?: default ?.let { _ ->
+                    return@single default(it)
+                } ?: error("Unable to take field $field from config")
+            }
+        }
+        get<Json>().decodeFromJsonElement(configSerializer, fieldValue)
+    }
+}
+
+/**
+ * Using [single] to register config with getting of [serializer] from [kClass]
+ *
+ * @param default Will be used if [field] is absent as an alternative way of config allocation. If null passed, error
+ * will be thrown
+ */
+@OptIn(InternalSerializationApi::class)
+inline fun <reified T : Any> Module.registerConfig(kClass: KClass<T>, field: String?, noinline default: (Scope.(JsonObject) -> T?)? = null) = registerConfig(kClass.serializer(), field, default)
+
+/**
+ * Using [single] to register config with getting of [serializer] from [kClass]
+ *
+ * @param default Will be used if [field] is absent as an alternative way of config allocation. If null passed, error
+ * will be thrown
+ */
+inline fun <reified T : Any> Module.registerConfig(field: String?, noinline default: (Scope.(JsonObject) -> T?)? = null) = registerConfig(T::class, field, default)
+
+inline fun <reified T : Any> Scope.config() = get<T>()
+inline fun <reified T : Any> Koin.config() = get<T>()
+inline fun <reified T : Any> Scope.configOrNull() = getOrNull<T>()
+inline fun <reified T : Any> Koin.configOrNull() = getOrNull<T>()

plugin/src/main/kotlin/dev/inmo/plagubot/Plugin.kt

@@ -1,47 +1,48 @@
 package dev.inmo.plagubot
 
-import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.micro_utils.fsm.common.State
+import dev.inmo.micro_utils.startup.plugin.StartPlugin
+import dev.inmo.tgbotapi.bot.ktor.KtorRequestsExecutorBuilder
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
-import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
-import kotlinx.coroutines.CoroutineScope
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextWithFSM
 import kotlinx.serialization.Serializable
-import org.jetbrains.exposed.sql.Database
+import kotlinx.serialization.json.JsonObject
+import org.koin.core.Koin
+import org.koin.core.scope.Scope
 
 /**
+ * **ANY REALIZATION OF [Plugin] MUST HAVE CONSTRUCTOR WITH ABSENCE OF INCOMING PARAMETERS**
+ *
  * Use this interface for your bot. It is possible to use [kotlinx.serialization.SerialName] annotations on your plugins
  * to set up short name for your plugin. Besides, simple name of your class will be used as key for deserialization
  * too.
  */
 @Serializable(PluginSerializer::class)
-interface Plugin {
+interface Plugin : StartPlugin {
+    @Deprecated("Deprecated in favor to setupBotClient with arguments")
+    fun KtorRequestsExecutorBuilder.setupBotClient() {}
+
     /**
-     * In case you want to publish some processed by your plugin commands, you can provide it via this method
+     * Will be called on stage of bot setup
      *
-     * @see BotCommand
+     * @param scope The scope of [org.koin.core.module.Module.single] of bot definition
+     * @param params Params (in fact, the whole bot config)
      */
-    suspend fun getCommands(): List<BotCommand> = emptyList()
+    fun KtorRequestsExecutorBuilder.setupBotClient(scope: Scope, params: JsonObject) = setupBotClient()
 
-    @Deprecated("Override other method with receiver BehaviourContext")
-    suspend operator fun invoke(
-        bot: TelegramBot,
-        database: Database,
-        updatesFilter: FlowsUpdatesFilter,
-        scope: CoroutineScope
+    /**
+     * Override this method in cases when you want to declare common bot behaviour. In case you wish to use FSM, you
+     * should override the method with receiver [BehaviourContextWithFSM]
+     */
+    suspend fun BehaviourContext.setupBotPlugin(
+        koin: Koin
     ) {}
-
     /**
-     * This method (usually) will be invoked just one time in the whole application.
+     * Override this method in cases when you want to declare full behaviour of the plugin. It is recommended to declare
+     * common logic of plugin in the [setupBotPlugin] with [BehaviourContext] receiver and use override this one
+     * for the FSM configuration
      */
-    suspend operator fun BehaviourContext.invoke(
-        database: Database
-    ) = invoke(bot, database, flowsUpdatesFilter, scope)
-
-    /**
-     * This method (usually) will be invoked just one time in the whole application.
-     */
-    suspend operator fun BehaviourContext.invoke(
-        database: Database,
-        params: Map<String, Any>
-    ) = invoke(database)
+    suspend fun BehaviourContextWithFSM<State>.setupBotPlugin(koin: Koin) {
+        (this as BehaviourContext).setupBotPlugin(koin)
+    }
 }

plugin/src/main/kotlin/dev/inmo/plagubot/PluginSerializer.kt

@@ -1,53 +1,25 @@
 package dev.inmo.plagubot
 
-import kotlinx.serialization.*
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.*
-
-private val defaultJson = Json {
-    ignoreUnknownKeys = true
-}
 
 @Serializer(Plugin::class)
-object PluginSerializer : KSerializer<Plugin> {
-    private val polymorphic = PolymorphicSerializer(Plugin::class)
-    override val descriptor: SerialDescriptor = JsonObject.serializer().descriptor
+class PluginSerializer : KSerializer<Plugin> {
+    override val descriptor: SerialDescriptor
+        get() = String.serializer().descriptor
 
-    @OptIn(InternalSerializationApi::class)
     override fun deserialize(decoder: Decoder): Plugin {
-        val format = (decoder as? JsonDecoder) ?.json ?: defaultJson
-        val asJson = JsonElement.serializer().deserialize(decoder)
-        val jsonObject = (asJson as? JsonObject)
-
-        val type = (jsonObject ?.get("type") as? JsonPrimitive) ?.contentOrNull
-        val external = if (type != null) {
-            try {
-                Class.forName(type) ?.kotlin ?.serializerOrNull()
-            } catch (e: Exception) {
-                null
-            }
-        } else {
-            null
-        }
-
-        return if (jsonObject != null && external != null) {
-            format.decodeFromJsonElement(
-                external as KSerializer<Plugin>,
-                JsonObject(jsonObject.toMutableMap().also { it.remove("type") })
-            )
-        } else {
-            format.decodeFromJsonElement(
-                polymorphic,
-                asJson
-            )
-        }
+        val kclass = Class.forName(decoder.decodeString()).kotlin
+        return (kclass.objectInstance ?: kclass.constructors.first { it.parameters.isEmpty() }.call()) as Plugin
     }
 
-    @OptIn(InternalSerializationApi::class)
     override fun serialize(encoder: Encoder, value: Plugin) {
-        val serializer = (value::class.serializerOrNull() ?: polymorphic) as KSerializer<Plugin>
-        serializer.serialize(encoder, value)
+        encoder.encodeString(
+            value::class.java.canonicalName
+        )
     }
 }

settings.gradle

@@ -2,7 +2,12 @@ String[] toInclude = [":bot", ":plugin"]
 
 rootProject.name = 'plagubot'
 
-toInclude.each {
-    include (it)
-    project(it).name = "${rootProject.name}${it.replace(":", ".")}"
+toInclude.each { originalName ->
+    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replace(":", File.separator)}"
+    String projectName = "${rootProject.name}${originalName.replace(":", ".")}"
+    String projectIdentifier = ":${projectName}"
+    include projectIdentifier
+    ProjectDescriptor project = project(projectIdentifier)
+    project.name = projectName
+    project.projectDir = new File(projectDirectory)
 }

template.config.json

@@ -4,13 +4,16 @@
     "driver": "org.sqlite.JDBC",
     "username": "OPTIONAL username",
     "password": "OPTIONAL password",
-    "initAutomatically": false
+    "reconnectOptions": {
+      "attempts": 3,
+      "delay": 1000
+    }
   },
   "botToken": "1234567890:ABCDEFGHIJKLMNOP_qrstuvwxyz12345678",
   "plugins": [
-    {
-      "type": "Hello",
-      "parameter": "Example"
-    }
-  ]
-}
+    "dev.inmo.plagubot.HelloPlugin"
+  ],
+  "helloPlugin": {
+    "print": "Hello World"
+  }
+}