feat(#821): make bridgesystem more robust with kType

Author: osoykan

docs/release-notes/0.20.0.md

@@ -8,6 +8,8 @@ This release introduces:
 - **Unified Spring Modules**: Single modules that work across Spring Boot 2.x, 3.x, and 4.x
 - **New Bean Registration DSL**: `stoveSpring4xRegistrar` for Spring Boot 4.x (since `BeanDefinitionDsl` is deprecated)
 - **Runtime Version Checks**: Clear error messages when Spring Boot/Kafka is missing from classpath
+- **Ktor DI Flexibility**: Support for Koin, Ktor-DI, or custom resolvers
+- **Generic Type Resolution**: `using<List<T>>` now works correctly with full generic type preservation
 
 ---
 
@@ -118,14 +120,38 @@ bridge() // Auto-detects Ktor-DI
 For any other DI framework (Kodein, Dagger, manual, etc.):
 
 ```kotlin
-bridge { application, klass ->
-    // Your custom resolution logic
-    myDiContainer.resolve(klass.java)
+bridge { application, type ->
+    // Your custom resolution logic - type is KType preserving generics
+    myDiContainer.resolve(type)
 }
 ```
 
 ---
 
+### Generic Type Resolution in Bridge System
+
+The `using<T>` function now properly preserves generic type information, allowing you to resolve types like `List<PaymentService>`:
+
+```kotlin
+// Register multiple implementations
+provide<List<PaymentService>> {
+    listOf(StripePaymentService(), PayPalPaymentService())
+}
+
+// Resolve with full generic type preserved
+validate {
+    using<List<PaymentService>> {
+        forEach { service -> service.pay(order) }
+    }
+}
+```
+
+This works by using `KType` instead of `KClass` internally, which preserves generic type parameters that would otherwise be lost due to JVM type erasure.
+
+**For custom BridgeSystem implementations:** Override `getByType(type: KType)` to support generic types. The default implementation falls back to `get(klass: KClass)`.
+
+---
+
 ### Runtime Version Checks
 
 When Spring Boot, Spring Kafka, or Ktor DI is missing from the classpath, Stove now provides clear error messages:
@@ -235,6 +261,22 @@ This is simpler - no need to create a separate class.
 
 ### Notes
 
+#### BridgeSystem API Enhancement
+
+The `BridgeSystem` abstract class now has a new method `getByType(type: KType)` which is used by `resolve()` to support generic types. If you have a custom `BridgeSystem` implementation:
+
+- **No action required** if you only use simple types - the default implementation falls back to `get(klass: KClass)`
+- **Override `getByType(type: KType)`** if you want to support generic types like `List<T>`, `Map<K,V>`, etc.
+
+```kotlin
+// Example for custom bridge
+override fun <D : Any> getByType(type: KType): D {
+    // Use type.classifier for KClass
+    // Use type.arguments for generic parameters
+    return myDiFramework.resolve(type)
+}
+```
+
 #### Dead Letter Topic Naming Convention (Spring Kafka)
 
 Be aware that Spring Kafka changed the default DLT (Dead Letter Topic) naming convention between versions:

lib/stove-testing-e2e/api/stove-testing-e2e.api

@@ -465,6 +465,7 @@ public abstract class com/trendyol/stove/testing/e2e/system/BridgeSystem : com/t
 	public fun close ()V
 	public fun executeWithReuseCheck (Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public abstract fun get (Lkotlin/reflect/KClass;)Ljava/lang/Object;
+	public fun getByType (Lkotlin/reflect/KType;)Ljava/lang/Object;
 	protected final fun getCtx ()Ljava/lang/Object;
 	public fun getTestSystem ()Lcom/trendyol/stove/testing/e2e/system/TestSystem;
 	protected final fun setCtx (Ljava/lang/Object;)V

lib/stove-testing-e2e/src/main/kotlin/com/trendyol/stove/testing/e2e/system/BridgeSystem.kt

@@ -4,6 +4,8 @@ import arrow.core.getOrElse
 import com.trendyol.stove.testing.e2e.system.abstractions.*
 import com.trendyol.stove.testing.e2e.system.annotations.StoveDsl
 import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
 
 /**
  * A system that provides a bridge between the test system and the application context.
@@ -34,16 +36,36 @@ abstract class BridgeSystem<T : Any>(
     ctx = context
   }
 
+  /**
+   * Resolves a dependency by KClass.
+   * Override this for basic type resolution without generic support.
+   */
   abstract fun <D : Any> get(klass: KClass<D>): D
 
+  /**
+   * Resolves a dependency by KType, preserving generic type information.
+   * Override this to support generic types like List<T>, Map<K,V>, etc.
+   * Default implementation falls back to KClass-based resolution.
+   *
+   * @param type the full KType including generic parameters
+   * @return the resolved dependency
+   */
+  @Suppress("UNCHECKED_CAST")
+  open fun <D : Any> getByType(type: KType): D {
+    val klass = type.classifier as? KClass<D>
+      ?: throw IllegalArgumentException("Cannot resolve type: $type")
+    return get(klass)
+  }
+
   /**
    * Resolves a bean of the specified type from the application context.
+   * Uses KType to preserve generic type information (e.g., List<PaymentService>).
    *
    * @param T the type of bean to resolve.
    * @return the resolved bean.
    */
   @PublishedApi
-  internal inline fun <reified D : Any> resolve(): D = get(D::class)
+  internal inline fun <reified D : Any> resolve(): D = getByType(typeOf<D>())
 
   /**
    * Executes the specified block using the resolved bean.

starters/ktor/stove-ktor-testing-e2e/api/stove-ktor-testing-e2e.api

@@ -19,6 +19,7 @@ public final class com/trendyol/stove/testing/e2e/KtorApplicationUnderTestKt {
 public final class com/trendyol/stove/testing/e2e/KtorBridgeSystem : com/trendyol/stove/testing/e2e/system/BridgeSystem, com/trendyol/stove/testing/e2e/system/abstractions/AfterRunAwareWithContext, com/trendyol/stove/testing/e2e/system/abstractions/PluggedSystem {
 	public fun <init> (Lcom/trendyol/stove/testing/e2e/system/TestSystem;Lkotlin/jvm/functions/Function2;)V
 	public fun get (Lkotlin/reflect/KClass;)Ljava/lang/Object;
+	public fun getByType (Lkotlin/reflect/KType;)Ljava/lang/Object;
 	public fun getTestSystem ()Lcom/trendyol/stove/testing/e2e/system/TestSystem;
 }
 

starters/ktor/stove-ktor-testing-e2e/src/main/kotlin/com/trendyol/stove/testing/e2e/DependencyResolvers.kt

@@ -4,14 +4,14 @@ import io.ktor.server.application.*
 import io.ktor.server.plugins.di.*
 import io.ktor.util.reflect.*
 import org.koin.ktor.ext.getKoin
-import kotlin.reflect.KClass
-import kotlin.reflect.full.starProjectedType
+import kotlin.reflect.*
 
 /**
  * Type alias for a dependency resolver function.
- * Takes an Application and a KClass, returns the resolved dependency.
+ * Takes an Application and a KType, returns the resolved dependency.
+ * KType preserves generic type information (e.g., List<PaymentService>).
  */
-typealias DependencyResolver = (Application, KClass<*>) -> Any
+typealias DependencyResolver = (Application, KType) -> Any
 
 /**
  * Default resolver implementations for supported DI frameworks.
@@ -20,16 +20,23 @@ object DependencyResolvers {
   /**
    * Resolver for Koin DI framework.
    */
-  val koin: DependencyResolver = { application, klass -> application.getKoin().get(klass) }
+  val koin: DependencyResolver = { application, type ->
+    val klass = type.classifier as? KClass<*>
+      ?: error("Cannot resolve type: $type")
+    application.getKoin().get(klass)
+  }
 
   /**
    * Resolver for Ktor-DI framework.
+   * Uses full KType to preserve generic type information.
    */
-  val ktorDi: DependencyResolver = { application, klass ->
+  val ktorDi: DependencyResolver = { application, type ->
     require(application.attributes.contains(DependencyRegistryKey)) {
       "Ktor-DI not installed in application. Make sure to install(DI) { ... } in your application."
     }
-    val typeInfo = TypeInfo(klass, klass.starProjectedType)
+    val klass = type.classifier as? KClass<*>
+      ?: error("Cannot resolve type: $type")
+    val typeInfo = TypeInfo(klass, type)
     application.dependencies.getBlocking(DependencyKey(type = typeInfo))
   }
 
@@ -38,7 +45,7 @@ object DependencyResolvers {
    * Prefers Ktor-DI over Koin if both are available.
    * Detection is deferred to runtime to ensure classpath is fully resolved.
    */
-  fun autoDetect(): DependencyResolver = { application, klass ->
+  fun autoDetect(): DependencyResolver = { application, type ->
     val resolver = when {
       KtorDiCheck.isKtorDiAvailable() -> ktorDi
 
@@ -47,9 +54,9 @@ object DependencyResolvers {
       else -> error(
         "No supported DI framework found. " +
           "Add either Koin (io.insert-koin:koin-ktor) or Ktor-DI (io.ktor:ktor-server-di) to your classpath, " +
-          "or provide a custom resolver via bridge(resolver = { app, klass -> ... })"
+          "or provide a custom resolver via bridge(resolver = { app, type -> ... })"
       )
     }
-    resolver(application, klass)
+    resolver(application, type)
   }
 }

starters/ktor/stove-ktor-testing-e2e/src/main/kotlin/com/trendyol/stove/testing/e2e/KtorBridgeSystem.kt

@@ -1,10 +1,13 @@
+@file:Suppress("UNCHECKED_CAST")
+
 package com.trendyol.stove.testing.e2e
 
 import com.trendyol.stove.testing.e2e.system.*
 import com.trendyol.stove.testing.e2e.system.abstractions.*
 import com.trendyol.stove.testing.e2e.system.annotations.StoveDsl
 import io.ktor.server.application.*
-import kotlin.reflect.KClass
+import kotlin.reflect.*
+import kotlin.reflect.full.starProjectedType
 
 /**
  * A system that provides a bridge between the test system and the application context.
@@ -20,8 +23,16 @@ class KtorBridgeSystem(
 ) : BridgeSystem<Application>(testSystem),
   PluggedSystem,
   AfterRunAwareWithContext<Application> {
-  @Suppress("UNCHECKED_CAST")
-  override operator fun <D : Any> get(klass: KClass<D>): D = resolver(ctx, klass) as D
+  /**
+   * Resolves a dependency by KClass (fallback, loses generic info).
+   */
+  override fun <D : Any> get(klass: KClass<D>): D = resolver(ctx, klass.starProjectedType) as D
+
+  /**
+   * Resolves a dependency by KType, preserving generic type information.
+   * This allows resolving types like List<PaymentService> correctly.
+   */
+  override fun <D : Any> getByType(type: KType): D = resolver(ctx, type) as D
 }
 
 /**

starters/ktor/tests/ktor-di-tests/src/test/kotlin/com/trendyol/stove/testing/e2e/ktor/app.kt

@@ -21,6 +21,15 @@ object KtorDiTestApp {
         provide<GetUtcNow> { SystemTimeGetUtcNow() }
         provide<ExampleService> { ExampleService(resolve()) }
         provide<TestConfig> { TestConfig() }
+
+        // Multiple payment service implementations as List<PaymentService>
+        provide<List<PaymentService>> {
+          listOf(
+            StripePaymentService(),
+            PayPalPaymentService(),
+            SquarePaymentService()
+          )
+        }
       }
     }
     applicationEngine.start(wait = false)

starters/ktor/tests/ktor-koin-tests/src/test/kotlin/com/trendyol/stove/testing/e2e/ktor/app.kt

@@ -24,6 +24,15 @@ object KoinTestApp {
             single<GetUtcNow> { SystemTimeGetUtcNow() }
             single { ExampleService(get()) }
             single { TestConfig() }
+
+            // Multiple payment service implementations as List<PaymentService>
+            single<List<PaymentService>> {
+              listOf(
+                StripePaymentService(),
+                PayPalPaymentService(),
+                SquarePaymentService()
+              )
+            }
           }
         )
       }

starters/ktor/tests/ktor-test-fixtures/src/testFixtures/kotlin/com/trendyol/stove/testing/e2e/ktor/BridgeSystemTests.kt

@@ -4,7 +4,9 @@ import com.trendyol.stove.testing.e2e.system.TestSystem.Companion.validate
 import com.trendyol.stove.testing.e2e.system.using
 import io.kotest.core.config.AbstractProjectConfig
 import io.kotest.core.spec.style.ShouldSpec
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.shouldBe
+import java.math.BigDecimal
 
 /**
  * Shared bridge system tests that work with both Koin and Ktor-DI.
@@ -45,4 +47,16 @@ abstract class BridgeSystemTests(
         }
       }
     }
+
+    should("resolve multiple instances of same interface") {
+      validate {
+        using<List<PaymentService>> {
+          val order = Order("order-123", BigDecimal("99.99"))
+          val results = map { it.pay(order) }
+
+          results.map { it.provider } shouldContainExactlyInAnyOrder listOf("Stripe", "PayPal", "Square")
+          results.all { it.success } shouldBe true
+        }
+      }
+    }
   })

starters/ktor/tests/ktor-test-fixtures/src/testFixtures/kotlin/com/trendyol/stove/testing/e2e/ktor/TestDomain.kt

@@ -1,5 +1,6 @@
 package com.trendyol.stove.testing.e2e.ktor
 
+import java.math.BigDecimal
 import java.time.Instant
 
 /**
@@ -27,3 +28,40 @@ class ExampleService(
 data class TestConfig(
   val message: String = "Hello from Stove!"
 )
+
+/**
+ * Domain classes for testing multi-instance resolution.
+ */
+data class Order(
+  val id: String,
+  val amount: BigDecimal
+)
+
+data class PaymentResult(
+  val provider: String,
+  val success: Boolean
+)
+
+interface PaymentService {
+  val providerName: String
+
+  fun pay(order: Order): PaymentResult
+}
+
+class StripePaymentService : PaymentService {
+  override val providerName = "Stripe"
+
+  override fun pay(order: Order) = PaymentResult(providerName, true)
+}
+
+class PayPalPaymentService : PaymentService {
+  override val providerName = "PayPal"
+
+  override fun pay(order: Order) = PaymentResult(providerName, true)
+}
+
+class SquarePaymentService : PaymentService {
+  override val providerName = "Square"
+
+  override fun pay(order: Order) = PaymentResult(providerName, true)
+}