wow-core/me.ahoo.wow.modeling.command

Package-level declarations

Types

abstract class AbstractCommandFunction<C : Any>(val commandAggregate: CommandAggregate<C, *>, afterCommandFunctions: List<AfterCommandFunction<C>>) : MessageFunction<C, ServerCommandExchange<*>, Mono<DomainEventStream>>

Abstract base class for command functions that handle command processing with after-command functions.

AggregateCommandDispatcher

class AggregateCommandDispatcher<C : Any, S : Any>(val aggregateMetadata: AggregateMetadata<C, S>, val parallelism: Int = MessageParallelism.DEFAULT_PARALLELISM, val scheduler: Scheduler, val messageFlux: Flux<ServerCommandExchange<*>>, val name: String = "-", aggregateProcessorFactory: AggregateProcessorFactory, commandHandler: CommandHandler, serviceProvider: ServiceProvider) : AggregateMessageDispatcher<ServerCommandExchange<*>>

Aggregate command dispatcher grouped by named aggregate.

AggregateProcessor

interface AggregateProcessor<C : Any> : AggregateIdCapable, NamedTypedAggregate<C> , MonoMessageProcessor<C, ServerCommandExchange<*>, Mono<DomainEventStream>>

Processor for handling commands on a specific aggregate instance.

AggregateProcessorFactory

interface AggregateProcessorFactory

Factory interface for creating aggregate processors.

AggregateProcessorFilter

@Order(value = 0)

object AggregateProcessorFilter : ExchangeFilter<ServerCommandExchange<*>>

CommandAggregate

interface CommandAggregate<C : Any, S : Any> : NamedTypedAggregate<C> , AggregateProcessor<C> , Version

Represents a command aggregate that processes commands and manages state transitions.

CommandAggregateFactory

interface CommandAggregateFactory

Factory interface for creating command aggregate instances.

CommandDispatcher

class CommandDispatcher(val name: String = CommandDispatcher::class.simpleName!!, val parallelism: Int = MessageParallelism.DEFAULT_PARALLELISM, val namedAggregates: Set<NamedAggregate> = MetadataSearcher.localAggregates, commandBus: CommandBus, aggregateProcessorFactory: AggregateProcessorFactory, commandHandler: CommandHandler, serviceProvider: ServiceProvider, schedulerSupplier: AggregateSchedulerSupplier = DefaultAggregateSchedulerSupplier("CommandDispatcher")) : AbstractDispatcher<ServerCommandExchange<*>>

Command Dispatcher .

CommandExpectVersionConflictException

class CommandExpectVersionConflictException(val command: CommandMessage<*>, val expectVersion: Int, val actualVersion: Int, cause: Throwable? = null) : WowException

CommandFunction

class CommandFunction<C : Any>(val delegate: MessageFunction<C, ServerCommandExchange<*>, Mono<*>>, commandAggregate: CommandAggregate<C, *>, afterCommandFunctions: List<AfterCommandFunction<C>>) : AbstractCommandFunction<C> , Decorator<MessageFunction<C, ServerCommandExchange<*>, Mono<*>>>

A concrete implementation of command function that wraps a delegate message function.

CommandHandler

interface CommandHandler : Handler<ServerCommandExchange<*>>

Handler interface for processing command exchanges.

CommandState

enum CommandState : Enum<CommandState>

Represents the state of command processing in a command aggregate.

DefaultCommandHandler

class DefaultCommandHandler(chain: FilterChain<ServerCommandExchange<*>>, errorHandler: ErrorHandler<ServerCommandExchange<*>> = LogResumeErrorHandler()) : AbstractHandler<ServerCommandExchange<*>> , CommandHandler

Default implementation of CommandHandler using a filter chain.

DefaultDeleteAggregateFunction

class DefaultDeleteAggregateFunction<C : Any>(commandAggregate: CommandAggregate<C, *>, afterCommandFunctions: List<AfterCommandFunction<C>>) : AbstractCommandFunction<C>

Default implementation of delete aggregate command function.

DefaultRecoverAggregateFunction

class DefaultRecoverAggregateFunction<C : Any>(commandAggregate: CommandAggregate<C, *>, afterCommandFunctions: List<AfterCommandFunction<C>>) : AbstractCommandFunction<C>

Default implementation of recover aggregate command function.

IllegalAccessDeletedAggregateException

class IllegalAccessDeletedAggregateException(val aggregateId: AggregateId, errorMsg: String = "Illegal access to a deleted aggregate[") : AggregateIdCapable, WowException

IllegalAccessOwnerAggregateException

class IllegalAccessOwnerAggregateException(val aggregateId: AggregateId, errorMsg: String = "Illegal access to a owner aggregate[") : WowException, AggregateIdCapable

Exception thrown when attempting to access an aggregate owned by another tenant or user.

RetryableAggregateProcessor

class RetryableAggregateProcessor<C : Any, S : Any>(val aggregateId: AggregateId, aggregateMetadata: AggregateMetadata<C, S>, aggregateFactory: StateAggregateFactory, stateAggregateRepository: StateAggregateRepository, commandAggregateFactory: CommandAggregateFactory) : AggregateProcessor<C> , NamedTypedAggregate<C>

RetryableAggregateProcessorFactory

class RetryableAggregateProcessorFactory(stateAggregateFactory: StateAggregateFactory, stateAggregateRepository: StateAggregateRepository, commandAggregateFactory: CommandAggregateFactory) : AggregateProcessorFactory

Factory that creates retryable aggregate processors.

SendDomainEventStreamFilter

@Order(value = 2147483647, after = [AggregateProcessorFilter::class])

class SendDomainEventStreamFilter(domainEventBus: DomainEventBus) : ExchangeFilter<ServerCommandExchange<*>>

SimpleCommandAggregate

class SimpleCommandAggregate<C : Any, S : Any>(val state: StateAggregate<S>, val commandRoot: C, eventStore: EventStore, metadata: CommandAggregateMetadata<C>) : CommandAggregate<C, S> , NamedTypedAggregate<C>

Simple implementation of CommandAggregate that handles command processing with state management.

SimpleCommandAggregateFactory

class SimpleCommandAggregateFactory(eventStore: EventStore) : CommandAggregateFactory

Factory for creating SimpleCommandAggregate instances.

Properties

COMMAND_AGGREGATE_KEY

const val COMMAND_AGGREGATE_KEY: String

Functions

getCommandAggregate

fun <C : Any, S : Any> ServerCommandExchange<*>.getCommandAggregate(): CommandAggregate<C, S>?

setCommandAggregate

fun ServerCommandExchange<*>.setCommandAggregate(commandAggregate: CommandAggregate<*, *>): ServerCommandExchange<*>