Package-level declarations

Abstract base class for filters that notify wait strategies about command processing completion. These filters intercept message processing pipelines and send notifications to waiting clients when specific processing stages are reached.

Enumeration of command processing stages.

Interface for objects that have an associated command stage.

Interface for defining command wait endpoints. Command wait endpoints specify where command processing results should be sent when using wait strategies in distributed scenarios.

Interface for notifying command wait endpoints about processing results. After command processors complete their work, they send results to waiting clients through implementations of this interface.

Subscriber that handles command processing completion and sends wait notifications. This subscriber wraps the actual subscriber and intercepts completion/error events to send appropriate wait signals to waiting clients.

Filter that notifies wait strategies when domain events are handled by event processors. Intercepts the domain event dispatcher pipeline to send EVENT_HANDLED stage notifications.

Data class representing an extracted wait strategy with its associated metadata. Combines the wait strategy implementation with endpoint and command ID information needed for message propagation and notification.

Local implementation of CommandWaitNotifier for in-process notifications. This notifier forwards wait signals to registered wait strategies within the same JVM instance.

A Mono wrapper that automatically notifies wait strategies when command processing completes. This class intercepts the completion of a Mono operation and sends appropriate wait signals to registered wait strategies based on the processing stage and message exchange.

Interface for objects that may have an aggregate version.

Filter that notifies wait strategies when command processing is complete. Intercepts the command dispatcher pipeline to send PROCESSED stage notifications.

Functional interface for defining predicate logic to determine whether notification should be sent during processing stages. Used by wait strategies to decide if they should be notified about command processing progress at specific stages.

Filter that notifies wait strategies when projections are updated. Intercepts the projection dispatcher pipeline to send PROJECTED stage notifications.

Filter that notifies wait strategies when domain events are handled by sagas. Intercepts the stateless saga dispatcher pipeline to send SAGA_HANDLED stage notifications.

Interface for objects that have a signal timestamp.

Simple implementation of CommandWaitEndpoint. Provides a basic data class wrapper for endpoint strings.

Simple implementation of WaitSignal.

Simple thread-safe implementation of WaitStrategyRegistrar using ConcurrentHashMap. Provides concurrent access to wait strategies with atomic operations.

Filter that notifies wait strategies when aggregate snapshots are generated. Intercepts the snapshot dispatcher pipeline to send SNAPSHOT stage notifications.

Interface for objects that have an associated wait command ID. The wait command ID is used to correlate wait strategies with their corresponding command executions in distributed scenarios.

Abstract base class for wait strategies that wait for specific command processing stages. Provides common functionality for managing wait signals, completion, and error handling. Subclasses must implement the logic for determining which signals are relevant.

Signal representing a command processing stage completion.

Functional interface for defining predicate logic to determine whether notification should be sent for specific wait signals. Provides fine-grained control over when wait strategies receive notifications based on the content and context of the signal.

Command Wait Strategy

Interface for propagating wait strategy information.

Registry for managing wait strategies. Provides thread-safe operations for registering, unregistering, and retrieving wait strategies by their command IDs.

Header key for storing the command wait context name.

Header key for storing the command wait endpoint.

Header key for storing the command wait function name.

Prefix for all command wait header keys.

Header key for storing the command wait processor name.

Header key for storing the command wait stage.

Header key for storing the wait command ID.

Extracts the command wait endpoint from the message header.

Extracts the command wait ID from the message header.

Extracts wait function information from the message header.

Extracts the waiting stage from the message header.

Extracts a complete wait strategy from the message header. Attempts to extract both simple waiting chain and waiting for stage strategies.

Determines if a command wait ID belongs to the current JVM instance. Uses the global ID generator to check if the machine ID in the wait ID matches the current machine's ID.

Checks if a function matches the criteria specified by this NamedFunctionInfo. Used to determine if a wait strategy should be notified about a specific function execution. Returns true if all specified criteria (context, processor, name) match or are not specified.

Extension function to notify and forget using an extracted wait strategy. Only sends notification if the wait strategy should be notified for this signal.

Adds the command wait endpoint to the message header for propagation.

Adds the wait command ID to the message header for propagation.

Adds wait function information to the message header for propagation.

Adds the waiting stage to the message header for propagation.

Extracts the command wait endpoint from the message header, throwing an exception if not present.

Extracts the command wait ID from the message header, throwing an exception if not present.

Extension function that wraps a Mono to automatically notify wait strategies on completion. This provides a convenient way to add wait notification behavior to any Mono operation in the command processing pipeline.