1.2

- kommand-libの外部化
- ビルド設定の見直し

build.gradle.kts

@@ -1,14 +1,14 @@
-import net.minecrell.pluginyml.bukkit.BukkitPluginDescription
+import net.minecrell.pluginyml.paper.PaperPluginDescription
 
 group = "net.hareworks"
-version = "1.1"
+version = "1.2"
 
 val exposedVersion = "0.54.0"
 
 plugins {
-    kotlin("jvm") version "2.0.20"
+    kotlin("jvm") version "2.2.21"
-    kotlin("plugin.serialization") version "2.0.20"
+    kotlin("plugin.serialization") version "2.2.21"
-    id("net.minecrell.plugin-yml.bukkit") version "0.6.0"
+    id("de.eldoria.plugin-yml.paper") version "0.8.0"
     id("com.gradleup.shadow") version "9.2.2"
 }
 repositories {
@@ -18,6 +18,8 @@ repositories {
 }
 dependencies {
     compileOnly("io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT")
+    compileOnly("org.jetbrains.kotlin:kotlin-stdlib")
+    compileOnly("net.hareworks:kommand-lib:1.1")
     implementation("net.kyori:adventure-api:4.17.0")
     implementation("net.kyori:adventure-text-minimessage:4.17.0")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1")
@@ -28,78 +30,34 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
     implementation("org.jetbrains.exposed:exposed-kotlin-datetime:$exposedVersion")
     implementation("de.tr7zw:item-nbt-api:2.15.3")
-    implementation("com.michael-bull.kotlin-result:kotlin-result:2.0.0")
 }
 tasks {
     shadowJar {
+        minimize()
         archiveBaseName.set("SimplyMCDB")
         archiveClassifier.set("")
         relocate("de.tr7zw.changeme.nbtapi", "net.hareworks.simplymcdb.libs.nbtapi")
     }
-
+    jar {
-    build {
+        enabled = false
-        dependsOn(shadowJar)
     }
 }
 
-bukkit {
+paper {
     main = "net.hareworks.simplymcdb.App"
     name = "Simply-Minecraft-DB"
     description = "It provides a simple way to manage player data through a database."
     version = getVersion().toString()
 	apiVersion = "1.21.10"
-    authors =
+    authors = listOf(
-            listOf("Hare-K02")
+        "Hare-K02"
-    permissions {
-        register("simplydb.*") {
-            children = listOf("simplydb.command", "simplydb.admin")
-        }
-        register("simplydb.command") {
-            description = "Allows access to the /simplydb command"
-            default = BukkitPluginDescription.Permission.Default.TRUE
-        }
-        register("simplydb.command.*") {
-            children = listOf(
-                "simplydb.command.config",
-                "simplydb.command.config.*",
-                "simplydb.command.on",
-                "simplydb.command.off",
     )
+    serverDependencies {
+        register("kommand-lib") {
+            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
         }
-        register("simplydb.command.config") {
+        register("permits-lib") {
-            description = "Allows access to the /simplydb config command"
+            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-            default = BukkitPluginDescription.Permission.Default.OP
-        }
-        register("simplydb.command.config.*") {
-            children = listOf(
-                "simplydb.command.config.reload",
-                "simplydb.command.config.fetch",
-                "simplydb.command.config.upload",
-            )
-        }
-        register("simplydb.command.config.reload") {
-            description = "Allows access to the /simplydb config reload command"
-            default = BukkitPluginDescription.Permission.Default.OP
-        }
-        register("simplydb.command.config.fetch") {
-            description = "Allows access to the /simplydb config fetch command"
-            default = BukkitPluginDescription.Permission.Default.OP
-        }
-        register("simplydb.command.config.upload") {
-            description = "Allows access to the /simplydb config upload command"
-            default = BukkitPluginDescription.Permission.Default.OP
-        }
-        register("simplydb.command.on") {
-            description = "Allows access to the /simplydb on command"
-            default = BukkitPluginDescription.Permission.Default.OP
-        }
-        register("simplydb.command.off") {
-            description = "Allows access to the /simplydb off command"
-            default = BukkitPluginDescription.Permission.Default.OP
-        }
-        register("simplydb.admin") {
-            description = "Allows configration/manage simplydb"
-            default = BukkitPluginDescription.Permission.Default.OP
         }
     }
 }

flake.nix

@@ -36,10 +36,6 @@
             export PATH="$JAVA_HOME/bin:$PATH"
 
             export GRADLE_USER_HOME="$PWD/.gradle"
-
-            echo "Loaded Minecraft dev env (JDK 21 + Gradle)"
-            java -version || true
-            gradle --version || true
           '';
         };
       }

gradle.properties

@@ -0,0 +1 @@
+kotlin.stdlib.default.dependency=false

settings.gradle.kts

@@ -0,0 +1,3 @@
+rootProject.name = "simply-mcdb"
+
+includeBuild("../kommand-lib")

src/main/kotlin/net/hareworks/kommandlib/main.kt

@@ -1,147 +0,0 @@
-package net.hareworks.kommandlib
-
-import com.github.michaelbull.result.*
-import kotlin.collections.listOf
-import org.bukkit.Bukkit
-import org.bukkit.command.CommandMap
-import org.bukkit.command.CommandSender
-import org.bukkit.command.PluginCommand
-import org.bukkit.command.TabCompleter
-import org.bukkit.plugin.java.JavaPlugin
-import net.hareworks.simplymcdb.App
-
-class KommandLib(plugin: JavaPlugin, vararg routes: Argument) {
-  val entries = routes.toList()
-  init {
-    val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
-    f.isAccessible = true
-    val commandMap = f.get(Bukkit.getServer()) as CommandMap
-    for (route in routes) {
-      commandMap.register(
-              plugin.getName(),
-              (PluginCommand::class
-                              .java
-                              .declaredConstructors
-                              .first()
-                              .apply { isAccessible = true }
-                              .newInstance(route.name, plugin) as
-                              PluginCommand)
-                      .apply {
-                        this.name = name
-                        this.setExecutor { sender, _, alias, args ->
-                          val routeargs = routeTreeSearch(arrayOf(alias, *args))
-                          if (routeargs.size == args.size + 1)
-                                  routeargs.last().onCommand(sender, args)
-                          true
-                        }
-                        this.tabCompleter = TabCompleter { sender, _, alias, args ->
-                          val routeargs = routeTreeSearch(arrayOf(alias, *args))
-                          if (routeargs.size == args.size)
-                                  routeargs.last().getCompletList(sender, args)
-                          else listOf()
-                        }
-                      }
-      )
-    }
-  }
-
-  fun routeTreeSearch(args: Array<String>): List<Argument> {
-    val list =
-            mutableListOf<Argument>(
-                    entries.find { it.name == args[0] } ?: throw Exception("Invalid command")
-            )
-    var i = 1
-    while (i + 1 <= args.size) {
-      if (list.last().routes.isEmpty()) break
-      val route = list.last().routes.sortedBy { it.priority }.find { it.name == args[i] } ?: break
-      list.add(route)
-      i += route.unit
-    }
-    return list
-  }
-
-  fun unregister() {
-    val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
-    f.isAccessible = true
-    val commandMap = f.get(Bukkit.getServer()) as CommandMap
-    for (route in entries) {
-      commandMap.getCommand(route.name)?.unregister(commandMap)
-    }
-  }
-}
-
-abstract class Argument(
-        val argname: String,
-        vararg routes: Argument,
-        val execute: (CommandSender, Array<String>) -> Unit
-) {
-  val name = argname
-  var routes = routes.toList()
-  var permission: String = ""
-    set(value) {
-      field = value
-      if (value.isEmpty()) return
-      for (route in routes) {
-        route.permission = value + "." + route.name
-      }
-    }
-  var condition: (CommandSender) -> Boolean = { true }
-
-  public fun addArgs(vararg routes: Argument): Argument {
-    this.routes += routes
-    return this
-  }
-
-  abstract var priority: Int
-  open var unit: Int = 1
-  open fun onCommand(sender: CommandSender, args: Array<String>) {
-    execute(sender, args)
-  }
-
-  abstract fun suggest(sender: CommandSender, args: Array<String>): List<String>
-
-  fun getCompletList(sender: CommandSender, args: Array<String>): List<String> {
-    return routes
-            .filter { sender.hasPermission(it.permission) && it.condition(sender) }
-            .map { it.suggest(sender, args) }
-            .flatten()
-  }
-}
-
-class Route(
-        name: String,
-        vararg routes: Argument,
-        execute: (CommandSender, Array<String>) -> Unit
-) : Argument(name, *routes, execute = execute) {
-  override var priority: Int = 2
-
-  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
-    return if (sender.hasPermission(this.permission) &&
-                    this.condition(sender) &&
-                    this.name.startsWith(args.last())
-    )
-            listOf(this.name)
-    else listOf()
-  }
-}
-
-class Text(name: String, vararg routes: Argument, execute: (CommandSender, Array<String>) -> Unit) :
-        Argument(name, *routes, execute = execute) {
-  override var priority: Int = 0
-
-  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
-    return listOf(args.last())
-  }
-}
-
-class Integer(
-        name: String,
-        vararg routes: Argument,
-        execute: (CommandSender, Array<String>) -> Unit
-) : Argument(name, *routes, execute = execute) {
-  override var priority: Int = 1
-
-  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
-    return listOf()
-  }
-}

src/main/kotlin/net/hareworks/simplymcdb/App.kt

@@ -1,7 +1,7 @@
 package net.hareworks.simplymcdb
 
-import net.hareworks.kommandlib.KommandLib
+import net.hareworks.kommand_lib.KommandLib
-import net.hareworks.simplymcdb.command.smcdb
+import net.hareworks.simplymcdb.command.registerCommands
 import net.hareworks.simplymcdb.database.Database
 import org.bukkit.plugin.java.JavaPlugin
 
@@ -30,7 +30,7 @@ public class App : JavaPlugin() {
   override fun onEnable() {
     instance = this
     Config.init()
-    command = KommandLib(this, smcdb)
+    command = registerCommands(this)
 
     server.pluginManager.registerEvents(EventListener, this)
 

src/main/kotlin/net/hareworks/simplymcdb/Command.kt

@@ -1,287 +1,267 @@
 package net.hareworks.simplymcdb.command
 
-import com.github.michaelbull.result.*
+import java.util.UUID
-import net.hareworks.kommandlib.*
+import net.hareworks.kommand_lib.KommandLib
-import net.hareworks.simplymcdb.*
+import net.hareworks.kommand_lib.kommand
+import net.hareworks.simplymcdb.App
+import net.hareworks.simplymcdb.Config
+import net.hareworks.simplymcdb.State
 import net.hareworks.simplymcdb.database.Database
+import net.hareworks.simplymcdb.fetch
+import net.hareworks.simplymcdb.findPlayersNeedingMigration
+import net.hareworks.simplymcdb.isRegistered
+import net.hareworks.simplymcdb.overwritePlayerData
+import net.hareworks.simplymcdb.register
+import net.hareworks.simplymcdb.update
+import net.hareworks.simplymcdb.PlayerSerializer
 import net.kyori.adventure.audience.Audience
 import net.kyori.adventure.text.minimessage.MiniMessage
 import org.bukkit.entity.Player
+import org.bukkit.plugin.java.JavaPlugin
+
+private val miniMessage = MiniMessage.miniMessage()
+private val commandBuffer = mutableMapOf<UUID, String>()
 
 public fun Audience.sendMM(message: String) {
-  this.sendMessage(MiniMessage.miniMessage().deserialize(message))
+  this.sendMessage(miniMessage.deserialize(message))
 }
 
-val command_buffer = mutableMapOf<java.util.UUID, String>()
+private fun Audience.sendConfigHelp() {
-public val smcdb =
+  sendMM(
-        Route("smcdb") { sender, _ -> sender.sendMessage("simptlymcdb command") }
+      "<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database")
-                .addArgs(
+}
-                        Route("config") { sender, _ ->
+
-                                  (sender as Player).performCommand("smcdb config help")
+public fun registerCommands(plugin: JavaPlugin): KommandLib =
+    kommand(plugin) {
+      command("smcdb") {
+        description = "Control Simply-Minecraft-DB"
+        permission = "simplydb.command"
+
+        executes {
+          sender.sendMessage("simplymcdb command")
         }
-                                .addArgs(
+
-                                        Route("reload") { sender, _ ->
+        literal("config") {
+          requires("simplydb.command.config")
+          executes { sender.sendConfigHelp() }
+
+          literal("reload") {
+            requires("simplydb.command.config.reload")
+            executes {
               sender.sendMessage("reloading config...")
               Config.reload()
               sender.sendMessage("reloaded.")
-                                        },
-                                        Route("fetch") { sender, _ ->
-                                          sender.sendMessage("fetching config...")
-                                        },
-                                        Route("upload") { sender, _ ->
-                                          sender.sendMessage("uploading config...")
-                                        },
-                                        Route("help") { sender, _ ->
-                                          var help =
-                                                  MiniMessage.miniMessage()
-                                                          .deserialize(
-                                                                  "<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database"
-                                                          )
-                                          sender.sendMessage(help)
             }
-                                ),
+          }
-                        Route("help") { sender, _ ->
+
+          literal("fetch") {
+            requires("simplydb.command.config.fetch")
+            executes { sender.sendMessage("fetching config...") }
+          }
+
+          literal("upload") {
+            requires("simplydb.command.config.upload")
+            executes { sender.sendMessage("uploading config...") }
+          }
+
+          literal("help") { executes { sender.sendConfigHelp() } }
+        }
+
+        literal("help") {
+          executes {
             sender.sendMM(
-                                  "<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it"
+                "<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it")
-                          )
+          }
-                        },
+        }
-                        Route("activate") { sender, _ ->
+
+        literal("activate") {
+          requires("simplydb.command.on")
+          executes {
             if (App.instance.enabled == State.ACTIVE) {
               sender.sendMessage("simplymcdb is already enabled.")
-                            return@Route
+              return@executes
             }
             App.instance.enable()
             sender.sendMessage("simplymcdb enabled.")
-                        },
+          }
-                        Route("deactivate") { sender, _ ->
+        }
+
+        literal("deactivate") {
+          requires("simplydb.command.off")
+          executes {
             if (App.instance.enabled == State.DISABLED) {
               sender.sendMessage("simplymcdb is already disabled.")
-                            return@Route
+              return@executes
             }
             App.instance.disable()
             sender.sendMessage("simplymcdb disabled.")
-                        },
+          }
-                        Route("database") { _, _ -> }
+        }
-                                .addArgs(
+
-                                        Route("init") { sender, _ ->
+        literal("database") {
+          literal("init") {
+            executes {
               Database.initialize()
               sender.sendMessage("database initialized.")
-                                        },
+            }
-                                        Route("reset") { sender, _ ->
+          }
+          literal("reset") {
+            executes {
               Database.reset()
               sender.sendMessage("database reset.")
-                                        },
+            }
-                                ),
+          }
-                        Route("migrate") { sender, _ ->
+        }
-                          if (sender !is Player) {
+
+        literal("migrate") {
+          executes {
+            val player = sender as? Player
+            if (player == null) {
               sender.sendMM("<red>[SMCDB] This command can only be run by players.")
-                            return@Route
+              return@executes
             }
             when (App.instance.enabled) {
               State.DISABLED -> {
                 sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
-                              return@Route
+                return@executes
               }
               State.DISCONNECTED -> {
                 sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
-                              return@Route
+                return@executes
               }
               else -> {}
             }
-                          if (!isRegistered(sender.uniqueId)) {
+            if (!isRegistered(player.uniqueId)) {
               sender.sendMM("<red>[SMCDB] You are not registered in the database.")
-                            return@Route
+              return@executes
             }
             try {
               sender.sendMM("<gray>[SMCDB] Applying legacy data...")
-                            fetch(sender)
+              fetch(player)
-                            update(sender)
+              update(player)
               sender.sendMM("<green>[SMCDB] Migration complete. Data updated to the latest format.")
             } catch (e: Exception) {
-                            App.instance.logger.warning("Failed to migrate data for ${sender.uniqueId}: ${e.message}")
+              App.instance.logger.warning("Failed to migrate data for ${player.uniqueId}: ${e.message}")
               sender.sendMM("<red>[SMCDB] Migration failed. Check server logs.")
             }
-                        }.addArgs(
+          }
-                                Route("all") { sender, _ ->
+
-                                  if (sender !is Player) {
+          literal("all") {
+            executes {
+              val executor = sender as? Player
+              if (executor == null) {
                 sender.sendMM("<red>[SMCDB] This command can only be run by players.")
-                                    return@Route
+                return@executes
               }
               when (App.instance.enabled) {
                 State.DISABLED -> {
                   sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
-                                      return@Route
+                  return@executes
                 }
                 State.DISCONNECTED -> {
-                                      sender.sendMM(
+                  sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
-                                              "<yellow>[SMCDB] Database disconnected. Try again later."
+                  return@executes
-                                      )
-                                      return@Route
                 }
                 else -> {}
               }
               val targets = findPlayersNeedingMigration()
               if (targets.isEmpty()) {
                 sender.sendMM("<gray>[SMCDB] No legacy data found.")
-                                    return@Route
+                return@executes
               }
-                                  sender.sendMM(
+              sender.sendMM("<gray>[SMCDB] Migrating ${targets.size} legacy profiles... Please wait.")
-                                          "<gray>[SMCDB] Migrating ${targets.size} legacy profiles... Please wait."
+              val backup = PlayerSerializer.serialize(executor)
-                                  )
-                                  val backup = PlayerSerializer.serialize(sender)
               var migrated = 0
               try {
                 targets.forEach { entry ->
                   try {
-                                        PlayerSerializer.deserialize(sender, entry.serialized)
+                    PlayerSerializer.deserialize(executor, entry.serialized)
-                                        val updatedSnapshot = PlayerSerializer.serialize(sender)
+                    val updatedSnapshot = PlayerSerializer.serialize(executor)
                     overwritePlayerData(entry.uuid, updatedSnapshot)
                     migrated++
                   } catch (ex: Exception) {
-                                        App.instance.logger.warning(
+                    App.instance.logger.warning("Failed to migrate data for ${entry.uuid}: ${ex.message}")
-                                                "Failed to migrate data for ${entry.uuid}: ${ex.message}"
-                                        )
                   }
                 }
               } finally {
                 try {
-                                      PlayerSerializer.deserialize(sender, backup)
+                  PlayerSerializer.deserialize(executor, backup)
                 } catch (restoreEx: Exception) {
-                                      App.instance.logger.warning(
+                  App.instance.logger.warning("Failed to restore migration executor state: ${restoreEx.message}")
-                                              "Failed to restore migration executor state: ${restoreEx.message}"
-                                      )
                 }
               }
-                                  sender.sendMM(
+              sender.sendMM("<green>[SMCDB] Migration finished ($migrated/${targets.size}). Check logs for failures.")
-                                          "<green>[SMCDB] Migration finished ($migrated/${targets.size}). Check logs for failures."
-                                  )
             }
-                        ),
+          }
-                        Route("check") { sender, _ ->
+        }
+
+        literal("check") {
+          executes {
             sender.sendMM(
                 "${when (App.instance.enabled) {
                   State.ACTIVE -> "<green>●"
                   State.DISCONNECTED -> "<yellow>■"
                   State.DISABLED -> "<red>○"
-                                            }}<white> simply-minecraft-database"
+                }}<white> simply-minecraft-database")
-                          )
             sender.sendMM(
                 "status: ${when (App.instance.enabled) {
                   State.ACTIVE -> "<green>active"
                   State.DISCONNECTED -> "<yellow>disconnected"
-                                                          State.DISABLED -> "<red>disabled"}}"
+                  State.DISABLED -> "<red>disabled"
-                          )
+                }}")
             sender.sendMM(
-                                  "<gray>- <white>database test: ${if (Database.ping()) "success" else "failed"}"
+                "<gray>- <white>database test: ${if (Database.ping()) "success" else "failed"}")
-                          )
             sender.sendMM(
-                                  "<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}"
+                "<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}")
-                          )
+          }
-                        },
+        }
-                        Route("register") { sender, _ ->
+
-                          if (sender !is Player) {
+        literal("register") {
+          executes {
+            val player = sender as? Player
+            if (player == null) {
               sender.sendMM("This command is only available for players.")
-                            return@Route
+              return@executes
-                          } else
+            }
             when (App.instance.enabled) {
-                                    State.DISABLED ->
+              State.DISABLED -> {
-                                            sender.sendMM(
+                sender.sendMM("<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status.")
-                                                    "<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status."
+                return@executes
-                                            )
+              }
-                                    State.DISCONNECTED ->
+              State.DISCONNECTED -> {
-                                            sender.sendMM(
+                sender.sendMM("<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status.")
-                                                    "<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status."
+                return@executes
-                                            )
+              }
-                                    else -> {
+              else -> {}
-                                      if (!isRegistered(sender.uniqueId)) {
+            }
+            if (!isRegistered(player.uniqueId)) {
               sender.sendMM(
                   "<gray>[SMCDB] <red>The inventory of the other servers will be overwritten.<newline>" +
                       "Are you sure you want to register?<newline>" +
-                                                        "<green>/smcdb confirm<gray> to confirm."
+                      "<green>/smcdb confirm<gray> to confirm.")
-                                        )
+              commandBuffer[player.uniqueId] = "register"
             } else {
               sender.sendMM("<gray>[SMCDB] You are already registered.")
             }
           }
         }
-                        },
+
-                        Route("confirm") { sender, _ ->
+        literal("confirm") {
-                          if (sender !is Player) return@Route
+          executes {
-                          when (command_buffer[sender.uniqueId]) {
+            val player = sender as? Player ?: return@executes
+            when (commandBuffer[player.uniqueId]) {
               "register" -> {
                 if (App.instance.enabled == State.ACTIVE) {
-                                register(sender)
+                  register(player)
                   sender.sendMM("<gray>[SMCDB] Successfully registered.")
                 } else {
                   sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
                 }
               }
-                            else -> {
+              else -> sender.sendMM("<red>[SMCDB] Invalid command.")
-                              sender.sendMM("<red>[SMCDB] Invalid command.")
+            }
+            commandBuffer.remove(player.uniqueId)
+          }
         }
       }
-                          command_buffer.remove(sender.uniqueId)
     }
-                        // Route("update") { sender, _ ->
-                        //   if (sender !is Player) {
-                        //     sender.sendMM("This command is only available for players.")
-                        //     return@Route
-                        //   } else
-                        //           when (App.instance.enabled) {
-                        //             State.DISABLED ->
-                        //                     sender.sendMM(
-                        //                             "<red>[SMCDB] simplymcdb is disabled.<br>Run
-                        // /smcdb check to check the status."
-                        //                     )
-                        //             State.DISCONNECTED ->
-                        //                     sender.sendMM(
-                        //                             "<red>[SMCDB] simplymcdb is enabled but
-                        // disconnected.<br>Run /smcdb check to check the status."
-                        //                     )
-                        //             else -> {
-                        //               if (isRegistered(sender.uniqueId)) {
-                        //                 update(sender)
-                        //                 sender.sendMM("<gray>[SMCDB] Successfully updated.")
-                        //               } else {
-                        //                 sender.sendMM("<red>[SMCDB] You are not registered.")
-                        //               }
-                        //             }
-                        //           }
-                        // },
-                        // Route("fetch") { sender, _ ->
-                        //   if (sender !is Player) {
-                        //     sender.sendMM("This command is only available for players.")
-                        //     return@Route
-                        //   } else
-                        //           when (App.instance.enabled) {
-                        //             State.DISABLED ->
-                        //                     sender.sendMM(
-                        //                             "<red>[SMCDB] simplymcdb is disabled.<br>Run
-                        // /smcdb check to check the status."
-                        //                     )
-                        //             State.DISCONNECTED ->
-                        //                     sender.sendMM(
-                        //                             "<red>[SMCDB] simplymcdb is enabled but
-                        // disconnected.<br>Run /smcdb check to check the status."
-                        //                     )
-                        //             else -> {
-                        //               if (isRegistered(sender.uniqueId)) {
-                        //                 sender.sendMM(
-                        //                         "<gray>[SMCDB] Welcome back,
-                        // ${sender.name}.<newline>Fetching your data..."
-                        //                 )
-                        //                 fetch(sender)
-                        //               } else {
-                        //                 sender.sendMM(
-                        //                         "<gray>[SMCDB] Welcome, ${sender.name}.<newline>"
-                        // +
-                        //                                 "SMCDB is active but you have already
-                        // played before.<newline>" +
-                        //                                 "Run <green>/smcdb register<gray> to
-                        // register yourself."
-                        //                 )
-                        //               }
-                        //             }
-                        //           }
-                        // },
-                        )