feat: add support for command inheritance, fixes #437 (#438)

* feat: add support for command inheritance, fixes #437

* make spotless happy

Author: osoykan

projects/kediatr-core/src/main/kotlin/com/trendyol/kediatr/RegistryImpl.kt

@@ -8,34 +8,52 @@ class RegistryImpl(
   private val registry = Container(dependencyProvider)
 
   override fun <TCommand : Command> resolveCommandHandler(classOfCommand: Class<TCommand>): CommandHandler<TCommand> {
-    val handler =
-      registry.commandMap[classOfCommand]?.get()
-        ?: throw HandlerNotFoundException("handler could not be found for ${classOfCommand.name}")
+    val handler = registry.commandMap[baseClassOrItself(classOfCommand, Command::class.java)]?.get()
+      ?: throw HandlerNotFoundException("handler could not be found for ${classOfCommand.name}")
     return handler as CommandHandler<TCommand>
   }
 
   override fun <TCommand : CommandWithResult<TResult>, TResult> resolveCommandWithResultHandler(
     classOfCommand: Class<TCommand>
   ): CommandWithResultHandler<TCommand, TResult> {
-    val handler =
-      registry.commandWithResultMap[classOfCommand]?.get()
-        ?: throw HandlerNotFoundException("handler could not be found for ${classOfCommand.name}")
+    val handler = registry.commandWithResultMap[baseClassOrItself(classOfCommand, CommandWithResult::class.java)]?.get()
+      ?: throw HandlerNotFoundException("handler could not be found for ${classOfCommand.name}")
     return handler as CommandWithResultHandler<TCommand, TResult>
   }
 
   override fun <TNotification : Notification> resolveNotificationHandlers(
     classOfNotification: Class<TNotification>
-  ): Collection<NotificationHandler<TNotification>> =
-    registry.notificationMap
-      .filter { (k, _) -> k.isAssignableFrom(classOfNotification) }
-      .flatMap { (_, v) -> v.map { it.get() as NotificationHandler<TNotification> } }
+  ): Collection<NotificationHandler<TNotification>> = registry.notificationMap
+    .filter { (k, _) -> k.isAssignableFrom(classOfNotification) }
+    .flatMap { (_, v) -> v.map { it.get() as NotificationHandler<TNotification> } }
 
   override fun <TQuery : Query<TResult>, TResult> resolveQueryHandler(classOfQuery: Class<TQuery>): QueryHandler<TQuery, TResult> {
-    val handler =
-      registry.queryMap[classOfQuery]?.get()
-        ?: throw HandlerNotFoundException("handler could not be found for ${classOfQuery.name}")
+    val handler = registry.queryMap[baseClassOrItself(classOfQuery, Query::class.java)]?.get()
+      ?: throw HandlerNotFoundException("handler could not be found for ${classOfQuery.name}")
     return handler as QueryHandler<TQuery, TResult>
   }
 
   override fun getPipelineBehaviors(): Collection<PipelineBehavior> = registry.pipelineSet.map { it.get() }
+
+  /**
+   * Walk the inheritance chain of [clazz], collect all classes (including itself)
+   * that implement/extend [clazzWanted], and return the farthest‐up one.
+   *
+   * - Uses a purely functional style: generateSequence → filter → lastOrNull.
+   * - Avoids any explicit nullable vars or while‐loops.
+   *
+   * @param clazz The starting class to inspect.
+   * @param clazzWanted The interface or superclass we’re looking for.
+   * @return The highest ancestor of [clazz] (or [clazz] itself) for which
+   *         clazzWanted.isAssignableFrom(thatAncestor) is true. If none match,
+   *         returns [clazz].
+   */
+  private fun baseClassOrItself(
+    clazz: Class<*>,
+    clazzWanted: Class<*>
+  ): Class<*> =
+    generateSequence(clazz) { it.superclass } // ↪ generate the chain: clazz, clazz.superclass, clazz.superclass.superclass, …
+      .filter { clazzWanted.isAssignableFrom(it) } // ↪ keep only those that actually “implement/extend” clazzWanted
+      .lastOrNull() // ↪ pick the *last* (farthest‐up) match
+      ?: clazz // ↪ if none matched, return the original clazz
 }

projects/kediatr-core/src/test/kotlin/com/trendyol/kediatr/MediatorTests.kt

@@ -38,7 +38,10 @@ class MediatorTests : MediatorUseCases() {
       ThirdPipelineBehaviour(),
       CommandHandlerThatPassesThroughOrderedPipelineBehaviours(),
       QueryHandlerThatPassesThroughOrderedPipelineBehaviours(),
-      NotificationHandlerThatPassesThroughOrderedPipelineBehaviours()
+      NotificationHandlerThatPassesThroughOrderedPipelineBehaviours(),
+      TestCommandBaseHandler(),
+      TestQueryBaseHandler(),
+      TestCommandWithResultBaseHandler()
     )
   )
 

projects/kediatr-core/src/testFixtures/kotlin/com/trendyol/kediatr/testing/MediatorUseCases.kt

@@ -85,6 +85,41 @@ abstract class MediatorUseCases : MediatorTestConvention() {
     command.invocationCount() shouldBe 1
   }
 
+  @Test
+  fun inherited_command_should_work() = runTest {
+    val command = TestCommandBase.TestCommandInherited1("id")
+    testMediator.send(command)
+    command.invocationCount() shouldBe 1
+
+    val command2 = TestCommandBase.TestCommandInherited2("id")
+    testMediator.send(command2)
+    command2.invocationCount() shouldBe 1
+  }
+
+  @Test
+  fun inherited_query_should_work() = runTest {
+    val query = TestQueryBase.TestQueryInherited1("id")
+    testMediator.send(query)
+    query.invocationCount() shouldBe 1
+
+    val query2 = TestQueryBase.TestQueryInherited2("id2")
+    testMediator.send(query2)
+    query2.invocationCount() shouldBe 1
+  }
+
+  @Test
+  fun inherited_command_with_result_should_work() = runTest {
+    val command = TestCommandWithResultBase.TestCommandWithResultInherited1("id1")
+    val result = testMediator.send(command)
+    result shouldBe "id1 handled"
+    command.invocationCount() shouldBe 1
+
+    val command2 = TestCommandWithResultBase.TestCommandWithResultInherited2("id2")
+    val result2 = testMediator.send(command2)
+    result2 shouldBe "id2 handled"
+    command2.invocationCount() shouldBe 1
+  }
+
   @Test
   fun command_is_routed_to_its_handler() = runTest {
     val command = TestCommandForWithoutInjection()

projects/kediatr-core/src/testFixtures/kotlin/com/trendyol/kediatr/testing/models.kt

@@ -492,3 +492,65 @@ class ThirdPipelineBehaviour : PipelineBehavior {
     return next(request)
   }
 }
+
+sealed class TestCommandBase :
+  EnrichedWithMetadata(),
+  Command {
+  abstract val id: String
+
+  data class TestCommandInherited1(
+    override val id: String
+  ) : TestCommandBase()
+
+  data class TestCommandInherited2(
+    override val id: String
+  ) : TestCommandBase()
+}
+
+class TestCommandBaseHandler : CommandHandler<TestCommandBase> {
+  override suspend fun handle(command: TestCommandBase) {
+    command.incrementInvocationCount()
+  }
+}
+
+sealed class TestQueryBase :
+  EnrichedWithMetadata(),
+  Query<String> {
+  abstract val id: String
+
+  data class TestQueryInherited1(
+    override val id: String
+  ) : TestQueryBase()
+
+  data class TestQueryInherited2(
+    override val id: String
+  ) : TestQueryBase()
+}
+
+class TestQueryBaseHandler : QueryHandler<TestQueryBase, String> {
+  override suspend fun handle(query: TestQueryBase): String {
+    query.incrementInvocationCount()
+    return query.id
+  }
+}
+
+sealed class TestCommandWithResultBase :
+  EnrichedWithMetadata(),
+  CommandWithResult<String> {
+  abstract val id: String
+
+  data class TestCommandWithResultInherited1(
+    override val id: String
+  ) : TestCommandWithResultBase()
+
+  data class TestCommandWithResultInherited2(
+    override val id: String
+  ) : TestCommandWithResultBase()
+}
+
+class TestCommandWithResultBaseHandler : CommandWithResultHandler<TestCommandWithResultBase, String> {
+  override suspend fun handle(command: TestCommandWithResultBase): String {
+    command.incrementInvocationCount()
+    return "${command.id} handled"
+  }
+}

projects/kediatr-koin-starter/src/test/kotlin/com/trendyol/kediatr/koin/MediatorTests.kt

@@ -52,6 +52,9 @@ class MediatorTests :
         single { CommandHandlerThatPassesThroughOrderedPipelineBehaviours() } bind CommandHandler::class
         single { QueryHandlerThatPassesThroughOrderedPipelineBehaviours() } bind QueryHandler::class
         single { NotificationHandlerThatPassesThroughOrderedPipelineBehaviours() } bind NotificationHandler::class
+        single { TestCommandBaseHandler() } bind CommandHandler::class
+        single { TestQueryBaseHandler() } bind QueryHandler::class
+        single { TestCommandWithResultBaseHandler() } bind CommandWithResultHandler::class
 
         // Extra
         single<MediatorAccessor> { { get<Mediator>() } }

projects/kediatr-quarkus-starter/src/test/kotlin/com/trendyol/kediatr/quarkus/MediatorTests.kt

@@ -108,4 +108,13 @@ class MediatorTests : MediatorUseCases() {
 
   @Produces
   fun handler25() = NotificationHandlerThatPassesThroughOrderedPipelineBehaviours()
+
+  @Produces
+  fun handler26() = TestCommandBaseHandler()
+
+  @Produces
+  fun handler27() = TestQueryBaseHandler()
+
+  @Produces
+  fun handler28() = TestCommandWithResultBaseHandler()
 }

projects/kediatr-spring-boot-2x-starter/src/test/kotlin/com/trendyol/kediatr/spring/MediatorTests.kt

@@ -41,7 +41,10 @@ import org.springframework.context.annotation.*
     ThirdPipelineBehaviour::class,
     CommandHandlerThatPassesThroughOrderedPipelineBehaviours::class,
     QueryHandlerThatPassesThroughOrderedPipelineBehaviours::class,
-    NotificationHandlerThatPassesThroughOrderedPipelineBehaviours::class
+    NotificationHandlerThatPassesThroughOrderedPipelineBehaviours::class,
+    TestCommandBaseHandler::class,
+    TestQueryBaseHandler::class,
+    TestCommandWithResultBaseHandler::class
   ]
 )
 class MediatorTests : MediatorUseCases() {

projects/kediatr-spring-boot-3x-starter/src/test/kotlin/com/trendyol/kediatr/spring/MediatorTests.kt

@@ -41,7 +41,10 @@ import org.springframework.context.annotation.*
     ThirdPipelineBehaviour::class,
     CommandHandlerThatPassesThroughOrderedPipelineBehaviours::class,
     QueryHandlerThatPassesThroughOrderedPipelineBehaviours::class,
-    NotificationHandlerThatPassesThroughOrderedPipelineBehaviours::class
+    NotificationHandlerThatPassesThroughOrderedPipelineBehaviours::class,
+    TestCommandBaseHandler::class,
+    TestQueryBaseHandler::class,
+    TestCommandWithResultBaseHandler::class
   ]
 )
 class MediatorTests : MediatorUseCases() {