EventStore | The stream database optimised for event sourcing | Microservice library

I'm one of the core developers of wolkenkit, so first of all thanks for bringing up this question 😊

Right now what you want is actually not possible, but nevertheless it could be a good idea to support this use case.

In wolkenkit the procedure is that the command handler publishes the events, and only if the command handler succeeds, the events are stored in the event store in an all-or-nothing approach.

To be able to understand your use case better – you said, you would like:

to rollback those events if something else fail[s]

What would this "something else" be?

Since this could be the start for a longer discussion, I think StackOverflow is probably not the perfect place to do this, so if you would like to talk to us about this feature, could you please open a feature request for this?

Updated after getting new code and stack trace. Original answer left below

I think it's a bug.

Boring explanation:

Strict and Wrapping each add rules to the front of the faked object's rules list. The rules apply to all incoming calls. The first rule found that matches a call is triggered. So in your configuration, Wrapping is added making the Fake attempt to forward all calls to the wrapped object. Then Strict, so now the Fake will reject all calls.

You'd then expect

I had the same issue, one of the reasons can be that your bean is brought by a dependency and to fix it you need to add an empty beans.xml in main/resources/META-INF in this dependency in order for Quarkus to discover the beans as indicated by the documentation

Relevant extract:

The bean archive is synthesized from:

• the application classes,

• dependencies that contain a beans.xml descriptor (content is ignored),

• dependencies that contain a Jandex index - META-INF/jandex.idx,

• dependencies referenced by quarkus.index-dependency in application.properties,

• and Quarkus integration code.

I see 2 problems in the configuration:

1. You just "build" the configuration, but don't start it. After buildConfiguration(), make sure to call 'start()' on the returned Configuration instance. Alternatively, directly call start() on the Configurer. It returns a started configuration instance.

   That should resolve the registrations not coming through. But it will probably trigger an exception related to the next issue....

2. Your MongoTokenStore configuration is incomplete. The TokenStore needs at least a serializer and a MongoTemplate instance. The latter tells the Axon which collections you want to certain types of information in. In your case, only the TrackingTokenCollection would be relant.

You have a couple of options. One is to use an ObservableObject that can have @objc functions and declare it as the delegate for the notifications:

Event-sourced systems by definition have a time lag between an event being stored in an event store, and it is projected to a read model. The lag is always there unless you apply the event synchronously to an in-memory read model when you commit the event to the store. But that approach would limit you to run your service as a single instance, otherwise, you cannot be sure that the in-memory state is synchronized. There are techniques to solve that, but they are rather complex.

As you don't describe the need for you to get the read model data immediately, it's hard to give specific advice, but I have some tips.

1. If you need it for the UI, and the UI needs the new entity state, you can return the entity state as the command handling result, as you already have it. Then, the UI can show the state immediately without executing any queries.

2. Same scenario, but you return a collection of new events to the UI. If the UI bit is built with something like React and Flux, they most probably already have "event sourcing" there (that's what Flux essentially is), and applying those events via their reducers they can update the UI without querying the read model.

3. If you know what read model needs to be in sync (I can't say how many you have), you can propagate the event commit position to the read model as a metadata property, or just as a document property. Then, you can hold the API call (basically wait) until the read model update position property gets equal to or more than the commit position. The drawback is that you can do it for a specific read model only, so your command handler needs to know too much about the read side.

4. Similar to (3) but you check the checkpoint store position. If the checkpoint store is not optimized with batching, it will soon pass over the last event commit position, then you return 200 OK to the caller. It's a bit easier than (3) as it only cares about the subscription checkpoint, not the single read model, but you need access to the checkpoint store.

5. The UI can do the same after they get the command handled, you need to return the commit position of the last event, and they query and wait.

I've seen all of the above working in production, but my preferred solutions are (1) and (2).

To make any of those work, your command service needs to return a sophisticated result to the caller (API, or beyond) as I've done in Eventuous.

In order to wrap callback-based API, you should use callbackFlow instead. It supports concurrent emissions, which I think is likely your problem here.

Also, it will properly handle the cancellation of the subscription when the flow itself is cancelled (via awaitClose()).

Here is one way to do it:

This online tool : https://configurator.eventstore.com/ should help you setup the configuration correctly

Answering my own question, but really the answer came from a discussion with Christian at Axon. (Will leave this open for a few days to allow for better answers, before accepting my own :))

My options #2 and #3 are the right answers: the difference depending on how different my "summary" projection is from my "detailed" projection. If they're close enough, option #2, if they're different enough #3.

Option #1 is non-ideal, because even if we were using state-stored for some other reason, basing queries on the state-store breaks the Segregation that is the 'S' in CQRS: it makes our query model depend on our command model, which can lead to problems when our model gets more complex.

(Thanks Christian)