remove redundant config test and update build workflow

0.5.1

.github/workflows/build.yml

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

CHANGELOG.md

@@ -1,5 +1,94 @@
 # Changelog
 
+## 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`
+  * `tgbotapi`: `0.38.4`
+  * `microutils`: `0.9.5`
+
+## 0.5.0
+
+* `Versions`
+  * `kotlin`: `1.6.10`
+  * `coroutines`: `1.6.0`
+  * `serialization`: `1.3.2`
+  * `exposed`: `0.37.2`
+  * `tgbotapi`: `0.38.0`
+  * `microutils`: `0.9.0`
+
+## 0.4.1
+
+Temporal update for compatibility with java 1.8
+
+## 0.3.2
+
+* `Versions`
+  * `kotlin`: `1.5.20` -> `1.5.31`
+  * `coroutines`: `1.5.0` -> `1.5.2`
+  * `serialization`: `1.2.1` -> `1.2.2`
+  * `exposed`: `0.32.1` -> `0.34.2`
+  * `tgbotapi`: `0.35.1` -> `0.35.9`
+  * `microutils`: `0.5.15` -> `0.5.28`
+
+## 0.3.1
+
+* `Versions`
+  * `kotlin`: `1.5.10` -> `1.5.20`
+  * `tgbotapi`: `0.35.0` -> `0.35.1`
+  * `microutils`: `0.5.7` -> `0.5.15`
+
+## 0.3.0
+
+* `Versions`
+  * `kotlin`: `1.4.32` -> `1.5.10`
+  * `coroutines`: `1.4.3` -> `1.5.0`
+  * `serialization`: `1.1.0` -> `1.2.1`
+  * `exposed`: `0.31.1` -> `0.32.1`
+  * `sdi`: `0.4.1` -> `0.5.0`
+  * `tgbotapi`: `0.34.1` -> `0.35.0`
+  * `microutils`: `0.4.36` -> `0.5.7`
+* `Bot`
+  * Add plugin `PluginsHolder`
+  * Rewrite mechanism of `Config` working
+  * `PlaguBot` now is correctly serializable/deserializable
+
+## 0.2.1
+
+* `Versions`
+  * `tgbotapi`: `0.33.4` -> `0.34.0`
+  * `sqlite`: `3.30.1` -> `3.34.0`
+
+## 0.2.0
+
+* `Versions`
+  * `tgbotapi`: `0.33.4` -> `0.34.0`
+  * `exposed`: `0.30.2` -> `0.31.1`
+
+## 0.1.9
+
+* `Versions`
+  * `tgbotapi`: `0.33.3` -> `0.33.4`
+  * `microutils`: `0.4.33` -> `0.4.36`
+  * `exposed`: `0.30.1` -> `0.30.2`
+
 ## 0.1.8
 
 * `Versions`

README.md

@@ -11,8 +11,8 @@ You can create your bot using
 
 | Template: | [![Use template](badges/use_template.svg)](https://github.com/InsanusMokrassar/PlaguBotPluginTemplate/generate) |
 |-----------|-----------------------------------------------------------------------------------------------------------------|
-| Bot version: | [![Download](https://api.bintray.com/packages/insanusmokrassar/PlaguBot/plagubot.bot/images/download.svg)](https://bintray.com/insanusmokrassar/PlaguBot/plagubot.bot/_latestVersion) |
+| Bot version: | [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/plagubot.bot/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/plagubot.bot) |
-| Plugin version: | [![Download](https://api.bintray.com/packages/insanusmokrassar/PlaguBot/plagubot.plugin/images/download.svg)](https://bintray.com/insanusmokrassar/PlaguBot/plagubot.plugin/_latestVersion) |
+| Plugin version: | [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/plagubot.plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/plagubot.plugin) |
 
 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.

bot/build.gradle

@@ -1,7 +1,6 @@
 plugins {
     id 'org.jetbrains.kotlin.jvm'
     id "org.jetbrains.kotlin.plugin.serialization"
-    id "org.jetbrains.kotlin.kapt"
     id 'application'
 }
 
@@ -11,21 +10,17 @@ project.version="$version"
 apply from: "publish.gradle"
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation libs.kt.stdlib
-    api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+    api libs.kt.coroutines
-    api "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_runtime_version"
+    api libs.kt.serialization
-    api "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
+    api libs.jb.exposed.jdbc
-    api "org.jetbrains.exposed:exposed-jdbc:$kotlin_exposed_version"
 
-    api "dev.inmo:tgbotapi:$tgbotapi_version"
+    api libs.tgbotapi
-    api "dev.inmo:sdi:$sdi_version"
+    api libs.microutils.repos.exposed
-    api "dev.inmo:micro_utils.repos.exposed:$microutils_version"
 
-    api "com.github.matfax.klassindex:library:$klassindex_version"
+    api libs.sqlite
-    kapt "com.github.matfax.klassindex:processor:$klassindex_version"
-    api "org.xerial:sqlite-jdbc:$sqlite_version"
 
-    testImplementation "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+    testImplementation libs.kt.test.junit
 
     api project(":plagubot.plugin")
 }
@@ -34,10 +29,8 @@ application {
     mainClassName = 'dev.inmo.plagubot.AppKt'
 }
 
-kapt {
+java {
-    arguments {
+    sourceCompatibility = JavaVersion.VERSION_1_8
-        arg("com.github.matfax.klassindex.IndexSubclasses", "dev.inmo.plagubot.Plugin")
+    targetCompatibility = JavaVersion.VERSION_1_8
-        arg("com.github.matfax.klassindex.IndexAnnotated", "dev.inmo.sdi.SDIIncluded")
-    }
 }
 

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,6 +1,4 @@
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
-
 
 task javadocJar(type: Jar) {
     from javadoc
@@ -50,17 +48,8 @@ publishing {
                     
                 }
             }
-            
+            repositories {
-                repositories {
+                if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-                    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/")
@@ -69,14 +58,24 @@ publishing {
                             password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                         }
                     }
-                    
                 }
-            
+            }
         }
     }
 }
 
-signing {
+if (project.hasProperty("signing.gnupg.keyName")) {
-    useGpgCmd()
+    apply plugin: 'signing'
-    sign publishing.publications
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
 }

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":"sonatype","url":"https://oss.sonatype.org/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

@@ -3,20 +3,9 @@ package dev.inmo.plagubot
 import dev.inmo.plagubot.config.*
 import kotlinx.coroutines.*
 import kotlinx.serialization.InternalSerializationApi
+import kotlinx.serialization.json.jsonObject
 import java.io.File
 
-@Deprecated(
-    "This method is redundant due to new class PlaguBot",
-    ReplaceWith(
-        "PlaguBot(config).start(scope)",
-        "dev.inmo.plagubot.PlaguBot"
-    )
-)
-suspend inline fun initPlaguBot(
-    config: Config,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-): Job = PlaguBot(config).start(scope)
-
 /**
  * This method by default expects one argument in [args] field: path to config
  */
@@ -24,7 +13,8 @@ suspend inline fun initPlaguBot(
 suspend fun main(args: Array<String>) {
     val (configPath) = args
     val file = File(configPath)
-    val config = configJsonFormat.decodeFromString(ConfigSerializer, file.readText())
+    val json = defaultJsonFormat.parseToJsonElement(file.readText()).jsonObject
+    val config = defaultJsonFormat.decodeFromJsonElement(Config.serializer(), json)
 
-    PlaguBot(config).start().join()
+    PlaguBot(json, config).start().join()
 }

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

@@ -1,16 +1,39 @@
 package dev.inmo.plagubot
 
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
-import kotlinx.serialization.SerialName
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
 import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.KoinApplication
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
+import org.koin.core.module.Module
+import org.koin.dsl.module
 
 @Serializable
 @SerialName("Hello")
-data class HelloPlugin(
+class HelloPlugin : Plugin {
-    val parameter: String
+    @Serializable
-) : Plugin {
+    data class HelloPluginConfig(
-    override suspend fun BehaviourContext.invoke(database: Database) {
+        val print: String
-        println(parameter)
+    )
+
+    override fun Module.setupDI(database: Database, params: JsonObject) {
+        single {
+            get<Json>().decodeFromJsonElement(HelloPluginConfig.serializer(), params["helloPlugin"] ?: return@single null)
+        }
+    }
+
+    override suspend fun BehaviourContext.setupBotPlugin(koin: Koin) {
+        println(koin.get<HelloPluginConfig>().print)
+        println(getMe())
+        onCommand("hello_world") {
+            reply(it, "Hello :)")
+        }
     }
 }

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

@@ -1,56 +1,98 @@
 package dev.inmo.plagubot
 
-import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
+import dev.inmo.plagubot.config.*
-import dev.inmo.plagubot.config.Config
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
-import dev.inmo.plagubot.config.database
+import dev.inmo.tgbotapi.extensions.api.webhook.deleteWebhook
-import dev.inmo.tgbotapi.bot.Ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.startGettingOfUpdatesByLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviour
-import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.types.botCommandsLimit
 import kotlinx.coroutines.*
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
+import kotlinx.serialization.json.JsonObject
 import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.KoinApplication
+import org.koin.core.context.GlobalContext
+import org.koin.core.module.Module
+import org.koin.core.scope.Scope
+import org.koin.dsl.module
+import java.util.logging.Level
+import java.util.logging.Logger
 
-const val DefaultPlaguBotParamsKey = "plagubot"
+val Scope.plagubot: PlaguBot
-val Map<String, Any>.plagubot
+    get() = get()
-    get() = get(DefaultPlaguBotParamsKey) as? PlaguBot
 
 @Serializable
 data class PlaguBot(
+    private val json: JsonObject,
     private val config: Config
 ) : Plugin {
+    @Transient
+    private val logger = Logger.getLogger("PlaguBot")
     @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 {
+    override fun Module.setupDI(database: Database, params: JsonObject) {
-        it.getCommands()
+        single { config }
+        single { config.plugins }
+        single { config.databaseConfig }
+        single { config.databaseConfig.database }
+        single { defaultJsonFormat }
+        single { this@PlaguBot }
+
+        includes(
+            config.plugins.mapNotNull {
+                runCatching {
+                    module {
+                        with(it) {
+                            setupDI(database, params)
+                        }
+                    }
+                }.onFailure { e ->
+                    logger.log(Level.WARNING, "Unable to load DI part of $it", e)
+                }.getOrNull()
+            }
+        )
     }
 
-    override suspend fun BehaviourContext.invoke(database: Database, params: Map<String, Any>) {
+    override suspend fun BehaviourContext.setupBotPlugin(koin: Koin) {
         config.plugins.forEach {
-            it.apply { invoke(database, params) }
+            runCatching {
+                with(it) {
+                    setupBotPlugin(koin)
+                }
+            }.onFailure { e ->
+                logger.log(Level.WARNING, "Unable to load bot part of $it", e)
+            }
         }
-        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
      */
     suspend fun start(
-        scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+        scope: CoroutineScope = CoroutineScope(Dispatchers.IO)
-    ): Job = bot.buildBehaviour(scope) {
+    ): Job {
-        invoke(database, paramsMap)
+        logger.info("Start initialization")
+        val koinApp = KoinApplication.init()
+        koinApp.modules(
+            module {
+                setupDI(config.databaseConfig.database, json)
+            }
+        )
+        logger.info("Modules loaded")
+        GlobalContext.startKoin(koinApp)
+        logger.info("Koin started")
+        lateinit var behaviourContext: BehaviourContext
+        bot.buildBehaviour(scope = scope) {
+            logger.info("Start setup of bot part")
+            behaviourContext = this
+            setupBotPlugin(koinApp.koin)
+            deleteWebhook()
+        }
+        logger.info("Behaviour builder has been setup")
+        return bot.startGettingOfUpdatesByLongPolling(scope = behaviourContext, updatesFilter = behaviourContext).also {
+            logger.info("Long polling has been started")
+        }
     }
 }

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

@@ -1,166 +1,13 @@
 package dev.inmo.plagubot.config
 
-import com.github.matfax.klassindex.KlassIndex
 import dev.inmo.plagubot.Plugin
-import dev.inmo.plagubot.PluginSerializer
+import kotlinx.serialization.SerialName
-import dev.inmo.sdi.*
+import kotlinx.serialization.Serializable
-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 configJsonFormat: 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]
-                    }
-                }
-            }
-        }
-    }
 
 @Serializable
 data class Config(
-    val plugins: List<@Contextual Plugin>,
-    val database: DatabaseConfig = DatabaseConfig(),
     val botToken: String,
-    @Contextual
+    val plugins: List<Plugin>,
-    val params: Module? = null
+    @SerialName("database")
+    val databaseConfig: DatabaseConfig = DatabaseConfig(),
 )
-
-@Serializer(Plugin::class)
-private class InternalPluginSerializer(
-    private val params: Module
-) : KSerializer<Plugin> {
-    override val descriptor: SerialDescriptor = PluginSerializer.descriptor
-
-    @InternalSerializationApi
-    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 ?: configJsonFormat)
-            jsonFormat.decodeFromJsonElement(PluginSerializer, asJson)
-        }
-    }
-
-    @InternalSerializationApi
-    override fun serialize(encoder: Encoder, value: Plugin) {
-        params.keys.firstOrNull { params[it] === value } ?.also {
-            encoder.encodeString(it)
-        } ?: PluginSerializer.serialize(encoder, value)
-    }
-}
-
-private val DefaultModuleSerializer = ModuleSerializer(emptyList()) {
-
-}
-
-@Serializer(Module::class)
-private class InternalModuleSerializer(
-    private val original: JsonElement?,
-    private val params: Module
-) : KSerializer<Module> {
-    override val descriptor: SerialDescriptor = PluginSerializer.descriptor
-
-    @InternalSerializationApi
-    override fun deserialize(decoder: Decoder): Module {
-        val asJson = JsonElement.serializer().deserialize(decoder)
-
-        return if (asJson == original) {
-            params
-        } else {
-            configJsonFormat.decodeFromJsonElement(DefaultModuleSerializer, asJson)
-        }
-    }
-
-    @InternalSerializationApi
-    override fun serialize(encoder: Encoder, value: Module) = DefaultModuleSerializer.serialize(encoder, value)
-}
-
-private fun internalPluginSerializerSerializersModule(
-    internalPluginSerializer: InternalPluginSerializer,
-    internalModuleSerializer: InternalModuleSerializer?
-) = SerializersModule {
-    contextual(internalPluginSerializer)
-    contextual(internalModuleSerializer ?: return@SerializersModule)
-}
-
-@Serializer(Config::class)
-internal object ConfigSerializer : KSerializer<Config> {
-    private val jsonSerializer = JsonObject.serializer()
-    private val moduleSerializer = ModuleSerializer()
-
-    @InternalSerializationApi
-    override fun deserialize(decoder: Decoder): Config {
-        val json = jsonSerializer.deserialize(decoder)
-        val jsonFormat = (decoder as? JsonDecoder) ?.json ?: configJsonFormat
-        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 resultJsonFormat.decodeFromJsonElement(
-            Config.serializer(),
-            json
-        )
-    }
-
-    @InternalSerializationApi
-    override fun serialize(encoder: Encoder, value: Config) {
-        if (value.params != null) {
-            val pluginsSerializer = InternalPluginSerializer(value.params)
-
-            val jsonFormat = Json(configJsonFormat) {
-                serializersModule = encoder.serializersModule.overwriteWith(
-                    internalPluginSerializerSerializersModule(pluginsSerializer, null)
-                )
-            }
-
-            jsonSerializer.serialize(
-                encoder,
-                jsonFormat.encodeToJsonElement(
-                    Config.serializer(),
-                    value
-                ) as JsonObject
-            )
-        } else {
-            Config.serializer().serialize(encoder, value)
-        }
-    }
-}

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

@@ -1,19 +1,17 @@
 package dev.inmo.plagubot.config
 
-import dev.inmo.sdi.SDIIncluded
 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.sql.Connection
 
-const val defaultDatabaseParamsName = "defaultDatabase"
+inline val Scope.database: Database?
-inline val Map<String, Any>.database: Database?
+    get() = getOrNull<Database>()
-    get() = (get(defaultDatabaseParamsName) as? DatabaseConfig) ?.database
 
 @Serializable
-@SDIIncluded
 data class DatabaseConfig(
     val url: String = "jdbc:sqlite:file:test?mode=memory&cache=shared",
     val driver: String = JDBC::class.qualifiedName!!,

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

@@ -0,0 +1,7 @@
+package dev.inmo.plagubot.config
+
+import kotlinx.serialization.json.Json
+
+val defaultJsonFormat = Json {
+    ignoreUnknownKeys = true
+}

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

@@ -1,37 +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 = configJsonFormat.decodeFromString(ConfigSerializer, rawConfig)
-
-        assert(config.plugins.size == 1)
-        assert(config.plugins.first() is HelloPlugin)
-        assert((config.plugins.first() as HelloPlugin).parameter == "Example")
-
-        val redecoded = configJsonFormat.decodeFromString(ConfigSerializer, configJsonFormat.encodeToString(ConfigSerializer, 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,20 +1,19 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
         maven { url "https://plugins.gradle.org/m2/" }
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath libs.buildscript.kt.gradle
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath libs.buildscript.kt.serialization
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
+        classpath libs.buildscript.gh.release
     }
 }
 
 allprojects {
     repositories {
         mavenCentral()
-        jcenter()
         mavenLocal()
         maven { url 'https://jitpack.io' }
     }

gradle.properties

@@ -4,19 +4,5 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 
-kotlin_version=1.4.32
-kotlin_coroutines_version=1.4.3
-kotlin_serialisation_runtime_version=1.1.0
-kotlin_exposed_version=0.30.1
-
-sdi_version=0.4.1
-tgbotapi_version=0.33.3
-microutils_version=0.4.33
-klassindex_version=4.1.0-rc.1
-
-sqlite_version=3.30.1
-
-github_release_plugin_version=2.2.12
-
 group=dev.inmo
-version=0.1.8
+version=1.0.0

gradle/libs.versions.toml

@@ -0,0 +1,49 @@
+[versions]
+
+kt = "1.6.21"
+kt-serialization = "1.3.3"
+kt-coroutines = "1.6.1"
+
+microutils = "0.10.4"
+tgbotapi = "1.1.0"
+
+jb-exposed = "0.38.2"
+jb-dokka = "1.6.21"
+
+sqlite = "3.36.0.3"
+
+klock = "2.7.0"
+uuid = "0.4.0"
+
+ktor = "2.0.1"
+
+gh-release = "2.3.7"
+
+android-gradle = "7.0.4"
+dexcount = "3.1.0"
+koin = "3.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" }
+microutils-repos-exposed = { module = "dev.inmo:micro_utils.repos.exposed", 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" }

gradle/wrapper/gradle-wrapper.properties

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

plugin/build.gradle

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

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,6 +1,4 @@
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
-
 
 task javadocJar(type: Jar) {
     from javadoc
@@ -50,17 +48,8 @@ publishing {
                     
                 }
             }
-            
+            repositories {
-                repositories {
+                if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-                    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/")
@@ -69,14 +58,24 @@ publishing {
                             password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                         }
                     }
-                    
                 }
-            
+            }
         }
     }
 }
 
-signing {
+if (project.hasProperty("signing.gnupg.keyName")) {
-    useGpgCmd()
+    apply plugin: 'signing'
-    sign publishing.publications
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
 }

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":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}},"type":"JVM"}

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

@@ -1,14 +1,15 @@
 package dev.inmo.plagubot
 
-import dev.inmo.tgbotapi.bot.TelegramBot
 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 kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonObject
 import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.module.Module
 
 /**
+ * **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.
@@ -16,32 +17,13 @@ import org.jetbrains.exposed.sql.Database
 @Serializable(PluginSerializer::class)
 interface Plugin {
     /**
-     * In case you want to publish some processed by your plugin commands, you can provide it via this method
+     * This method will be called when this plugin should configure di module based on the incoming params
-     *
-     * @see BotCommand
      */
-    suspend fun getCommands(): List<BotCommand> = emptyList()
+    fun Module.setupDI(
-
-    @Deprecated("Override other method with receiver BehaviourContext")
-    suspend operator fun invoke(
-        bot: TelegramBot,
         database: Database,
-        updatesFilter: FlowsUpdatesFilter,
+        params: JsonObject
-        scope: CoroutineScope
+    ) {}
+    suspend fun BehaviourContext.setupBotPlugin(
+        koin: Koin
     ) {}
-
-    /**
-     * This method (usually) will be invoked just one time in the whole application.
-     */
-    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)
 }

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

@@ -1,53 +1,24 @@
 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> {
+class PluginSerializer : KSerializer<Plugin> {
-    private val polymorphic = PolymorphicSerializer(Plugin::class)
+    override val descriptor: SerialDescriptor
-    override val descriptor: SerialDescriptor = JsonObject.serializer().descriptor
+        get() = String.serializer().descriptor
 
-    @InternalSerializationApi
     override fun deserialize(decoder: Decoder): Plugin {
-        val format = (decoder as? JsonDecoder) ?.json ?: defaultJson
+        return Class.forName(decoder.decodeString()).getDeclaredConstructor().newInstance() as Plugin
-        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
-            )
-        }
     }
 
-    @InternalSerializationApi
     override fun serialize(encoder: Encoder, value: Plugin) {
-        val serializer = (value::class.serializerOrNull() ?: polymorphic) as KSerializer<Plugin>
+        encoder.encodeString(
-        serializer.serialize(encoder, value)
+            value::class.java.canonicalName
+        )
     }
-}
+}

template.config.json

@@ -8,9 +8,9 @@
   },
   "botToken": "1234567890:ABCDEFGHIJKLMNOP_qrstuvwxyz12345678",
   "plugins": [
-    {
+    "dev.inmo.plagubot.HelloPlugin"
-      "type": "Hello",
+  ],
-      "parameter": "Example"
+  "helloPlugin": {
-    }
+    "print": "Hello World"
-  ]
+  }
-}
+}