ProcessorBinding
One handler of an annotated subscription processor, bound to its processor instance: what the compiler generates for each @OnEvent function of a @Projection, @Reactor or @Saga, exposed by its module's ModelProvider.processors. It knows no runtime: the runtime compiles each into one subscription named name, processor.function.
stateType is the state of the
StateEvent<S>the handler takes: the subscription reads the aggregates of its context whose state is one, and hands each commit over with the state after it. Null forStateEvent<*>: every aggregate of the context. nullableState says the handler takes a null state,StateEvent<S?>orStateEvent<*>: what a stream another context publishes without its state needs.aggregates are those
@OnEvent(aggregates)names,context.aggregate, all of one context. When they are of another context than the module's (sourceContext), the handler reads that context's published streams instead of the log: its state, if any, is decoded from the published state into stateType, and its events are the published ones.startFrom is where the subscription starts in a partition it has no checkpoint in yet, as
@OnEvent(start)declares it; null leaves it to startIn: a projection from the beginning, so it builds its read model from the whole history, and so does any handler of another context's stream, so a service that joins later still gets what that context published before; a reactor or a saga of its own context's log from its end (a new subscription chooses), so deploying one does not replay side effects or derive commands for the history.blocking (
@Blocking) asks the runtime to run the call on virtual threads instead of inline.retry (
@Retryon the handler or its processor) is the handler's own in-process retry budget, under what the host configures for its subscription and over the host's global one.invoke calls the handler directly and returns the commands a saga derives; a projection's or a reactor's none.
rejections are a saga's
@OnRejectedhandlers, the same for each handler of the saga: the runtime hands the rejection of a command this handler derived to the one rejectionHandlerOf its class.commits are a saga's
@OnCommittedhandlers, likewise: the runtime hands the success receipt of a command this handler derived to the one committedHandlerOf its class, and only such a command asks for one.job is the job of a saga's
@OnSchedulehandler (schedule): its subscription reads the job's instances of the context's built-in job aggregate (<context>.schedule, JobState) and hands each of their ticks over as a ScheduleTick.
Built with project, react or saga, one per kind, or schedule for a saga's job.
Properties
The job of an @OnSchedule handler (schedule); null for an @OnEvent one.
The handler's own in-process retry budget (@Retry); null when it gives none.
What a saga's handler declares it sends (@Sends, else its return type for what it derives): the only commands its context lets it derive, schedule and call. None for any other handler.
The context of the aggregates the handler names; null when it names none: its module's.
Functions
The @OnCommitted handler of the saga for the success receipt of a command of command this handler derived (CommittedBinding.handlerOf); null when the saga has none for it, and the command asks for no receipt.
This handler reading aggregates, context.aggregate: those of another context whose events it takes by type without naming them, which the service's Manifest finds from the peer contracts.
The @OnRejected handler of the saga for the rejection of a command of command this handler derived (RejectionBinding.handlerOf); null when the saga has none for it.
Where the subscription starts, in a partition it has no checkpoint in yet, when its module's context is context: startFrom when the handler declares it; otherwise from the beginning for a projection, where the service joins the stream for a reactor's or a saga's handler of another context's stream (isSourced, StartFrom.JOIN), from the end for a reactor or a saga of its own context's log.