Merlino.agency

I can't emphasize enough how learning and implementing the Clean Architecture in all our projects has saved—and is saving—us so much time in the development of new features, the testability of the system, and the general maintenance of their components. Implementing it will require a little effort in understanding how it works and will also generate a bit more files than just following, for example, the ExpressJS Getting Started guide. However, we will never go back. It served us so robustly that we'll just keep focusing on shipping. Now, let's start. Introduction The secret to building a large project that is easy to maintain and performs better is to separate files and classes into components that can change independently without affecting other components: this is what Clean Architecture is all about. Clean Architecture is an architectural style created by Robert C. Martin. It is a set of standards that aims to develop an application that makes it easier to quality code that will perform better, is easy to maintain, and has fewer dependencies as the project grows. Firstly, I will introduce what Clean Architecture is. We will then head to the development side of things to see how the engineering team at Merlino Software Agency developed OneFood and Isla using NodeJS/ExpressJS with a Clean Architecture. In the end, we will conclude how Clean Architecture makes a difference. According to Stack Overflow Insights of 2021, JavaScript completes its ninth year in a row as the most commonly used programming language. NodeJS is placed as the sixth most widely used tool, and Express JS, a minimal Node JS framework, got the third position as the most common web framework. Therefore, having your application in Express JS decorated with Clean Architecture is a blessing that leads to better performance and easy maintainability of the project. Let us have a quick introduction to Software Architecture before diving into it! What is Software Architecture Before providing a definition, consider that the actions people may do using systems on a daily basis — scheduling a Tweet to post, sending an automated transactional email, etc. — heavily depend on the Software Architecture of the system in use. Many things we know and use would be impossible without software architecture, but why is that? A system's architecture acts as a blueprint. It establishes a communication and coordination mechanism among components, gives an abstraction to control system complexity, and represents the design decisions related to overall system structure and behavior. In simple words, Software Architecture exposes a system's structure while hiding implementation details. Moreover, it also focuses on how the elements and components within a system interact with one another. The subject of Software Architecture appears to have sparked much attention in recent years. Furthermore, among the many different types and styles, Clean Architecture attracted more attention than the others. Let us head to the central part of the article and find out what Clean Architecture is. The Clean Architecture Microservices and serverless architecture have emerged as revolutionary architectural patterns in the software development world during the last several years. Each has its characteristics, behaviors, technological structure, and required expertise. However, they are all part of a broader desire for a better separation of architecture concerns and improved testability. Clean Architecture is a set of standards that aims to develop layered architectures that make it easier to write quality code that will perform better, is easy to maintain, and has fewer dependencies as the project grows. This architecture can be applied no matter what language you code in. The illustration below shows the four concentric circles that compose a Clean Architecture, how they interact with each other, and their dependencies. The Dependency Rule In the illustration above, please pay attention to the arrows, the fact that they are pointing from the outermost circle down into the innermost circle, and that they only go in one direction. The arrows represent the dependence flow, indicating that an outer ring can depend on an inner ring but that an inner ring cannot rely on an outer ring; this is what The Dependency Rule is all about. For example, Entities know nothing about all the other circles, while the Frameworks & Drivers, the outer layer, know everything about the inner rings. In simple words, variables, functions, classes, or any other named software entity declared in an outer circle must not be mentioned by the code in an inner circle. Four layers of Clean Architecture There are four concentric circles in Clean Architecture that each represents different areas of Software, which are as below: Entities Use Cases Interface Adapters Frameworks and Drivers The development team of Merlino also implemented another layer called Routes, and that's totally okay. If you find that you may need more than four, just go on. However, the Dependency Rule must always apply. So, the four layers become five layers in our case study, which are as below: Entities (Mongoose models and their abstraction) Use Cases Interface Adapters (Controllers) Routes Frameworks and Drivers Let us find out what each circle means along with our case study, but before diving in, here is the project's hierarchy; ```plaintext . │ README.md │ package.json │ ... │ └─── app │ │ app.js // 5. Framework and Drivers │ │ server.js // start master and forks other workers │ │ config.js // get config from env or config file │ │ database.js │ │ logger.js │ │ │ └─── models // 1.a) entities (i.e., Mongoose models) │ │ │ index.js │ │ │ orders.model.js │ │ │ ... │ │ │ └─── data-access // 1.b) entities (i.e., abstraction of Mongoose models) │ │ │ index.js │ │ │ orders.db.js │ │ │ ... │ │ │ └─── use-cases // 2) Use cases │ │ └─── orders │ │ │ │ index.js │ │ │ │ post-order.js │ │ │ │ ... │ │ └─── ... │ │ │ └─── controllers // 3) Interface Adapters │ │ │ order.controller.js │ │ │ ... │ │ │ └─── routes // 4) Routes │ │ │ order.routes.js │ │ │ ... │ └─── ... ``` 1. Entities At the center of the onion are the Entities of the software, which constitute the business logic of software. An entity can be an object with methods, or it can be a set of data structures and functions, they don't know anything about the outer layers and don't have any dependency. In simple words, Entities are the primary concepts of your business. When something external happens, Entities are the least likely to change. A change to page navigation or security, for example, would not be expected to affect these objects. The entity circle should not be affected by any operational changes to any application. If you're building a Social Media application, you might have entities like Posts, Comment, or User, or in the case of OneFood — a premium food delivery business and a client of ours — a few of their entities would be Customer, Order, Payment, Product, Vendor, etc. Important to consider is that since we use Mongoose, we'll also have model definitions, which are specific to this implementation and we'll soon see how to abstract them. All models are then exported like follows: All Entities can then be exported like this: ```javascript // /models/index.js import Orders from './orders.model'; // ... export { Orders, // ... }; ``` Then, in `data-access`, let's create an abstraction layer that allows us to decouple the database methods that we call in our application (i.e., `findOne`, insert`, etc.) from the type of database, in this case, MongoDB. We might want to change to a SQL database in the future and that'll be totally fine. One could argue that this is what Prisma does as a service. ```javascript // /data-access/orders.db.js // outside libraries are ok to import import {v4 as uuid} from "uuid"; import _ from "lodash"; export default function makeOrdersDb({Orders}) { async function findOne(_filter, _options = {}) { const {populate, sort} = _options; const query = Orders.findOne(_filter); if (sort) query.sort(sort); _.forEach(populate || [], (p) => query.populate(p)); return query.lean().exec(); } async function insert({id: _id = uuid(), ...orderInfo}) { return Orders.create({_id, ...orderInfo}); } async function update(_filter, _orderInfo) { return Orders.findOneAndUpdate(_filter, _orderInfo, {new: true}); } async function remove(_id) { const res = await Orders.deleteOne({_id}); return { found: res.n, deleted: res.deletedCount }; } async function find(_filter, _options = {}) { const {populate} = _options; const query = Orders.find(_filter); if (populate) _.forEach(populate || [], (p) => query.populate(p)); return query.lean().exec(); } async function aggregate(pipeline = []) { return Orders.aggregate(pipeline); } async function paginate(_query, _options) { const {sort, populate, page, limit} = _options; return Orders.paginate(_query, { sort, lean: true, page, limit, populate }); } return Object.freeze({ findOne, insert, update, remove, find, aggregate, paginate }); } ``` Several of these files would then be exported in their `index.js` like follows: ```javascript // /data-access/index.js // your DB model definitions, in OneFood's case they are Mongoose files import * as models from "../models"; import makeOrdersDb from "./orders.db"; const ordersDb = makeOrdersDb(models); export { ordersDb, ... }; ``` As you can see we are making the `models` available to their abstraction layer through Dependency Injection. Somewhere upstream, we have some code that will call the `ordersDb.findOne()` function and all the various dependencies required (i.e., `models`) will be automatically available. Dependency Injection has several advantages described below: The first advantage is Testability. By injecting dependencies, we can test our code independently of anything else. The other advantage is as the developer is writing this code, they do not need all of these dependencies to be ready. In this case, the developer can focus on the business logic of the Entity. The most important advantage of doing this is that the developer can change the implementation details of the project dependencies independently of this code. 2. Use Cases The Use Cases layer, which lies outside the Entities layer, contains login and rules related to the behavior and design of the system. In simple words, Use Cases are interactions between Entities. For example, suppose we are in our Social Media application example. In that case, we can have a Use Case like user posts, or in the OneFood application, a customer places an order. Changes to this layer should not affect the entities. Changes to externalities such as the database, user interface, or frameworks are unlikely to affect this layer. Let us check out the `/use-cases` directory and look at the Order's definition: ```javascript // /use-cases/orders/post-order.js export default function makePostOrder({ ordersDb, orderItemsDb, getPromoCodeDetails }) { return async function postOrder({body, headers, user}) { // Validate parameters... // Create order... // Create order items... return order; }; } ``` All Orders Use Cases can then be exported like this: ```javascript // /use-cases/orders/index.js import { ordersDb, // ... } from 'data-access'; import Config from 'config'; import makePostOrder from './post-order'; // ... const postOrder = makePostOrder({ ordersDb, Config, // other injected dependencies ... }); // Export a service containing all Use Cases ... const orderService = Object.freeze({ postOrder, // ... }); export default orderService; // ... and also every Use Case singularly export { postOrder, // ... }; ``` 3. Interface Adapters The Interface Adapters or the Adapter layer holds the controllers, APIs, and gateways. The Interface Adapters govern the flow of communication between external components and the system's back-end. In simple words, Interface Adapters are isolating our various Use Cases from the tools that we use. Let us look at the controllers directory and choose `OrderController` by sample to see what's going on: ```javascript // /controllers/order.controller.js import { postOrder, // ... } from 'use-cases/orders'; import { postPaymentLink } from 'use-cases/payments'; export default Object.freeze({ postOrder: (httpRequest) => postOrder(httpRequest, postPaymentLink), // ... }); ``` 4. Routes The `/routes` folder is where you can organize all of your different REST endpoints declarations. The file below exposes all available endpoints related to the `Orders` Entity: ```javascript // /routes/order.routes.js import express from 'express'; import controller from 'controllers/api/orderController'; import makeExpressCallback from 'routes/make-callback'; const router = express.Router(); router.route('/order').post(makeExpressCallback(controller.postOrder)); router.route('/order/:orderId').get(makeExpressCallback(controller.getOrderById)); // ... export default router; ``` Bonus: you may have noticed the `makeExpressCallback` function in the code. That is a wrapper function that: receives `req` and `res` as inputs from Express's `.post()`, `.get()`, etc. functions of each endpoint. creates a clean request object with all possible useful information needed by controllers and feeds them with it (i.e., `controller.postOrder`); handles whatever it's returned by controllers (i.e., data or errors), and replied to clients in a standardized way. Check this file out: ```javascript import * as Sentry from '@sentry/node'; export default (controller) => (req, res) => { const httpRequest = { body: req.body, query: req.query, params: req.params, ip: req.ip, method: req.method, path: req.path, user: req.user, logger: req.logger, source: { ip: req.ip, browser: req.get('User-Agent') }, headers: { 'Content-Type': req.get('Content-Type'), Referer: req.get('referer'), 'User-Agent': req.get('User-Agent') } }; // req.user coming from 'policies/token.js', // after the JWT token is parsed if (req.user) { Sentry.setUser(req.user); } else { Sentry.configureScope((scope) => scope.setUser(null)); } controller(httpRequest) .then((httpResponse) => { res.set('Content-Type', 'application/json'); res.type('json'); const body = { success: true, code: 200, data: httpResponse }; res.status(200).send(body); }) .catch((e) => { Sentry.captureException(e); res.status(400).send({ success: false, code: 400, error: { description: e.message } }); }); }; ``` Then, let's export all routes: ```javascript // /routes/index.js import express from 'express'; import token from 'policies/token'; import orders from './orders'; // ... const router = express.Router(); // Bonus: you can split this /routes folder in 2: private and public. // In the private index.js file you would precede all routes declaration // with a function that checks if the authentication token is present // in all requests and it's valid. router.use(token); router.use(orders); export default router; ``` 5. Frameworks and Drivers The Frameworks and Drivers, also known as the Infrastructure Layer, is the outermost layer that provides all necessary details about frameworks, drivers, and tools such as Databases that we use to build our application. All the details of the system go in this layer. For example, in the case of the OneFood application, the engineering team used Express JS as the framework and Mongoose (MongoDB) for Node JS as the database framework. The entry point to the entire application is the `app.js` file. This is where we use the Express JS framework. You will see many `import` statements, initialization of Express server, using the `routes` middleware, and finally exporting the `app` module. ```javascript // app.js import express from 'express'; import routes from "routes"; // other imports // initialize express server const app = express(); app.use("/", routes); export default app; ``` Conclusion Following these guidelines is simple and will save you from a lot of trouble in the future. By separating Software into layers and obeying the Dependency Rule, you will create Software that is more: Testable Maintainable Independent of a framework Independent of a database Independent of UI ... and independent of any other tools and drivers Keep in mind that there's no boundary of having just four circles/layers. If you find that you may need more than four, just go on. However, the Dependency Rule must always apply.

Merlino.agency

Type the way you talk

Clean Architecture in ExpressJS Applications (NodeJS)

A Step by Step Guide on How to Download a CSV File using Angular

Merlino Software Agency Receives Second Clutch Review, Earns Second 5-Star Review

Services

Projects

Other

Subscribe now to Merlin Coding