kediatR

Handlers resolve polymorphically.

• Notifications: A handler registered for a base type (e.g., Notification) will receive all derived notification types.
• Requests: A more specific handler takes priority over a base-type handler if both are registered.

sealed class DomainEvent : Notification
data class OrderPlaced(val orderId: Long) : DomainEvent()
data class OrderShipped(val orderId: Long) : DomainEvent()

// Receives every DomainEvent subtype
class AuditLogger : NotificationHandler<DomainEvent> {
  override suspend fun handle(notification: DomainEvent) {
    audit.record(notification)
  }
}

kediatR uses a Mediator to dispatch three types of messages. All handlers are suspend functions and are coroutine-native.

• Requests: Unify commands and queries. A Request<T> returns a value of type T. Use Request.Unit when no return value is needed. Each request has exactly one handler.
• Notifications: Fire-and-forget messages that can be handled by zero or more handlers.
• PipelineBehavior: Wraps every send and publish call, allowing for cross-cutting concerns like logging or validation.

The Mediator interface is simplified. All requests (Commands and Queries) use the same send() method. MediatorBuilder has been removed in favor of a companion object factory method Mediator.build(dependencyProvider).

Additionally, publish() for notifications now accepts an optional PublishStrategy which defaults to PublishStrategy.DEFAULT.

// Mediator Creation
val mediator = Mediator.build(dependencyProvider)

// Sending requests
mediator.send(CreateUserCommand())
val user = mediator.send(GetUserCommand("123"))

// Publishing notifications
mediator.publish(UserCreatedNotification(user.id)) // Uses default
mediator.publish(UserCreatedNotification(user.id), PublishStrategy.CONTINUE_ON_EXCEPTION)

In v4.x, commands are no longer distinct types but implementations of the Request interface.

1. Unit Commands (commands that return nothing):

   • Implement Request.Unit instead of Command.
   • Implement RequestHandler.Unit<TCommand> instead of CommandHandler<TCommand>.

2. Commands with Results:

   • Implement Request<TResult> instead of CommandWithResult<TResult>.
   • Implement RequestHandler<TCommand, TResult> instead of CommandWithResultHandler<TCommand, TResult>.

Note: When updating handler methods, change the parameter name from command/query to request to align with the new unified pattern.

In v4.x, commands that do not return a result should implement Request.Unit instead of the old Command interface. Handlers should implement RequestHandler.Unit<TRequest>.

// After v4.x
class CreateUserCommand : Request.Unit {
  // command properties
}

class CreateUserCommandHandler : RequestHandler.Unit<CreateUserCommand> {
  override suspend fun handle(request: CreateUserCommand) {
    // handle command
  }
}

Add the kediatr-spring-boot-{2x|3x|4x}-starter. The starter auto-configures a Mediator bean. Simply annotate your handlers and behaviors as Spring components (e.g., @Component, @Service).

@Component
class GetUserByIdHandler(
  private val users: UserRepository
) : RequestHandler<GetUserById, User> {
  override suspend fun handle(request: GetUserById): User =
    users.findById(request.id)
}

@Service
class UserService(private val mediator: Mediator) {
  suspend fun find(id: Long): User = mediator.send(GetUserById(id))
}

The transition from v3.x to v4.x involves a complete architecture overhaul. The primary change is the unification of all request types (Commands and Queries) under a single Request<TResult> interface. This simplifies the API to three core interfaces: Request, RequestHandler, and Notification.

Key Mapping Summary

When registering handlers in your DI container, ensure you use the new unified interfaces (RequestHandler.Unit or RequestHandler).

// Spring Boot
@Component
class CreateUserCommandHandler : RequestHandler.Unit<CreateUserCommand> {
  // implementation
}

// Koin
module {
  single { CreateUserCommandHandler() } bind RequestHandler::class
}

// Manual
val mediator = HandlerRegistryProvider.createMediator(
  handlers = listOf(
    CreateUserCommandHandler(),
    GetUserCommandHandler()
  )
)

To use kediatR, add the kediatr-core module and the starter corresponding to your dependency injection framework. For plain Kotlin applications without a DI framework, only kediatr-core is required.

val version = "{CURRENT_VERSION}"

// Core — always required
implementation("com.trendyol:kediatr-core:$version")

// One starter, matching your framework (each pulls in core transitively)
implementation("com.trendyol:kediatr-spring-boot-2x-starter:$version")
implementation("com.trendyol:kediatr-spring-boot-3x-starter:$version")
implementation("com.trendyol:kediatr-spring-boot-4x-starter:$version")
implementation("com.trendyol:kediatr-koin-starter:$version")
implementation("com.trendyol:kediatr-quarkus-starter:$version")