start migration

0.5.1

.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,159 @@
 # Changelog
 
+## 1.0.0
+
+## 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`
+  * `tgbotapi`: `0.33.2` -> `0.33.3`
+  * `microutils`: `0.4.32` -> `0.4.33`
+
+## 0.1.7
+
+* `Versions`
+  * `exposed`: `0.29.1` -> `0.30.1`
+  * `tgbotapi`: `0.33.1` -> `0.33.2`
+  * `microutils`: `0.4.31` -> `0.4.32`
+* `PlaguBot`
+  * New class `PlaguBot` (😊)
+  * `initPlaguBot` is deprecated
+  * New shortcut for params - `plagubot`. `PlaguBot` class can be put inside other plagubot
+  for additional opportunities
+
+## 0.1.6
+
+* `Versions`
+  * `kotlin`: `1.4.31` -> `1.4.32`
+  * `tgbotapi`: `0.33.0` -> `0.33.1`
+  * `microutils`: `0.4.29` -> `0.4.31`
+
+## 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`
+  * `kotlin`: `1.4.10` -> `1.4.21`
+  * `kotlin coroutines`: `1.4.1` -> `1.4.2`
+  * `tgbotapi`: `0.30.7` -> `0.30.10`
+  * `microutils`: `0.4.1` -> `0.4.11`
+
 ## 0.0.4
 
 * `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,18 +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:micro_utils.repos.exposed:$microutils_version"
+    api libs.microutils.repos.exposed
 
-    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 libs.kt.test.junit
 
     api project(":plagubot.plugin")
 }
@@ -31,9 +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
-    }
 }
 

bot/maven.publish.gradle

@@ -1,54 +0,0 @@
-apply plugin: 'maven-publish'
-
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
-
-task javadocJar(type: Jar) {
-    from javadoc
-    classifier = 'javadoc'
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-
-            artifact sourcesJar
-            artifact javadocJar
-
-            pom {
-                resolveStrategy = Closure.DELEGATE_FIRST
-
-                description = ""
-                name = "PlaguBot ${project.name}"
-                url = "https://github.com/InsanusMokrassar/PlaguBot"
-
-                scm {
-                    developerConnection = "scm:git:[fetch=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git[push=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-                    url = "ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-                }
-
-                developers {
-                    
-                        developer {
-                            id = "InsanusMokrassar"
-                            name = "Aleksei Ovsiannikov"
-                            email = "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name = "Apache Software License 2.0"
-                            url = "https://github.com/InsanusMokrassar/PlaguBot/LICENSE"
-                        }
-                    
-                }
-            }
-        }
-    }
-}

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 ${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"}

bot/publish.gradle

@@ -1,43 +1,81 @@
-apply plugin: 'com.jfrog.bintray'
+apply plugin: 'maven-publish'
 
-ext {
+task javadocJar(type: Jar) {
-    projectBintrayDir = "${project.group}/".replace(".", "/") + "${project.name}/${project.version}"
+    from javadoc
+    classifier = 'javadoc'
+}
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
 }
 
-bintray {
+publishing {
-    user = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
+    publications {
-    key = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
+        maven(MavenPublication) {
-    publications = ["maven"]
+            from components.java
-    filesSpec {
+
-        into "$projectBintrayDir"
+            artifact javadocJar
-        from("build/libs") {
+            artifact sourcesJar
-            include "**/*.asc"
+
-        }
+            pom {
-        from("build/publications/maven") {
+                resolveStrategy = Closure.DELEGATE_FIRST
-            rename 'pom-default.xml(.*)', "${project.name}-${project.version}.pom\$1"
+
-        }
+                description = "Base PlaguBot project"
-    }
+                name = "PlaguBot Bot"
-    
+                url = "https://github.com/InsanusMokrassar/PlaguBot"
-    publish = true
+
-    override = true
+                scm {
-    
+                    developerConnection = "scm:git:[fetch=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git[push=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-    pkg {
+                    url = "ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-        repo = "PlaguBot"
+                }
-        name = "${project.name}"
+
-        vcsUrl = "https://github.com/InsanusMokrassar/PlaguBot"
+                developers {
-        licenses = ["Apache-2.0"]
+                    
-        version {
+                        developer {
-            name = "${project.version}"
+                            id = "InsanusMokrassar"
-            released = new Date()
+                            name = "Aleksei Ovsiannikov"
-            vcsTag = "${project.version}"
+                            email = "ovsyannikov.alexey95@gmail.com"
-            gpg {
+                        }
-                sign = true
+                    
-                passphrase = project.hasProperty('signing.gnupg.passphrase') ? project.property('signing.gnupg.passphrase') : System.getenv('signing.gnupg.passphrase')
+                }
+
+                licenses {
+                    
+                        license {
+                            name = "Apache Software License 2.0"
+                            url = "https://github.com/InsanusMokrassar/PlaguBot/LICENSE"
+                        }
+                    
+                }
+            }
+            repositories {
+                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://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')
+                        }
+                    }
+                }
             }
         }
     }
 }
 
-apply from: "maven.publish.gradle"
+if (project.hasProperty("signing.gnupg.keyName")) {
-
+    apply plugin: 'signing'
-bintrayUpload.dependsOn publishToMavenLocal
+    
+    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

@@ -1,41 +1,10 @@
 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.plagubot.config.configSerialFormat
-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.types.botCommandsLimit
 import kotlinx.coroutines.*
 import kotlinx.serialization.InternalSerializationApi
 import java.io.File
 
-suspend inline fun initPlaguBot(
-    config: Config,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) {
-    val bot = telegramBot(config.botToken)
-
-    bot.startGettingFlowsUpdatesByLongPolling(scope = scope) {
-        val commands = config.plugins.flatMap {
-            it.invoke(bot, config.database.database, this, scope)
-            it.getCommands()
-        }.let {
-            val futureUnavailable = it.drop(botCommandsLimit.last)
-            if (futureUnavailable.isNotEmpty()) {
-                println("Next commands are out of range in setting command request and will be unavailable from autocompleting: ${futureUnavailable}")
-            }
-            it.take(botCommandsLimit.last)
-        }
-        scope.launch {
-            safelyWithoutExceptions {
-                bot.setMyCommands(commands)
-            }
-        }
-    }
-}
-
 /**
  * This method by default expects one argument in [args] field: path to config
  */
@@ -43,9 +12,7 @@ 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 = configAndPluginsConfigJsonFormat.decodeFromString(PluginsConfigurationSerializer, file.readText()) as Config
 
-    val scope = CoroutineScope(Dispatchers.Default)
+    PlaguBot(config).start().join()
-    initPlaguBot(config, scope)
-    scope.coroutineContext.job.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.extensions.behaviour_builder.BehaviourContext
-import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
-import kotlinx.coroutines.CoroutineScope
 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(
+    override suspend fun BehaviourContext.invoke(database: Database) {
-        bot: TelegramBot,
-        database: Database,
-        updatesFilter: FlowsUpdatesFilter,
-        scope: CoroutineScope
-    ) {
         println(parameter)
     }
 }

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

@@ -0,0 +1,53 @@
+package dev.inmo.plagubot
+
+import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
+import dev.inmo.plagubot.config.*
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.botCommandsLimit
+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
+
+@Serializable
+data class PlaguBot(
+    @Serializable(PluginsConfigurationSerializer::class)
+    private val config: Config
+) : Plugin {
+    @Transient
+    private val bot = telegramBot(config.botToken)
+    @Transient
+    private val database = config.params ?.database ?: config.database.database
+
+    override suspend fun getCommands(): List<BotCommand> = config.plugins.flatMap {
+        it.getCommands()
+    }
+
+    override suspend fun BehaviourContext.invoke(database: Database, params: Map<String, Any>) {
+        config.plugins.forEach {
+            it.apply { invoke(database, params) }
+        }
+        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)
+    ): Job = bot.buildBehaviourWithLongPolling(scope) {
+        invoke(database, paramsMap)
+    }
+}

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

@@ -0,0 +1,25 @@
+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,42 +1,15 @@
 package dev.inmo.plagubot.config
 
-import com.github.matfax.klassindex.KlassIndex
 import dev.inmo.plagubot.Plugin
-import kotlinx.serialization.*
+import dev.inmo.sdi.Module
-import kotlinx.serialization.json.Json
+import kotlinx.serialization.Contextual
-import kotlinx.serialization.modules.*
+import kotlinx.serialization.Serializable
-import kotlin.reflect.KClass
+import kotlinx.serialization.json.JsonObject
-
-@InternalSerializationApi
-internal inline fun <T : Plugin> KClass<T>.includeIn(builder: PolymorphicModuleBuilder<Plugin>) = builder.subclass(this, serializer())
-
-@InternalSerializationApi
-internal val configSerialFormat: StringFormat
-    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<Plugin>,
+    override val plugins: List<Plugin>,
-    val database: DatabaseConfig,
+    val database: DatabaseConfig = DatabaseConfig(),
-    val botToken: String
+    val botToken: String,
-)
+    val rawConfig: JsonObject
+) : PluginsConfiguration

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/main/kotlin/dev/inmo/plagubot/config/PluginsConfiguration.kt

@@ -0,0 +1,189 @@
+package dev.inmo.plagubot.config
+
+import com.github.matfax.klassindex.KlassIndex
+import dev.inmo.plagubot.Plugin
+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/test/kotlin/dev/inmo/plagubot/config/ConfigTest.kt

@@ -0,0 +1,40 @@
+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,20 +1,18 @@
 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.jfrog.bintray.gradle:gradle-bintray-plugin:$gradle_bintray_plugin_version"
+        classpath libs.buildscript.gh.release
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
     }
 }
 
 allprojects {
     repositories {
-        jcenter()
         mavenCentral()
         mavenLocal()
         maven { url 'https://jitpack.io' }

gradle.properties

@@ -4,17 +4,5 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 
-kotlin_version=1.4.10
-kotlin_coroutines_version=1.4.1
-kotlin_serialisation_runtime_version=1.0.1
-kotlin_exposed_version=0.28.1
-tgbotapi_version=0.30.7
-microutils_version=0.4.1
-klassindex_version=4.1.0-rc.1
-sqlite_version=3.30.1
-
-gradle_bintray_plugin_version=1.8.5
-github_release_plugin_version=2.2.12
-
 group=dev.inmo
-version=0.0.4
+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.0.1"
+
+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.0.1"
+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.7-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/maven.publish.gradle

@@ -1,54 +0,0 @@
-apply plugin: 'maven-publish'
-
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
-
-task javadocJar(type: Jar) {
-    from javadoc
-    classifier = 'javadoc'
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-
-            artifact sourcesJar
-            artifact javadocJar
-
-            pom {
-                resolveStrategy = Closure.DELEGATE_FIRST
-
-                description = ""
-                name = "PlaguBot ${project.name}"
-                url = "https://github.com/InsanusMokrassar/PlaguBot"
-
-                scm {
-                    developerConnection = "scm:git:[fetch=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git[push=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-                    url = "ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-                }
-
-                developers {
-                    
-                        developer {
-                            id = "InsanusMokrassar"
-                            name = "Aleksei Ovsiannikov"
-                            email = "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name = "Apache Software License 2.0"
-                            url = "https://github.com/InsanusMokrassar/PlaguBot/LICENSE"
-                        }
-                    
-                }
-            }
-        }
-    }
-}

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 ${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"}

plugin/publish.gradle

@@ -1,43 +1,81 @@
-apply plugin: 'com.jfrog.bintray'
+apply plugin: 'maven-publish'
 
-ext {
+task javadocJar(type: Jar) {
-    projectBintrayDir = "${project.group}/".replace(".", "/") + "${project.name}/${project.version}"
+    from javadoc
+    classifier = 'javadoc'
+}
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
 }
 
-bintray {
+publishing {
-    user = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
+    publications {
-    key = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
+        maven(MavenPublication) {
-    publications = ["maven"]
+            from components.java
-    filesSpec {
+
-        into "$projectBintrayDir"
+            artifact javadocJar
-        from("build/libs") {
+            artifact sourcesJar
-            include "**/*.asc"
+
-        }
+            pom {
-        from("build/publications/maven") {
+                resolveStrategy = Closure.DELEGATE_FIRST
-            rename 'pom-default.xml(.*)', "${project.name}-${project.version}.pom\$1"
+
-        }
+                description = "Base dependency for whole PlaguBot project"
-    }
+                name = "PlaguBot Plugin"
-    
+                url = "https://github.com/InsanusMokrassar/PlaguBot"
-    publish = true
+
-    override = true
+                scm {
-    
+                    developerConnection = "scm:git:[fetch=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git[push=]ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-    pkg {
+                    url = "ssh://git@github.com/InsanusMokrassar/PlaguBot.git"
-        repo = "PlaguBot"
+                }
-        name = "${project.name}"
+
-        vcsUrl = "https://github.com/InsanusMokrassar/PlaguBot"
+                developers {
-        licenses = ["Apache-2.0"]
+                    
-        version {
+                        developer {
-            name = "${project.version}"
+                            id = "InsanusMokrassar"
-            released = new Date()
+                            name = "Aleksei Ovsiannikov"
-            vcsTag = "${project.version}"
+                            email = "ovsyannikov.alexey95@gmail.com"
-            gpg {
+                        }
-                sign = true
+                    
-                passphrase = project.hasProperty('signing.gnupg.passphrase') ? project.property('signing.gnupg.passphrase') : System.getenv('signing.gnupg.passphrase')
+                }
+
+                licenses {
+                    
+                        license {
+                            name = "Apache Software License 2.0"
+                            url = "https://github.com/InsanusMokrassar/PlaguBot/LICENSE"
+                        }
+                    
+                }
+            }
+            repositories {
+                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://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')
+                        }
+                    }
+                }
             }
         }
     }
 }
 
-apply from: "maven.publish.gradle"
+if (project.hasProperty("signing.gnupg.keyName")) {
-
+    apply plugin: 'signing'
-bintrayUpload.dependsOn publishToMavenLocal
+    
+    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,16 +1,23 @@
 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.KoinApplication
 
 /**
+ * **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 {
     /**
      * In case you want to publish some processed by your plugin commands, you can provide it via this method
@@ -22,10 +29,17 @@ interface Plugin {
     /**
      * This method (usually) will be invoked just one time in the whole application.
      */
-    suspend operator fun invoke(
+    suspend operator fun BehaviourContext.invoke(
-        bot: TelegramBot,
         database: Database,
-        updatesFilter: FlowsUpdatesFilter,
+        koinApplication: KoinApplication,
-        scope: CoroutineScope
+    ) {}
-    )
+
+    /**
+     * This method (usually) will be invoked just one time in the whole application.
+     */
+    suspend operator fun BehaviourContext.invoke(
+        database: Database,
+        koinApplication: KoinApplication,
+        params: JsonObject
+    ) = invoke(database, koinApplication)
 }

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

@@ -0,0 +1,24 @@
+package dev.inmo.plagubot
+
+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
+
+@Serializer(Plugin::class)
+class PluginSerializer : KSerializer<Plugin> {
+    override val descriptor: SerialDescriptor
+        get() = String.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): Plugin {
+        return Class.forName(decoder.decodeString()).getDeclaredConstructor().newInstance() as Plugin
+    }
+
+    override fun serialize(encoder: Encoder, value: Plugin) {
+        encoder.encodeString(
+            value::class.java.canonicalName
+        )
+    }
+}