feat: Reloadable modules in DIScope

fix: Make di close idempotent

Author: 0ffz

core/src/commonMain/kotlin/com/mineinabyss/dependencies/DIScope.kt

@@ -4,7 +4,8 @@ import co.touchlab.kermit.Logger
 
 class DIScope(root: MutableDI.() -> Unit = {}) : DIAware, AutoCloseable {
     private val _loaded = mutableMapOf<DI.Module.Key, DI>()
-    val loaded: List<DI.Module> = _loaded.keys.filterIsInstance<DI.Module>()
+    private val loadOrder = mutableListOf<DI.Module>()
+    val loaded: List<DI.Module> get() = loadOrder.toList()
 
     val root = DI.invoke(this) {
         single<DIScope>(ignoreOverride = true) { this@DIScope }
@@ -15,7 +16,7 @@ class DIScope(root: MutableDI.() -> Unit = {}) : DIAware, AutoCloseable {
     val logger by lazy { getOrNull<Logger>() ?: Logger }
 
     fun <T> load(feature: DI.ModuleWithConfig<T>, configure: T.() -> Unit): DI {
-        return load(module("$feature-configuration") {
+        return load(module("${feature.name}-configuration") {
             feature.get(singleModule(feature)).configure()
         })
     }
@@ -25,14 +26,18 @@ class DIScope(root: MutableDI.() -> Unit = {}) : DIAware, AutoCloseable {
         if (key in _loaded) return _loaded.getValue(key)
         val created = feature.create(root)
         _loaded[key] = created
-        created.addCloseable { _loaded.remove(key) }
+        loadOrder += feature
+        created.addCloseable {
+            _loaded.remove(key)
+            loadOrder.remove(feature)
+            logger.i { "Unloaded feature $feature" }
+        }
+        logger.i { "Loaded feature $feature" }
         return created
     }
 
     fun loadCatching(feature: DI.Module): Result<DI> {
-        return runCatching { load(feature) }.onSuccess {
-            logger.i { "Loaded feature $feature" }
-        }.onFailure {
+        return runCatching { load(feature) }.onFailure {
             if (it is IllegalArgumentException) {
                 logger.e { "Failed to load feature $feature: ${it.message}" }
             } else {
@@ -49,6 +54,25 @@ class DIScope(root: MutableDI.() -> Unit = {}) : DIAware, AutoCloseable {
         modules.forEach { loadCatching(it) }
     }
 
+    fun reload(module: DI.Module) {
+        val beforeUnload = loadOrder.toList()
+        unload(module)
+        val unloadedDependencies = beforeUnload.minus(loadOrder.toSet())
+        loadAll(*unloadedDependencies.toTypedArray())
+    }
+
+    fun reload(vararg module: DI.Module) {
+        val beforeUnload = loadOrder.toList()
+        module.forEach { unload(it) }
+        val unloadedDependencies = beforeUnload.minus(loadOrder.toSet())
+        loadAll(*unloadedDependencies.toTypedArray())
+    }
+
+    fun reloadAll() {
+        val load = loadOrder.toTypedArray()
+        unloadAll()
+        loadAll(*load)
+    }
     operator fun get(module: DI.Module): DI? {
         return _loaded[module.key]?.di
     }
@@ -60,16 +84,15 @@ class DIScope(root: MutableDI.() -> Unit = {}) : DIAware, AutoCloseable {
     fun unload(feature: DI.Module) {
         val key = feature.key
         val feat = _loaded[key] ?: return
-        runCatching { feat.close() }.onSuccess {
-            logger.i { "Unloaded feature $feature" }
-        }.onFailure {
-            logger.e(it) { "Failed to unload $feature" }
-        }
-        _loaded.remove(key)
+        feat.close()
+    }
+
+    fun unloadAll() {
+        loadOrder.toList().reversed().forEach { unload(it) }
     }
 
     override fun close() {
-        _loaded.toList().reversed().forEach { unload(it.first as DI.Module) } //TODO no cast
+        unloadAll()
     }
 
     companion object {

core/src/commonMain/kotlin/com/mineinabyss/dependencies/impl/MutableDIImpl.kt

@@ -11,6 +11,7 @@ class MutableDIImpl(
     private val dependsOn = mutableSetOf<DI.Module>()
     private val _injected = mutableMapOf<Pair<KType, String?>, InjectedValue<*>>()
     override val injected get() = _injected.map { it.key to it.value }
+    private var closed = false
 
     override fun <T> Put(type: Pair<KType, String?>, property: InjectedValue<T>): InjectedValue<T> {
         val existing = _injected[type]
@@ -58,6 +59,8 @@ class MutableDIImpl(
     }
 
     override fun close() {
+        if (closed) return
+        closed = true
         closeables.reversed().forEach { it.close() }
     }
 }