CommandBus | package provides an opinionated base

I see there's some confusion between the various Buses and the Event Store. Before attempting to implement an Event Bus, you need to answer one important question that lies at the foundation of any Event Sourcing implementation:

• How to preserve the Event Store as the Single Source of Truth?

That is, your Event Store contains the complete state of the domain. This also means that the consumers of the Event Bus (whatever it ends up being - a message queue, a streaming platform, Redis, etc.) should only get the events that are persisted. Therefore, the goals become:

• Only deliver events on the Bus that are persisted to the Store (so if you get an error writing to the Store, or maybe a Concurrency Exception, do not deliver via bus!)
• Deliver all events to all interested consumers, without losing any events

These two goals intuitively translate to "I want atomic commit between the Event Store and the Event Bus". This is simplest to achieve when they're the same thing!

So, instead of thinking about how to connect an "Event Bus" to command handlers and send events back and forth, think about how to retrieve already persisted events from the Event Store and subscribe to that. This also removes any dependency between command handlers and event subscribers - they live on different sides of the Event Store (writer vs. reader), and could be in different processes, on different machines.

So after a couple days I managed to find two approaches to connecting to an external eventbus. I found out that I don't really need an external command or query bus as these come in through API calls. So if you want to connect to an external eventbus with NestJS here are the two options I found:

1. Via a custom publisher & subscriber
2. Via the NestJS Microservice package

The two approaches mainly differ in the way they connect to the external eventbus and how they handle incoming messages. Depending on your needs one might suit you better than the other, but I went with the first option.

Custom publisher & subscriber

In my application I was already using manual publish calls to my eventbus by using the EventBus class from NestJS and calling .publish() for my events. I created a service that wrapped around the local NestJS eventbus together with the custom publisher and custom subscriber.

eventBusService.ts

The issue was Assembly scanning in .net core 3.1. The old - non working way:

I think it is a good idea to have Microservices communicate with each other asynchronously and in practice I also use this appraoch with a mix of orchestration and choreography depending on the use cases.

Concerning the public API which you expose to your clients (e.g. web clients) over the internet it really depends on the determining factors and the options you are given. If your clients require REST based communication I would recommend to provide a fast response to the client synchronously by just providing the information that it went through Ok and some kind of unique id.

So if you think of an order request of an online shop the API gateway would forward the request to the order Microservice (either via REST or in your case via Messaging and some translation from asynchronous to synchronous response at the API gateway layer). Anyway, there should be some kind of immediate response to the client the order service can provide which could simply contain the id of the new order. Everything else for processing the order will than happen asynchronously either completely via an event-based choreography (started by an OrderRequestReceived event or whatever name fits the domain language) or via some kind of workflow orchestrated by the order service (but still with asynchronous messaging).

The client can then always use the order id to query the current state of the order which you will than provide based on the read model you are building.

If you are free to implement the client the way want you can also look into WebSockets, using HTTP/2 to allow for pushing of status changes rather than requiring the clients to poll for the current state. Or you could even look into gRPC...

The ContainerManagedEntityManagerProvider instance created by Axon, if you are using the Spring Boot Starter, through the JpaAutoConfiguration looks as follows:

this is determined when you're calling a function. How are you invoking your handle method?

Consider this example:

Generic functions in TypeScript act as a function representing every possible specification of its generic type parameters, since it's the caller of the function that specifies the type parameter, not the implementer:

The reason for the deadlock is rather simple:

• There is one code loop (not a specific thread; see below) that is responsible for processing the queue. As it processes each command, it awaits that command's handler.
• There is a command handler that awaits another command to be handled. However, this cannot work because no further commands will be processed; the code loop will not dequeue the next command until this one completes.

Put another way, it is not logically possible for one command to execute another command if commands can only be executed one at a time.

There's a few possible approaches to solving this problem. I do not recommend the "re-entrant" approach; reentrancy is the cause of many subtle logic bugs. The approaches I would recommend are one of:

1. Change the Send semantics so that they're a "queue" semantic. This means it's not possible to get command results; results would have to be sent as a message through some mediator.
2. Have the code loop not await the command handler, allowing it to loop back and pick up the next command. This means it doesn't "synchronize one at a time" any more.
3. Redefine "synchronize one at a time" to mean "one at a time but if it's awaiting then it doesn't count as one". In that case, you can probably use something like ConcurrentExclusiveSchedulerPair or Nito.AsyncEx.AsyncContext to run the method chunks one at a time.

Side note: LongRunning doesn't do what you think it's doing. StartNew is not async-aware, so the LongRunning flag only applies to the code up to the first await; after that, the code in that lambda will run on arbitrary thread pool threads (without LongRunning set). Replacing StartNew with Task.Run will make the code more clear.

So, this took my some investigation to get a hunch what is going wrong, but I know what the problem is. Quick notice, it's not an Axon specific thing, rather the plugin you are using.

I ran your sample project and indeed ended up with the same result; no Axon beans were being wired, ever. That led me to investigate the process of creating fat JAR's step by step. First Maven, then Spring Boot with Maven, then Gradle with Spring Boot and finally with the Shadow plugin you are referring too.

This endeavour landed me on this issue, which states as much as "projects which require the use of META-INF files need to add this to the shadow plugin, and this should be documented".

The portion referenced through this is the following: