One last video on the overall design of this application.
So first I want to show you a list of the different events are going to create.
We're going to have events like user created user updated ticket created ticket updated everything you
see on this list right here.
Now some these events might not make a lot of sense right now but over time we're going to have a very
deep discussion about the goal of each of these different events.
You'll notice that right now they all kind of seem more or less kind of simple in nature in the name
of each of them is kind of self-evident.
So we're going to emit events like say order expired whenever a order goes over that 15 minute limit.
I just want to give you this list of events right now just to give you a picture of some the different
events we're going to create.
But the absolute definition of each one is not super important right now on that just one last quick
diagram here.
So this is going to be just a couple of notes on the overall design of each service.
So we are going to have once again a kind of react client application that is going to be in charge
of showing some content inside the browser this time around this react application is going to be built
using next.
J.S. if you are not familiar with Next j ust at all don't sweat it.
Next is a server side rendering react framework.
There's a very very good reason that we're going to use server side rendering in this application.
We'll discuss why that is.
As soon as we start building that react application were then going to have our order tickets.
Orders payments and expiration services that are all going to be essentially simple node servers each
one of them is going to be running express very similar to how we've been doing.
On that first project this time around each of these different services are going to have some persistent
storage in the form of Mongo DB Now absolutely we could use a database besides Mongo DB and some of
these but we're just going to stick with Mongo DB all the way through because this is not really course
about teaching you the basics of database design or something like that we could have some of these
services using Mongo and maybe one over here using most grass or what have you but we're going to stay
consistent and use Mongo all the way through do notice that the expiration service on the other hand
is going to be making use of readies you have not used threats again.
Don't sweat it.
Super easy to learn and pick up we're using readies on expiration for a very very particular reason
and you'll see why as soon as we start building out that service each of these different services are
going to be making use of a shared common library.
So we're going to refer to this common library right here simply as common just about everything else
inside this diagrams are a reference to a technology or something like that.
In this case common is going to be an NPM module that you and I are going to build to share a bunch
of code among these different services.
So we're going to be putting a lot of time into this com library to figure out some of the different
middle wares and events.
Who knows what else we're going to need that are going to be commonly used between all these different
services.
And then finally or an event bus rather than building our own this time around we're going to be using
something else called the Nats streaming server.
Now the term Nats right here if you've ever done some router setup like a home router I'm not talking
about an express router I'm talking about an actual Wi-Fi router or a networking router.
You might have heard of something called Nat like network address translation that is totally different
than that streaming server.
So if you have heard of the term Nat not the same as Nat streaming server.
Essentially this is an event bus somewhat similar nature to the one that we built just a little bit
ago.
Of course it's very very different in its implementation tremendously different but it's more or less
going to do the same thing as the event plus we put together a little bit ago it's gonna receive some
events from our services and then echo those events out to all of our other services.
That's pretty much it okay.
So again I'm just showing this diagram to give you a picture of what we're going to have to do for this
application.
So one more pause right here.
We're gonna start writing some code and doing some setup in just a moment.