How to approach Redux + Microservices intercommunication - redux

Question

We are implementing an auction cloud service, that will receive orders, from an external API service on demand. Each received order is a 1:1 to an auction.
We can have more than 2000 orders (auctions) per day.
we have decided to use Microservices + Redux to separate concerns between orders and auctions.
Bellow are the explanation of each service.
External API
Enternal API is just a website that pushes orders to our Order Service and receive updates from our Order service we have no control over it.
Order service
Orders has a bunch of information (properties) that the client (mobile app) use to get information to decide on joining an auction. for example, this is how an order can look like:
{
id: 123,
description: 'Some description',
salePrice: 0,
minPrice: 1000,
openPrice: 500,
status: 'active',
address: 'Some address',
file: '.../some-file.pdf',
client: 'Joe Doe',
notes: 'Some notes',
createdAt: '12345678',
pending: false,
postpone: false,
...moreproperties
}
In the order service the orders can be updated (address, name, openPrice, minPrice, status, etc) by the server at any time before the auction starts via the actions bellow.
{ type: LOAD_ORDERS, orders }
{ type: PEND_ORDER, id }
{ type: POSTPONE_ORDER, id }
{ type: SET_ORDER_AUCTION, id, auction, salePrice }
{ type: UPDATE_ORDER, id, properties }
Auction Service
An auction object in this service can look like this:
{
id: 'abcd',
orderId: 123456,
increment: 1,
outBid: { agentId: 'b1', price: 545 },
bestBid:{agentId: 'b2', price: 550 },
openPrice: 500,
currentPrice: 550,
status: 'started'
startedByAgent: 'a1'
}
Auctions can be updated by these actions:
{ type: JOIN_AUCTION, id, agentId, type }
{ type: START_AUCTION, id, agentId }
{ type: PLACE_BID, id, agentId, price }
{ type: END_AUCTION, id, agentId }
API Service
It works just as gateway between front end app and the microservices. Receive and dispatch requests from clients (mobiles) to Order Service or Auction Service in form of actions.
Workflow:
1 - External API push orders of the day to Order Service via LOAD_ORDERS also a CREATE_AUCTIONS action is dispatched to the Action Service to create an auction for each order.
2 - User open mobile app and get the list of orders of the day with details including open prices from Order Service.
3 - User join an specific order
- API Service creates a bidder agent that will place bids.
- API Service send a join action via JOIN_AUCTION to join an auction on the Auction Service
4 - An auctioneer agent starts the auction and bidding starts.
5 - Joined bidder agents starts to place bids via PLACE_BID action on Auction Service.
6 - When auction is over the auctioneer agent ends the auction by dispatching END_AUCTION.
7 - When auction ends sale price and auction details (via object) are send to the Order Service via the SET_ORDER_AUCTION.
8 - The Order Service handle the SET_ORDER_AUCTION and update the order state with the final salePrice and the auction object and then wait for payment.
9 - Once payment info is received from the client then it is submitted to the External Service by Order Service
My questions are:
Is the workflow above a reasonable approach for using Microservices + Redux and updating each service state?
It is ok to dispatch actions from a microservice to another when using redux microservices? My question is because when using microservices + event sourcing + CQRS, services intercommunication are not recommended but instead using a Sagas that work as intermediate service that convert events to commands.
My other question is where to put business logic (validation), for example a bidder cannot send bid if auction is not started or its already ended, a bidder cannot send a bid if he/she has not joined the auction yet. Were to put this logic? in action, middleware or reducers? and how to handle errors back to clients?
In general what are some best practices when it comes to Microservices + Redux?
What are pros and cons of using Microservices + Redux vs Microservices + Event sourcing + CQRS?
Sorry for the long post, I just need some orientation here because I cannot find any documentation about this topic and I am not sure if I am approaching this right.
Any advice would be appreciated!!!

Answer 1

I think this questions is way off the guidelines.
Nevertheless, I'd say write your own redux middleware to integrate your microservices; the API is very simple:
store => next => action => {
let result = next(action)
return result
}
In the most outer function (store =>) you can add microservice listerner and dispatch actions via the store reference.
In the innermost function (action =>) you can react to actions in the redux app by sending requests to your microservices.