#Indirection stickers how to
#Indirection stickers software

The DTOs act as a layer of indirection and shield the clients from internal changes to the way the API is resolved.

We've implemented architectural dependency inversion between the client and the server.

The DTOs become a strict contract for our API.

Now instead of relying on the server (and everything the server relies on), the clients rely only on the DTOs. We decide that it would make more sense to have something like this instead:Д¬onst GetCurrentUserController = ( sequelize ) => Advantages to this approach We're here today and we want to refactor it.

The design got us to this point, and that's what matters. A module should be open for extension but closed for modification, right? But it seems that every time we want to add a new role (ie: extend this entity's use case), we have to modify it directly (by adding a new column to the database in the form of an is structure).

#Indirection stickers software

The user entity has become somewhat coupled the specifics of other subdomains ( students, jobs).ДЄn astute software designer may also recognize that this is a violation of the Open-Closed principle. We realize that we're moving towards having more and more roles and that hard-coding the roles as a part of the user entity actually breaks domain encapsulation. We want to change the APIДЄfter months of living with our design, we realize that we don't like it - particularly the isAdmin, isStudent, isEmployer part.

Consider that client teams have used our API and built things on top of it already. But let's imagine that this is what we've chosen and it's been like that for quite some time now. A trivial RESTful API controllerД¬onsider this very stripped down, simple controller that pulls the current user and returns a raw Sequelize ORM object as a result of the GetCurrentUser RESTful API call.Д¬ool.

#Indirection stickers how to

Let me walk you through a real-world example of how to use DTOs - Data-Transfer Objects to introduce stability and protect clients from change in a RESTful API. Since my application depends on the browser, it means I'll always have to keep on top of things the browser does that could cause my app to break. In fact, just this week, I realized that the browsers introduced a new security feature called strict-origin-when-cross-origin that was stopping solidbook.io readers from getting into the online Wiki. A substantial change could break the entire client. It puts the clients in an awkward position of needing to constantly keep on top of the latest changes to the server and protect itself against failure. It means that if, for some reason, the server were to change things or break, that change or breakage has the potential to ripple into each client that relies on it. In this dependency relationship, the clients rely on the server. They have a web, mobile, and desktop app. This usually means that the client relies on the server.ДЄnd if we're being realistic, it's a lot more likely that there will be several clients that rely on the server (like a web, mobile, and desktop client).

Most web applications implement the client-server architecture. This means that components (whether it be a class, object, package, server, or client application) typically rely on other components to do something meaningful. To understand the concept of indirection, we need to understand the fact that software doesn't do a whole lot unless we can connect things together. I'm not sure about all, but if the structural problems in software design can be reduced to being either an issue with coupling or cohesion, then yeah - this makes a lot of sense. Have you ever heard the expression that ' all problems in computer science can be solved by adding another layer of indirection'?