fix build

0.1.4

.github/workflows/build.yml

@@ -0,0 +1,16 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 1.8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+      - name: Build with Gradle
+        run: ./gradlew build

CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 0.1.5
+
+* `Versions`
+  * `kotlin`: `1.4.30` -> `1.4.31`
+  * `serialization`: `1.1.0-RC` -> `1.1.0`
+  * `coroutines`: `1.4.2` -> `1.4.3`
+  * `tgbotapi`: `0.32.8` -> `0.33.0`
+  * `microutils`: `0.4.26` -> `0.4.29`
+
+## 0.1.4
+
+* `Versions`
+  * `sdi`: `0.4.0-rc2` -> `0.4.1`
+  * `tgbotapi`: `0.32.7` -> `0.32.8`
+  * `microutils`: `0.4.25` -> `0.4.26`
+* `Bot`
+  * Fix of [#9](https://github.com/InsanusMokrassar/PlaguBot/issues/9)
+
+## 0.1.3
+
+* `Versions`
+  * `tgbotapi`: `0.32.6` -> `0.32.7`
+* `Bot`
+  * `initPlaguBot` now will return `Job`
+* `Plugin`
+  * Plugin serializer
+
+## 0.1.2
+
+* `Versions`
+  * `tgbotapi`: `0.32.5` -> `0.32.6`
+
+## 0.1.0
+
+* `Versions`
+  * `kotlin`: `1.4.21` -> `1.4.30`
+  * `serialization`: `1.0.1` -> `1.1.0-RC`
+  * `exposed`: `0.28.1` -> `0.29.1`
+  * `tgbotapi`: `0.30.10` -> `0.32.5`
+  * `microutils`: `0.4.11` -> `0.4.25`
+* `Bot`
+  * New dependency `sdi`
+    * Now it is possible to pass `Module` to configuration for providing a global plugins parameters like different
+  common database or tools
+* `Plugin`
+  * Two new methods `BehaviourContext#invoke`
+    * Old method `invoke` has been deprecated
+
 ## 0.0.5
 
 * `Versions`

bot/build.gradle

@@ -18,12 +18,15 @@ dependencies {
     api "org.jetbrains.exposed:exposed-jdbc:$kotlin_exposed_version"
 
     api "dev.inmo:tgbotapi:$tgbotapi_version"
+    api "dev.inmo:sdi:$sdi_version"
     api "dev.inmo:micro_utils.repos.exposed:$microutils_version"
 
     api "com.github.matfax.klassindex:library:$klassindex_version"
     kapt "com.github.matfax.klassindex:processor:$klassindex_version"
     api "org.xerial:sqlite-jdbc:$sqlite_version"
 
+    testImplementation "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+
     api project(":plagubot.plugin")
 }
 
@@ -34,6 +37,7 @@ application {
 kapt {
     arguments {
         arg("com.github.matfax.klassindex.IndexSubclasses", "dev.inmo.plagubot.Plugin")
+        arg("com.github.matfax.klassindex.IndexAnnotated", "dev.inmo.sdi.SDIIncluded")
     }
 }
 

bot/pubconf.kpsb

@@ -1 +1 @@
-{"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 ${project.name}","description":"","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"}]},"type":"JVM"}
+{"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,28 +1,29 @@
 apply plugin: 'maven-publish'
+apply plugin: 'signing'
 
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
 
 task javadocJar(type: Jar) {
     from javadoc
     classifier = 'javadoc'
 }
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
+}
 
 publishing {
     publications {
         maven(MavenPublication) {
             from components.java
 
-            artifact sourcesJar
             artifact javadocJar
+            artifact sourcesJar
 
             pom {
                 resolveStrategy = Closure.DELEGATE_FIRST
 
-                description = ""
-                name = "PlaguBot ${project.name}"
+                description = "Base PlaguBot project"
+                name = "PlaguBot Bot"
                 url = "https://github.com/InsanusMokrassar/PlaguBot"
 
                 scm {
@@ -59,8 +60,23 @@ publishing {
                             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')
+                        }
+                    }
+                    
                 }
             
         }
     }
-}
+}
+
+signing {
+    useGpgCmd()
+    sign publishing.publications
+}

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

@@ -1,11 +1,11 @@
 package dev.inmo.plagubot
 
 import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
-import dev.inmo.plagubot.config.Config
-import dev.inmo.plagubot.config.configSerialFormat
+import dev.inmo.plagubot.config.*
+import dev.inmo.plagubot.config.configJsonFormat
+import dev.inmo.tgbotapi.bot.Ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.telegramBot
-import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.startGettingFlowsUpdatesByLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviour
 import dev.inmo.tgbotapi.types.botCommandsLimit
 import kotlinx.coroutines.*
 import kotlinx.serialization.InternalSerializationApi
@@ -14,12 +14,14 @@ import java.io.File
 suspend inline fun initPlaguBot(
     config: Config,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) {
+): Job {
     val bot = telegramBot(config.botToken)
 
-    bot.startGettingFlowsUpdatesByLongPolling(scope = scope) {
+    val paramsMap = config.params ?.toMap() ?: emptyMap()
+    val database = config.params ?.database ?: config.database.database
+    return bot.buildBehaviour(scope) {
         val commands = config.plugins.flatMap {
-            it.invoke(bot, config.database.database, this, scope)
+            it.apply { invoke(database, paramsMap) }
             it.getCommands()
         }.let {
             val futureUnavailable = it.drop(botCommandsLimit.last)
@@ -28,11 +30,7 @@ suspend inline fun initPlaguBot(
             }
             it.take(botCommandsLimit.last)
         }
-        scope.launch {
-            safelyWithoutExceptions {
-                bot.setMyCommands(commands)
-            }
-        }
+        safelyWithoutExceptions { setMyCommands(commands) }
     }
 }
 
@@ -43,9 +41,8 @@ suspend inline fun initPlaguBot(
 suspend fun main(args: Array<String>) {
     val (configPath) = args
     val file = File(configPath)
-    val config = configSerialFormat.decodeFromString(Config.serializer(), file.readText())
+    val config = configJsonFormat.decodeFromString(ConfigSerializer, file.readText())
 
     val scope = CoroutineScope(Dispatchers.Default)
-    initPlaguBot(config, scope)
-    scope.coroutineContext.job.join()
+    initPlaguBot(config, scope).join()
 }

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

@@ -1,8 +1,6 @@
 package dev.inmo.plagubot
 
-import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
-import kotlinx.coroutines.CoroutineScope
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import org.jetbrains.exposed.sql.Database
@@ -12,12 +10,7 @@ import org.jetbrains.exposed.sql.Database
 data class HelloPlugin(
     val parameter: String
 ) : Plugin {
-    override suspend fun invoke(
-        bot: TelegramBot,
-        database: Database,
-        updatesFilter: FlowsUpdatesFilter,
-        scope: CoroutineScope
-    ) {
+    override suspend fun BehaviourContext.invoke(database: Database) {
         println(parameter)
     }
 }

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

@@ -2,8 +2,13 @@ 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.*
 import kotlinx.serialization.*
-import kotlinx.serialization.json.Json
+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
 
@@ -11,7 +16,7 @@ import kotlin.reflect.KClass
 internal inline fun <T : Plugin> KClass<T>.includeIn(builder: PolymorphicModuleBuilder<Plugin>) = builder.subclass(this, serializer())
 
 @InternalSerializationApi
-internal val configSerialFormat: StringFormat
+internal val configJsonFormat: Json
     get() = Json {
         ignoreUnknownKeys = true
         serializersModule = SerializersModule {
@@ -36,7 +41,126 @@ internal val configSerialFormat: StringFormat
 
 @Serializable
 data class Config(
-    val plugins: List<Plugin>,
-    val database: DatabaseConfig,
-    val botToken: String
+    val plugins: List<@Contextual Plugin>,
+    val database: DatabaseConfig = DatabaseConfig(),
+    val botToken: String,
+    @Contextual
+    val params: Module? = null
 )
+
+@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,5 +1,6 @@
 package dev.inmo.plagubot.config
 
+import dev.inmo.sdi.SDIIncluded
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
 import org.jetbrains.exposed.sql.Database
@@ -7,7 +8,12 @@ import org.jetbrains.exposed.sql.transactions.transactionManager
 import org.sqlite.JDBC
 import java.sql.Connection
 
+const val defaultDatabaseParamsName = "defaultDatabase"
+inline val Map<String, Any>.database: 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/test/kotlin/dev/inmo/plagubot/config/ConfigTest.kt

@@ -0,0 +1,37 @@
+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

@@ -13,8 +13,8 @@ buildscript {
 
 allprojects {
     repositories {
-        jcenter()
         mavenCentral()
+        jcenter()
         mavenLocal()
         maven { url 'https://jitpack.io' }
     }

gradle.properties

@@ -4,16 +4,19 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 
-kotlin_version=1.4.21
-kotlin_coroutines_version=1.4.2
-kotlin_serialisation_runtime_version=1.0.1
-kotlin_exposed_version=0.28.1
-tgbotapi_version=0.30.10
-microutils_version=0.4.11
+kotlin_version=1.4.31
+kotlin_coroutines_version=1.4.3
+kotlin_serialisation_runtime_version=1.1.0
+kotlin_exposed_version=0.29.1
+
+sdi_version=0.4.1
+tgbotapi_version=0.33.0
+microutils_version=0.4.29
 klassindex_version=4.1.0-rc.1
+
 sqlite_version=3.30.1
 
 github_release_plugin_version=2.2.12
 
 group=dev.inmo
-version=0.0.5
+version=0.1.5

gradle/wrapper/gradle-wrapper.properties

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

plugin/pubconf.kpsb

@@ -1 +1 @@
-{"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 ${project.name}","description":"","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"}]},"type":"JVM"}
+{"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,28 +1,29 @@
 apply plugin: 'maven-publish'
+apply plugin: 'signing'
 
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
 
 task javadocJar(type: Jar) {
     from javadoc
     classifier = 'javadoc'
 }
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
+}
 
 publishing {
     publications {
         maven(MavenPublication) {
             from components.java
 
-            artifact sourcesJar
             artifact javadocJar
+            artifact sourcesJar
 
             pom {
                 resolveStrategy = Closure.DELEGATE_FIRST
 
-                description = ""
-                name = "PlaguBot ${project.name}"
+                description = "Base dependency for whole PlaguBot project"
+                name = "PlaguBot Plugin"
                 url = "https://github.com/InsanusMokrassar/PlaguBot"
 
                 scm {
@@ -59,8 +60,23 @@ publishing {
                             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')
+                        }
+                    }
+                    
                 }
             
         }
     }
-}
+}
+
+signing {
+    useGpgCmd()
+    sign publishing.publications
+}

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

@@ -1,9 +1,11 @@
 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 org.jetbrains.exposed.sql.Database
 
 /**
@@ -11,6 +13,7 @@ import org.jetbrains.exposed.sql.Database
  * 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 {
     /**
      * In case you want to publish some processed by your plugin commands, you can provide it via this method
@@ -19,13 +22,26 @@ interface Plugin {
      */
     suspend fun getCommands(): List<BotCommand> = emptyList()
 
-    /**
-     * This method (usually) will be invoked just one time in the whole application.
-     */
+    @Deprecated("Override other method with receiver BehaviourContext")
     suspend operator fun invoke(
         bot: TelegramBot,
         database: Database,
         updatesFilter: FlowsUpdatesFilter,
         scope: CoroutineScope
-    )
+    ) {}
+
+    /**
+     * 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

@@ -0,0 +1,53 @@
+package dev.inmo.plagubot
+
+import kotlinx.serialization.*
+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
+
+    @InternalSerializationApi
+    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
+            )
+        }
+    }
+
+    @InternalSerializationApi
+    override fun serialize(encoder: Encoder, value: Plugin) {
+        val serializer = (value::class.serializerOrNull() ?: polymorphic) as KSerializer<Plugin>
+        serializer.serialize(encoder, value)
+    }
+}