Commanded

v0.13.0

Commanded v0.13.0 Commanded.ProcessManagers.ProcessManager behaviour View Source

Behaviour to define a process manager.

A process manager is responsible for coordinating one or more aggregate roots. It handles events and dispatches commands in response. Process managers have state that can be used to track which aggregate roots are being orchestrated.

Use the Commanded.ProcessManagers.ProcessManager macro in your process manager module and implement the three callback functions defined in the behaviour:

Example 

defmodule ExampleProcessManager do
  use Commanded.ProcessManagers.ProcessManager,
    name: "ExampleProcessManager",
    router: BankRouter

  def interested?(%AnEvent{...}) do
    # ...
  end

  def handle(%ExampleProcessManager{...}, %AnEvent{...}) do
    # ...
  end

  def apply(%ExampleProcessManager{...}, %AnEvent{...}) do
    # ...
  end
end

Start the process manager (or configure as a worker inside a Supervisor)

{:ok, process_manager} = ExampleProcessManager.start_link()

Please read the Process managers guide for more details.

Link to this section Summary

Types

command()
domain_event()
process_manager()
process_uuid()

Callbacks

apply(process_manager, domain_event)

Mutate the process manager’s state by applying the domain event

handle(process_manager, domain_event)

Process manager instance handles the domain event, returning commands to dispatch

interested?(domain_event)

Is the process manager interested in the given command?

Link to this section Types

Link to this type command() View Source 
command() :: struct
Link to this type domain_event() View Source 
domain_event() :: struct
Link to this type process_manager() View Source 
process_manager() :: struct
Link to this type process_uuid() View Source 
process_uuid() :: String.t

Link to this section Callbacks

Link to this callback apply(process_manager, domain_event) View Source 
apply(process_manager, domain_event) :: process_manager

Mutate the process manager’s state by applying the domain event

The apply/2 function is used to mutate the process manager’s state. It receives its current state and the interested event. It must return the modified state.

Link to this callback handle(process_manager, domain_event) View Source 
handle(process_manager, domain_event) :: [command]

Process manager instance handles the domain event, returning commands to dispatch

A handle/2 function must exist for each :start and :continue tagged event previously specified. It receives the process manager’s state and the event to be handled. It must return the commands to be dispatched. This may be none, a single command, or many commands.

Link to this callback interested?(domain_event) View Source 
interested?(domain_event) ::
  {:start, process_uuid} |
  {:continue, process_uuid} |
  {:stop, process_uuid} |
  false

Is the process manager interested in the given command?

The interested?/1 function is used to indicate which events the process manager receives. The response is used to route the event to an existing instance or start a new process instance.

  • Return {:start, process_uuid} to create a new instance of the process manager.
  • Return {:continue, process_uuid} to continue execution of an existing process manager.
  • Return {:stop, process_uuid} to stop an existing process manager and shutdown its process.
  • Return false to ignore the event.