Search for a command to run...
Clean Architecture Series - Frameworks Layer
I'm an enthusiastic Chilean software engineer in New Zeland. I mostly focus on the back-end of the systems. This is my site, Señor Developer, where I share my knowledge and experience.
In this series, I will show you the clean architecture system and how to implement it in nodejs and typescript.
Clean Architecture Series - Frameworks Layer
Quilla Frontend Kit turns recurring API, authentication, and server-state concerns into composable TypeScript packages.
Quilla Backend Kit provides the foundations for structured TypeScript services while leaving the application architecture in your hands.
Practical constraints for preserving the framework’s boundaries, dependency direction, and readability as a test suite grows.
A tool-agnostic approach to separating test intent from UI mechanics as an automation suite grows.
In this article, we will go through the entire process of set up Visual Studio Code for debugging “Deno” programs using “V8 Inspector Protocol”. Step-by-step, we will be learning how to configure VSCode to debug a Deno project. If you don’t know Deno...
The communication between the underlying application and clients (such as web browsers or mobile apps) in the outside world is handled by the web server layer. It receives queries from other sources, processes them, and sends back the relevant answers. It includes parts such as views, middleware, controllers, and routers.
We will start creating the folder structure for our web server layer. So, go to frameworks folder and create a new folder named "webserver" with a subfolder named "express".
Before setup the web server framework, we will create an interface which ensure that any server implementing the IServer interface contract. So, create a file named "server.interface.ts" into the "webserver" folder:
// .src/frameworks/webserver/server.interface.ts
export interface IServer {
port: number;
bootstrap: () => Promise<void>;
listen: () => Promise<void>;
}
Let's explain the interface:
port: Define port number which the server use to listens the connections.
bootstrap: The bootstrap method allows to implement what "staffs" the server needs to do before start. For example: Load middlewares or routes.
listen: The listen method allows to implement how the frameworks start listening the connections.
For our project we will use ExpressJs as the web framework:
Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications...
To define how our web server handles client requests we have to implement the ExpressJs Router. So, create a file named "api.router.ts" into the "express" folder:
// .src/frameworks/webserver/express/api.router.ts
import { CreatePolicyController } from "@/adapters/controllers/policy/create-policy.controller";
import { ExpressAdapter } from "@/adapters/http/express.adapter";
import { IHttpRequest } from "@/adapters/http/http-request.interface";
import { SqliteDb } from "@/frameworks/persistence/db/sqlite/sqlite.db";
import { PolicyRepository } from "@/frameworks/persistence/repositories/policy/policy.repository";
import { Router } from "express";
// create the router object
const router = Router();
// get the sqlite database instance
const sqliteDb = SqliteDb.getInstance();
// create the repository and inject the db dependency
const policyRepository = new PolicyRepository(sqliteDb);
// create the controller and inject the repository dependency
const createPolicyController = new CreatePolicyController(policyRepository);
export const apiRouter = () => {
router
.route("/policy")
.post(
// adapting the incoming request and calling the controller function
ExpressAdapter.controller((httpRequest: IHttpRequest) =>
createPolicyController.execute(httpRequest)
)
);
return router;
};
As you remember, the repository and controller are using "Inversion of Control" (IoC) and DI (Dependency Injection) for this reason, before create every object we have to satisfy their constructor dependencies.
The "apiRouter" constant encapsulates the logic to handle the "/policy" route for "POST" http method. Also, we use the "ExpressAdapter" to adapt the incoming request and call the controller function and inject the httpRequest object.
To implement express as web server we need to create a file named "server.ts" into the "express" folder:
// .src/frameworks/webserver/express/server.ts
import express from "express";
import { apiRouter } from "./api.router";
import { IServer } from "../server.interface";
export class Server implements IServer {
port: number;
private framework: express.Application;
constructor(port: number) {
this.port = port;
this.framework = express();
}
async bootstrap(): Promise<void> {
// Builtin Express Middleware
this.framework.use(express.json());
// Routers
this.framework.use(apiRouter());
}
async listen(): Promise<void> {
this.framework.listen(this.port);
}
}
bootstrap: The "bootstrap" method is setting the express json middleware which parses incoming requests with JSON payloads. And also, this method is loading the API Routes.
listen: The "listen" method encapsulate the logic related to how the "ExpressJs Framework" needs to be configured to listening for connections.
The web server layer is isolated from the core business logic and focuses solely on handling the communication aspects.
And thats all for the web server layer, see you in the next article.