feat: Rework features as DI.Module and DIScope Submodules

Author: 0ffz

core/src/commonMain/kotlin/com/mineinabyss/features/DI.kt

@@ -1,20 +1,92 @@
 package com.mineinabyss.features
 
+import com.mineinabyss.features.DI.Module
+import com.mineinabyss.features.impl.ModuleImpl
+import com.mineinabyss.features.impl.MutableDIImpl
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
+interface DIAware : AutoCloseable {
+    val di: DI
+
+    override fun close() {
+        di.close()
+    }
+}
+
 /**
  * A dependency injection context, values are evaluated lazily.
  *
  * A value *provider* can never change, though calling [Get] twice may return different values
  * when using a factory provider.
  */
 @FeatureDSLMarker
-interface DI {
+interface DI : DIAware, AutoCloseable {
+    val scope: DIScope
+
+    override val di: DI get() = this
+
     fun <T> Get(type: Pair<KType, String?>): T
-    fun <T> Lazy(type: Pair<KType, String?>): Lazy<T>
+    fun <T> Lazy(type: Pair<KType, String?>): InjectedValue<T>
+
+    fun addCloseable(closeable: AutoCloseable)
 
     val injected: List<Pair<Pair<KType, String?>, InjectedValue<*>>>
+
+    interface Module {
+        val name: String
+        val key: Key
+
+        fun create(parent: DI): DI
+
+        fun override(beforeLoad: MutableDI.() -> Unit): Module
+
+        interface Key
+    }
+
+    fun childDI(): DI {
+        val di = invoke(di.scope) { import(this@DI.di) }
+        addCloseable(di)
+        return di
+    }
+
+    interface ModuleWithConfig<T> : Module {
+        fun get(parent: DI): T
+    }
+
+    companion object {
+        operator fun invoke(scope: DIScope = DIScope(), builder: MutableDI.() -> Unit): DI {
+            return MutableDIImpl(scope).apply(builder)
+        }
+    }
+}
+
+fun module(
+    name: String,
+    block: MutableDI.() -> Unit,
+): Module {
+    return ModuleImpl(name, configure = block)
+}
+
+inline fun DIAware.addCloseable(crossinline closeable: () -> Unit) {
+    di.addCloseable(AutoCloseable { closeable() })
+}
+
+fun <T : AutoCloseable> DIAware.addCloseable(closeable: T): T {
+    di.addCloseable(closeable)
+    return closeable
+}
+
+fun DIAware.addCloseables(vararg closeables: AutoCloseable) {
+    closeables.forEach { addCloseable(it) }
+}
+
+inline fun <reified T> Module.gets(): DI.ModuleWithConfig<T> {
+    return object : DI.ModuleWithConfig<T>, Module by this {
+        override fun get(parent: DI): T {
+            return parent.get<T>()
+        }
+    }
 }
 
 /**
@@ -23,8 +95,35 @@ interface DI {
  * @see DI
  */
 interface MutableDI : DI {
-    fun <T> Put(type: Pair<KType, String?>, property: InjectedValue<T>): Lazy<T>
+    fun <T> Put(type: Pair<KType, String?>, property: InjectedValue<T>): InjectedValue<T>
 
+    /**
+     * Loads a [DI.Module] as a singleton in this DI [scope]. If a module is already loaded, gets the instance.
+     *
+     * Closes this DI context when the included module is unloaded in [scope].
+     */
+    fun singleModule(di: Module): DI
+
+    /**
+     * Loads a [DI.Module] inside this [DI] context, copies dependencies at the point of the call into the submodule,
+     * but does not [import] the submodule's new dependencies into this context.
+     *
+     * Closes the submodule when closing this DI context.
+     *
+     * @see import
+     */
+    fun submodule(di: Module): DI
+
+    /**
+     * Imports all keys from a DI [context] into this context.
+     * Keys can never be overridden, so this may throw an error if the included context contains clashing providers.
+     *
+     * Identical providers do not throw an error, thus a submodule can be included via:
+     *
+     * ```kotlin
+     * import(submodule(other))
+     * ```
+     */
     fun import(context: DI)
 }
 
@@ -33,15 +132,18 @@ interface MutableDI : DI {
  *
  * Immediately throws an error if not already registered.
  */
-inline fun <reified T> DI.get(key: String? = null): T = Get(typeOf<T>() to key)
+inline fun <reified T> DIAware.get(key: String? = null): T = di.Get(typeOf<T>() to key)
+
+//TODO simplify
+inline fun <reified T> DIAware.getOrNull(key: String? = null): T? = runCatching { di.Get<T>(typeOf<T>() to key) }.getOrNull()
 
 /**
  * Gets a value of type [T], optionally keyed by [key] as a delegate.
  * Only evaluates when first read.
  *
  * Immediately throws an error if not already registered.
  */
-inline fun <reified T> DI.getLazy(key: String? = null): Lazy<T> = Lazy(typeOf<T>() to key)
+inline fun <reified T> DIAware.getLazy(key: String? = null): InjectedValue<T> = di.Lazy(typeOf<T>() to key)
 
 /**
  * Registers a value of type [T], optionally keyed by [key].
@@ -53,9 +155,9 @@ inline fun <reified T> MutableDI.single(
     key: String? = null,
     ignoreOverride: Boolean = false,
     crossinline block: DI.() -> T,
-): Lazy<T> = Put(
+): InjectedValue<T> = Put(
     typeOf<T>() to key,
-    InjectedValue(ignoreOverride, lazy { block() })
+    InjectedValueImpl(ignoreOverride, lazy { block() })
 )
 
 /**
@@ -69,10 +171,10 @@ inline fun <reified T> MutableDI.factory(
     key: String? = null,
     ignoreOverride: Boolean = false,
     noinline block: DI.() -> T,
-): Lazy<T> {
+): InjectedValue<T> {
     return Put(
         typeOf<T>() to key,
-        InjectedValue(ignoreOverride, object : Lazy<T> {
+        InjectedValueImpl(ignoreOverride, object : Lazy<T> {
             override val value: T get() = block()
 
             override fun isInitialized(): Boolean = false
@@ -81,6 +183,6 @@ inline fun <reified T> MutableDI.factory(
 }
 
 context(context: MutableDI)
-inline fun <reified R> Lazy<R>.and(): Lazy<R> {
-    return context.single<R> { this@and.value }
+inline fun <reified R> InjectedValue<R>.and(): InjectedValue<R> {
+    return context.single<R>(ignoreOverride = ignoreOverride) { this@and.value }
 }

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

@@ -0,0 +1,82 @@
+package com.mineinabyss.features
+
+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>()
+
+    val root = DI.invoke(this) {
+        single<DIScope>(ignoreOverride = true) { this@DIScope }
+        single<Logger>(ignoreOverride = true) { Logger }
+        root()
+    }
+    override val di: DI = this.root
+
+    val logger by getLazy<Logger>()
+
+    fun <T> load(feature: DI.ModuleWithConfig<T>, configure: T.() -> Unit): DI {
+        return load(module("$feature-configuration") {
+            feature.get(singleModule(feature)).configure()
+        })
+    }
+
+    fun load(feature: DI.Module): DI {
+        val key = feature.key
+        if (key in _loaded) return _loaded.getValue(key)
+        return loadCatching(feature).getOrThrow()
+    }
+
+    fun loadCatching(feature: DI.Module): Result<DI> {
+        val key = feature.key
+        if (key in _loaded) return Result.success(_loaded.getValue(key))
+        return runCatching { feature.create(root) }.onSuccess {
+            _loaded[key] = it
+            it.addCloseable { _loaded.remove(key) }
+            logger.i { "Loaded feature $feature" }
+        }.onFailure {
+            if (it is IllegalArgumentException) {
+                logger.e { "Failed to load feature $feature: ${it.message}" }
+            } else {
+                logger.e(it) { "Failed to load feature $feature" }
+            }
+        }
+    }
+
+    fun loadAll(vararg modules: DI.Module) {
+        modules.forEach { load(it) }
+    }
+
+    fun loadAllCatching(vararg modules: DI.Module) {
+        modules.forEach { loadCatching(it) }
+    }
+
+    operator fun get(module: DI.Module): DI? {
+        return _loaded[module.key]?.di
+    }
+
+    operator fun <T> get(module: DI.ModuleWithConfig<T>): T? {
+        return _loaded[module.key]?.di?.let { module.get(it) }
+    }
+
+    fun unload(feature: DI.Module) {
+        val key = feature.key
+        val feat = _loaded[key] ?: return
+        runCatching { feat.close() }.onSuccess {
+            logger.i { "Loaded feature $feature" }
+        }.onFailure {
+            logger.e(it) { "Failed to unload $feature" }
+        }
+        _loaded.remove(key)
+    }
+
+    override fun close() {
+        _loaded.toList().reversed().forEach { unload(it.first as DI.Module) } //TODO no cast
+    }
+
+    companion object {
+        fun new(builder: MutableDI.() -> Unit = {}): DIScope {
+            return DIScope(builder)
+        }
+    }
+}

core/src/commonMain/kotlin/com/mineinabyss/features/Feature.kt

@@ -2,15 +2,3 @@ package com.mineinabyss.features
 
 @DslMarker
 annotation class FeatureDSLMarker
-
-@FeatureDSLMarker
-interface FeatureDSL
-//
-//fun feature(name: String, block: FeatureBuilder.() -> Unit): Feature<Unit> {
-//    return FeatureBuilder(name, Unit::class).apply(block).build(extract = { })
-//}
-//
-//@JvmName("featureWithType")
-//inline fun <reified T : Any> feature(name: String, block: FeatureBuilder.() -> Unit): Feature<T> {
-//    return FeatureBuilder(name, T::class).apply(block).build(extract = { instance<T>() })
-//}