Search for a command to run...
Clean Architecture Series - Adapters 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 adapters layer is responsible for interacting with the outside world. It acts as a bridge between the business logic (use cases) and the external systems. For example, In a web application, It takes the incoming requests and transforms them into a format that the use cases can understand.
To handle our create policy feature, we need to create a controller to mapping the web server routes of the CreatePolicy endpoint which we will define in the framework layer with ExpressJS.
So, go to the "adapters" folder and create a new folder named "controllers/policy" with a "create-policy.controller.ts" file.
import { IHttpRequest } from "@/adapters/http/http-request.interface";
import { HttpResponse } from "@/adapters/http/http-response.type";
import { IPolicyRepository } from "@/domain/policy/policy-repository.interface";
import { CreatePolicyUseCase } from "@/use-cases/policy/create-policy.use-case";
export class CreatePolicyController {
constructor(private policyRepository: IPolicyRepository) {}
async execute(httpRequest: IHttpRequest): Promise<HttpResponse> {
try {
const createPolicyUseCase = new CreatePolicyUseCase(this.policyRepository);
const policy = await createPolicyUseCase.execute({ ...httpRequest.getBody() });
return { httpCode: 201, payload: policy };
} catch (error) {
return {
httpCode: 500,
error: {
name: "CreatePolicyController",
message: "Error",
details: error.message,
},
};
}
}
}
The constructor injection ensures that the controller cannot be instantiated without its necessary dependencies. In this case, we have the IPolicyRepository dependency which is required by controller to create the "CreatePolicyUseCase" instance.
By accepting dependencies through a setter method, rather than the constructor, allows ExpressAdapter to manipulate each incoming request.
The "execute" method injects the use case dependencies, pass the body data and call the execute method of the use-case.
Finally, in case of success, it returns 201 with the new Policy entity object else an error object according to the HttpResponse type is returning.
These interfaces allows us to use the Inversion of Control (IoC) principle and Dependency Injection (DI) technique to delegate the responsibility of handling dependencies and object creation to the external layers.
We are using the IHttpRequest interface as parameter of the execute method to ensure that our controller is agnostic on any framework or library. And the IPolicyRepository interface as a dependency in the constructor to leave open the option to switch between repository implementations.
\ We can switch from one specific implementation to another easily (Ex. replace Expressjs with Fastifyjs or replace Sqlite3 with another DB).*
Let's create the HttpRequest Interface file named "http-request.interface.ts"
//src/adapters/http/http-request.interface.ts
export interface IHttpRequest {
getBody: () => any;
}
We only define one interface member named getBody to handle the body data from the "ExpressRequest" Function (we will use it in the Express Adapter section).
\You can define more members of the interface if you wanted to have more control over the Request. For example: getHeaders to handle the Request's Headers.*
As we chose Expressjs as web server, a package of our frameworks layer, we need to create an adapter to adapt the ExpressJS's request-response cycle.
So, go to the "adapters" folder and create a new folder named "http" with a "express.adapter.ts" file.
import {
Request as ExpressRequest,
Response as ExpressResponse,
NextFunction as ExpressNextFunction,
} from "express";
import { IHttpRequest } from "./http-request.interface";
import { HttpResponse } from "./http-response.type";
export class ExpressAdapter {
static controller(fn: (...args: any) => Promise<HttpResponse>) {
return (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => {
fn(ExpressAdapter.adaptRequest(req))
.then((httpResponse: HttpResponse) => {
const { httpCode, ...rest } = httpResponse;
res.status(httpCode).json(rest);
})
.catch((error: Error) => {
res.status(500).send(error.message);
});
};
}
static adaptRequest(req: ExpressRequest): IHttpRequest {
return {
getBody: () => req.body,
};
}
}
The "controller" method create and return a middleware function to handle the "Expressjs" request-response" cycle. It has access to "Expressjs" objects and allows to use the ExpressRequest, ExpressResponse and ExpressNextFunction:
...
static controller(fn: (...args: any) => Promise<HttpResponse>) {
...
return (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => {}
Then, calls the provided function from the "fn" parameter and adds the adapted request object according the IHttpRequest interface:
fn(ExpressAdapter.adaptRequest(req))
.then((httpResponse: HttpResponse) => {
const { httpCode, ...rest } = httpResponse;
res.status(httpCode).json(rest);
})
.catch((error: Error) => {
res.status(500).send(error.message);
});
\The "fn" parameter represents the controller method.*
As the "fn" returns a Promise, this method registers "then" and "catch" functions:
Then: When "then" function is calling, the adapter takes the controller's ("fn") response and use the ExpressJs response object to generate the http response with the controller response data as a json object.
Catch: When "catch" is calling, the adapter takes the controller's ("fn") error and use the ExpressJs response object to generate the http response with the controller response data.
\We only use the 500 error for everything to simplify the error handling. You could improve it having custom exceptions as you need.*
Last but not least, the HttpResponse type file named "http-response.type.ts":
// ./src/adapters/http/http-response.type.ts
export type HttpResponse = {
httpCode: number;
error?: {
name: string;
message: string;
details: any;
};
payload?: any;
};
This type allows us to define a common response object for the API response.
Now the adapter layer is ready to be integrated in our Clean Architecture project.
See you in the next article.