Merge pull request #25 from InsanusMokrassar/0.5.1

0.5.1

CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 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`

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

@@ -41,3 +41,8 @@ kapt {
     }
 }
 
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+

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

@@ -5,18 +5,6 @@ import kotlinx.coroutines.*
 import kotlinx.serialization.InternalSerializationApi
 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 +12,7 @@ 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 config = configAndPluginsConfigJsonFormat.decodeFromString(PluginsConfigurationSerializer, file.readText()) as Config
 
     PlaguBot(config).start().join()
 }

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

@@ -1,12 +1,10 @@
 package dev.inmo.plagubot
 
 import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
-import dev.inmo.plagubot.config.Config
+import dev.inmo.plagubot.config.*
-import dev.inmo.plagubot.config.database
 import dev.inmo.tgbotapi.bot.Ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviour
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.botCommandsLimit
 import kotlinx.coroutines.*
@@ -20,6 +18,7 @@ val Map<String, Any>.plagubot
 
 @Serializable
 data class PlaguBot(
+    @Serializable(PluginsConfigurationSerializer::class)
     private val config: Config
 ) : Plugin {
     @Transient
@@ -50,7 +49,7 @@ data class PlaguBot(
      */
     suspend fun start(
         scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-    ): Job = bot.buildBehaviour(scope) {
+    ): 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,166 +1,15 @@
 package dev.inmo.plagubot.config
 
-import com.github.matfax.klassindex.KlassIndex
 import dev.inmo.plagubot.Plugin
-import dev.inmo.plagubot.PluginSerializer
+import dev.inmo.sdi.Module
-import dev.inmo.sdi.*
+import kotlinx.serialization.Contextual
-import kotlinx.serialization.*
+import kotlinx.serialization.Serializable
-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>,
+    override val plugins: List<@Contextual Plugin>,
     val database: DatabaseConfig = DatabaseConfig(),
     val botToken: String,
     @Contextual
-    val params: Module? = null
+    override val params: Module? = null
-)
+) : PluginsConfiguration
-
-@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/PluginsConfiguration.kt

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

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

@@ -22,13 +22,16 @@ class ConfigTest {
               }
             }
         """.trimIndent()
-        val config = configJsonFormat.decodeFromString(ConfigSerializer, rawConfig)
+        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 = configJsonFormat.decodeFromString(ConfigSerializer, configJsonFormat.encodeToString(ConfigSerializer, config))
+        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)

gradle.properties

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

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.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

plugin/build.gradle

@@ -15,3 +15,8 @@ dependencies {
     api "dev.inmo:tgbotapi:$tgbotapi_version"
     api "dev.inmo:micro_utils.repos.exposed:$microutils_version"
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

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

@@ -15,7 +15,7 @@ object PluginSerializer : KSerializer<Plugin> {
     private val polymorphic = PolymorphicSerializer(Plugin::class)
     override val descriptor: SerialDescriptor = JsonObject.serializer().descriptor
 
-    @InternalSerializationApi
+    @OptIn(InternalSerializationApi::class)
     override fun deserialize(decoder: Decoder): Plugin {
         val format = (decoder as? JsonDecoder) ?.json ?: defaultJson
         val asJson = JsonElement.serializer().deserialize(decoder)
@@ -45,9 +45,9 @@ object PluginSerializer : KSerializer<Plugin> {
         }
     }
 
-    @InternalSerializationApi
+    @OptIn(InternalSerializationApi::class)
     override fun serialize(encoder: Encoder, value: Plugin) {
         val serializer = (value::class.serializerOrNull() ?: polymorphic) as KSerializer<Plugin>
         serializer.serialize(encoder, value)
     }
-}
+}