DEV Community: John Piedrahita

Microservices using Kafka and clean architecture

John Piedrahita — Sun, 02 Jan 2022 22:56:35 +0000

Here is the high-level architecture of this simple asynchronous processing example with 2 microservices.

Microservice 1 - is a REST microservice which receives data from a /POST HTTP call to it. After receiving the request, it retrieves the data from the HTTP request and saves it to Kafka. After saving, it responds to the caller with the same data sent via /POST

Microservice 2 - is a microservice which subscribes to a topic in Kafka, where Microservice 1 saves the data. Once a message is consumed by the microservice, it then saves the data to MongoDB.

Microservice Rest
Microservice Kafka Mongo
Application flow

First, you must configure your local environment for the Kafka server.

You must create a directory where the two projects are managed.



mkdir tsclean-kafka-mongo

After this, we generate the two projects for the microservices. We will continue using the NPM package @tsclean/scaffold



npm i -g @tsclean/scaffold

Microservice Rest

We created the first project that will manage the Rest microservice.



scaffold create:project --name=api

We start by creating the entity User.



scaffold create:entity --name=user



export type UserModel = {
    id: string | number;
    name: string;
    email: string;
}

export type AddUserParams = Omit<UserModel, 'id'>

Then we create the interface that will communicate with the Kafka Adapter.



scaffold create:interface --name=add-user --path=models



import {AddUserParams, UserModel} from "@/domain/models/user";

export const ADD_USER_REPOSITORY = "ADD_USER_REPOSITORY";

export interface IAddUserRepository {
    addUser:(data: AddUserParams) => Promise<UserModel>
}

We create the service where the business logic of the microservice is to go.



scaffold create:service --name=add-user



import {AddUserParams, UserModel} from "@/domain/models/user";

export const ADD_USER_SERVICE = "ADD_USER_SERVICE";

export interface IAddUserService {
    addUser:(data: AddUserParams) => Promise<UserModel>
}



import {Adapter, Service} from "@tsclean/core";
import {IAddUserService} from "@/domain/use-cases/add-user-service";
import {AddUserParams, UserModel} from "@/domain/models/user";
import {ADD_USER_REPOSITORY, IAddUserRepository} from "@/domain/models/contracts/add-user-repository";

@Service()
export class AddUserServiceImpl implements IAddUserService {
    constructor(
        @Adapter(ADD_USER_REPOSITORY)
        private readonly addUserRepository: IAddUserRepository
    ) {
    }

    async addUser(data: AddUserParams): Promise<UserModel> {
        return await this.addUserRepository.addUser(data);
    }
}

Now we create the Kafka adapter to communicate with the domain layer where the business logic is. We do this by means of one of the SOLID principles, Dependency Inversion.



scaffold create:adapter --name=kafka



import dotenv from "dotenv";
import {Kafka} from "kafkajs"

import {AddUserParams, UserModel} from "@/domain/models/user";
import {IAddUserRepository} from "@/domain/models/contracts/add-user-repository";

dotenv.config({path: ".env"})

export class KafkaAdapter implements IAddUserRepository {

    public kafka = new Kafka({
        clientId: process.env.KAFKA_CLIENT_ID, brokers: ["localhost:9092"]}
    )
    public producer = this.kafka.producer()

    async addUser(data: AddUserParams): Promise<UserModel | any> {
        const topic = process.env.KAFKA_TOPIC;
        await this.producer.connect()

        let i = 0

        try {
            await this.producer.send({
                topic,
                messages: [
                    {
                        key: String(i),
                        value: JSON.stringify(data),
                    },
                ],
            })
            i++
        } catch (err) {
            console.error("could not write message " + err)
        }
    }
}

We make the configurations in the file @/infrastructure/driven-adapters/providers/index.ts.



import {ADD_USER_SERVICE} from "@/domain/use-cases/add-user-service";
import {AddUserServiceImpl} from "@/domain/use-cases/impl/add-user-service-impl";
import {KafkaAdapter} from "@/infrastructure/driven-adapters/adapters/kafka-adapter";
import {ADD_USER_REPOSITORY} from "@/domain/models/contracts/add-user-repository";

export const adapters = [
    {
        provide: ADD_USER_REPOSITORY,
        useClass: KafkaAdapter
    }
]

export const services = [
    {
        provide: ADD_USER_SERVICE,
        useClass: AddUserServiceImpl
    }
]

We, create the controller with the microservice entry point.



scaffold create:controller --name=add-user



import {Mapping, Post, Body, Adapter} from "@tsclean/core";
import {AddUserParams, UserModel} from "@/domain/models/user";
import {ADD_USER_SERVICE, IAddUserService} from "@/domain/use-cases/add-user-service";

@Mapping('api/v1/add-user')
export class AddUserController {

    constructor(
        @Adapter(ADD_USER_SERVICE)
        private readonly addUserService: IAddUserService
    ) {
    }

    @Post()
    async addUserController(@Body() data: AddUserParams): Promise<UserModel | any> {
        await this.addUserService.addUser(data);
        return { message: "User created successfully" }
    }
}

Finally, we include the configuration in the main container of the application.



import {Container} from "@tsclean/core";
import {controllers} from "@/infrastructure/entry-points/api";
import {adapters, services} from "@/infrastructure/driven-adapters/providers";

@Container({
    providers: [...services, ...adapters],
    controllers: [...controllers]
})

export class AppContainer {}

Microservice Kafka Mongo

The important thing in this code is the consumption from Kafka, so we have this decoupled microservice and in case of a change, do it only in this component.

We created the second project that will manage the Rest microservice.



scaffold create:project --name=kafka-mongo

We create the entity user to normalize the data to be persisted in Mongo



scaffold create:entity --name=user



export type UserModel = {
    id: string | number;
    name: string;
    email: string;
}

export type AddUserParams = Omit<UserModel, 'id'>

Now we create the adapters for the consumption of the Rest microservice.



scaffold create:adapter-orm --name=user --orm=mongoose



import {model, Schema} from "mongoose";
import {UserModel} from '@/domain/models/user';

const schema = new Schema<UserModel>({
        id: {
            type: String
        },
        name: {
            type: String
        },
        email: {
            type: String
        }
    },
    {
        strict: false
    }
);

export const UserModelSchema = model<UserModel>('users', schema);

This adapter will consume all messages arriving from the other microservice and store them in the database.



scaffold create:adapter --name=kafka



import {Kafka} from "kafkajs"
import dotenv from "dotenv";
import {UserModelSchema} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/models/user";

dotenv.config({path: ".env"})

export class KafkaAdapter {

    public kafka = new Kafka({clientId: process.env.KAFKA_CLIENT_ID, brokers: ["localhost:9092"]})
    public consumer = this.kafka.consumer({ groupId: process.env.KAFKA_CLIENT_ID })

    async consume(): Promise<any> {
        const topic = process.env.KAFKA_TOPIC;

        await this.consumer.connect()
        await this.consumer.subscribe({topic})

        await this.consumer.run({
            eachMessage: async ({ message }) => {
                await UserModelSchema.create(JSON.parse(message.value.toString()))
                console.log(`User created successfully: ${message.value}`)
            },
        })
    }
}

export const Consumer = new KafkaAdapter();

Finally, we import the adapter in the file that starts the application.



import 'module-alias/register'

import helmet from 'helmet';
import { connect } from 'mongoose';
import { StartProjectInit } from "@tsclean/core";

import { AppContainer } from "@/application/app";
import {MONGODB_URI} from "@/application/config/environment";
import {Consumer} from "@/infrastructure/driven-adapters/adapters/kafka-adapter";

async function run(): Promise<void> {
  await connect(MONGODB_URI);
  console.log('DB Mongo connected')
  const app = await StartProjectInit.create(AppContainer);
  app.use(helmet());
  await Consumer.consume();
  // This line is not necessary for the consumer
  // await app.listen(PORT, () => console.log('Running on port: ' + PORT))
}

run().catch();

Application flow

We run the api microservice



npm run watch

Here is the log you will see in microservice rest. Once you see this, it means data has been received from Postman and saved to Kafka

Since we are not running microservice kafka-mongo yet, the data saved by microservice rest will only be in Kafka. Let's consume and save to MongoDB by running microservice kafka-mongo.



npm run watch

Now you will see that microservice kafka-mongo consumes the data and stores it in mongoDB.

Check if the data is stored in mongoDB. If it's there, we're good!

If you liked this blog post, follow me on Twitter @JohnpiedrahitaH and on
LinkedIn john-piedrahita-30593a179

Third part, authentication based on clean architecture

John Piedrahita — Tue, 09 Nov 2021 15:52:36 +0000

Third part...

In the previous post we made the use case to authenticate ourselves in the system, now we are going to solve a use case to read all the users that exist in the system and include the roles so they can access this resource.

Use case to read the system users

We create the gateway for this use case.

scaffold create:interface --name=get-users --path=models

We create this interface to then apply the principle of Dependency Inversion, between the service and the Mongo DB adapter.

src/domain/models/gateways/get-users-repository.ts

import {UserModel} from "@/domain/models/user";

export const GET_USERS_REPOSITORY = "GET_USERS_REPOSITORY";

export interface IGetUsersRepository {
    getUsersRepository: () => Promise<UserModel[]>
}

Now we create the service that will implement the logic of the use case.

scaffold create:service --name=get-users

src/domain/use-cases/get-users-service.ts

We create this interface to then apply the principle of Dependency Inversion, between the service and the entry point.

import {UserModel} from "@/domain/models/user";

export const GET_USERS_SERVICE = "GET_USERS_SERVICE";

export interface IGetUsersService {
    getUsersService: () => Promise<UserModel[]>
}

src/domain/use-cases/impl/get-users-service-impl.ts

import {Adapter, Service} from "@tsclean/core";

@Service()
export class GetUsersServiceImpl implements IGetUsersService {
    constructor(
        @Adapter(GET_USERS_REPOSITORY) private readonly getUsersRepository: IGetUsersRepository
    ) {
    }

    async getUsersService(): Promise<UserModel[]> {
        return await this.getUsersRepository.getUsersRepository();
    }
}

We already have everything we need in the domain layer for the use case, now we are going to include the interface in the mongo adapter we have.

src/infrastructure/driven-adapters/orm/mongoose/user-mongoose-repository-adapter.ts

import {AddUserParams, UserModel} from "@/domain/models/user";
import {UserModelSchema} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/models/user";
import {IAddUserRepository} from "@/domain/models/gateways/add-user-repository";
import {ICheckEmailRepository} from "@/domain/models/gateways/check-email-repository";

export class UserMongooseRepositoryAdapter implements IAddUserRepository,
ICheckEmailRepository,
IGetUsersRepository {

// We create this function to manage the entity that exists in the domain.
    map(data: any): any {
        const {_id, firstName, lastName, email, password} = data
        return Object.assign({}, {id: _id.toString(), firstName, lastName, email, password})
    }

    async addUserRepository(data: AddUserParams): Promise<UserModel> {
        return await UserModelSchema.create(data);
    }

    async checkEmail(email: string): Promise<ICheckEmailRepository.Result> {
        const user = await UserModelSchema.findOne({email}).exec();
        return user && this.map(user);
    }

    async getUsersRepository(): Promise<UserModel[]> {
        return UserModelSchema.find().select("-password");
    }
}

We create the controller as an entry point.

scaffold create:controller --name=get-users

src/infrastructure/entry-points/api/get-users-controller.ts

import {Adapter, Get, Mapping} from "@tsclean/core";
import {GET_USERS_SERVICE, IGetUsersService} from "@/domain/use-cases/get-users-service";

@Mapping('api/v1/get-users')
export class GetUsersController {

    constructor(
        @Adapter(GET_USERS_SERVICE) private readonly getUsersService: IGetUsersService
    ) {
    }

    @Get()
    async getUsersController(): Promise<any> {
        return await this.getUsersService.getUsersService();
    }
}

If everything went well and you have reached this point when you visit the endpoint http://localhost:9000/api/v1/get-users, it should users list.

Protecting resources with roles.

We have already solved our use cases, now we are going to protect some resources so that only users with a certain role can access them. To achieve this we must first go to the adapter and create the corresponding logic.

src/infrastructure/driven-adapters/adapters/jwt-adapter.ts

import jwt from "jsonwebtoken";
import dotenv from "dotenv";
import {IEncrypt} from "@/domain/models/gateways/encrypt-repository";
import {AccessResourceInterface, ExecutionContextInterface} from "@tsclean/core";

dotenv.config({path: ".env"})

export class JwtAdapter implements IEncrypt, AccessResourceInterface {

    constructor(
        private readonly roles: string[]
    ) {
    }

    async encrypt(text: string | number | Buffer, roles: []): Promise<string> {
        const payload = {id: text, roles: roles}
        return jwt.sign({account: payload}, process.env.JWT_SECRET, {expiresIn: "1d"});
    }

    accessResource(context: ExecutionContextInterface): boolean | Promise<boolean> {
        try {
            const request = context.getHttp().getRequest();
            const token = request.rawHeaders[1].split(" ")[1];

            if (token) {
                const decode = jwt.verify(token, process.env.JWT_SECRET);
                const roles = decode["account"].roles;

                let assignRole = false;

                for (const role of roles) {
                    assignRole = false;
                    for (const roleElement of this.roles) {
                        let roleExist = role.role === roleElement;
                        if (roleExist) assignRole = roleExist;
                        if (assignRole) return true;
                    }
                }
            }
        } catch (e) {
            return false;
        }
    }
}

What we do in this adapter is to implement the AccessResourceInterface interface provided by the plugin with its accessResource method. We receive through the constructor the roles of the user that tries to access the resource. And a boolean is returned according to the validation.

Next we create a factory that will help us in the controller with this validation.

src/infrastructure/helpers/auth.ts

import {applyDecorators, AccessResource} from "@tsclean/core";
import {JwtAdapter} from "@/infrastructure/driven-adapters/adapters/jwt-adapter";

export function Auth(roles: string[]) {
    return applyDecorators(AccessResource(new JwtAdapter(roles)));
}

src/infrastructure/entry-points/api/get-users-controller.ts

import {Adapter, Get, Mapping} from "@tsclean/core";
import {Auth} from "@/infrastructure/helpers/auth";
import {GET_USERS_SERVICE, IGetUsersService} from "@/domain/use-cases/get-users-service";

@Mapping('api/v1/get-users')
export class GetUsersController {

    constructor(
        @Adapter(GET_USERS_SERVICE) private readonly getUsersService: IGetUsersService
    ) {
    }

    @Get()
    @Auth(["manager", "guest"])
    async getUsersController(): Promise<any> {
        return await this.getUsersService.getUsersService();
    }
}

Now you can see that the method has an additional decorator that receives an array of the roles that can access the resource. This resource can have one or many roles.

When a user tries to access the resource with a role different from those in the decorator, it returns a 403 status code. With this, we can protect the ends in a simple way.

If you have reached this point, you have the way to create the authentication for a system and protect the routes with roles and all this applying a concept based on Clean Architecture.

In this link you can find the implementation of the project https://github.com/tsclean/api-example

Second part, authentication based on clean architecture

John Piedrahita — Mon, 25 Oct 2021 16:53:08 +0000

Second part...

In the previous post we did the use case for registering a user. In this occasion we are going to continue developing the other use case which is that the user that is registered can authenticate to enter the application. To generate the token we will use the external library jsonwebtoken.

We must create two interfaces to communicate with the infrastructure layer adapters. One to compare that the password corresponds to the database and the other to generate the token from the service.

src/domain/models/gateways/hash-compare-repository.ts

export const HASH_COMPARE_REPOSITORY = "HASH_COMPARE_REPOSITORY";

export interface IHashCompare {
    compare: (text: string, verify: string) => Promise<boolean>
}

src/domain/models/gateways/encrypt-repository.ts

export const ENCRYPT_REPOSITORY = "ENCRYPT_REPOSITORY";

export interface IEncrypt {
    encrypt: (text: string | number | Buffer) => Promise<IEncrypt.Result>
}

export namespace IEncrypt {
    export type Result = string;
}

We create the service to make the use case logic.

scaffold create:service --name=authentication

src/domain/use-cases/authentication-service.ts

export const AUTHENTICATION_SERVICE = "AUTHENTICATION_SERVICE";

export interface IAuthenticationService {
    auth: (data: IAuthenticationService.Params) => Promise<IAuthenticationService.Result>;
}

export namespace IAuthenticationService {
    export type Params = {
        email: string;
        password: string
    }

    export type Result = {
        accessToken: string;
        name: string
    }
}

src/domain/use-cases/impl/authentication-service-impl.ts

import {Adapter, Service} from "@tsclean/core";
import {IAuthenticationService} from "@/domain/use-cases/authentication-service";
import {CHECK_EMAIL_REPOSITORY, ICheckEmailRepository} from "@/domain/models/gateways/check-email-repository";
import {HASH_COMPARE_REPOSITORY, IHashCompare} from "@/domain/models/gateways/hash-compare-repository";
import {ENCRYPT_REPOSITORY, IEncrypt} from "@/domain/models/gateways/encrypt-repository";

@Service()
export class AuthenticationServiceImpl implements IAuthenticationService {
    constructor(
        @Adapter(ENCRYPT_REPOSITORY) private readonly encrypt: IEncrypt,
        @Adapter(HASH_COMPARE_REPOSITORY) private readonly hashCompare: IHashCompare,
        @Adapter(CHECK_EMAIL_REPOSITORY) private readonly checkEmailRepository: ICheckEmailRepository) {
    }

    async auth(data: IAuthenticationService.Params): Promise<IAuthenticationService.Result> {
        const account = await this.checkEmailRepository.checkEmail(data.email);
        const isValid = await this.hashCompare.compare(data.password, account.password);
        if (isValid) {
            const accessToken = await this.encrypt.encrypt(account.id);

            return {
                accessToken,
                name: account.firstName
            }
        }

        return null;
    }
}

After this we move to the infrasctructure layer and modify the bcrypt adapter and create the adapter for the external library jsonwebtoken.

src/infrasctructure/driven-adapters/bcrypt-adapter.ts

import bcrypt from "bcrypt";
import {IHashCompare} from "@/domain/models/gateways/hash-compare-repository";
import {IHashRepository} from "@/domain/models/gateways/hash-repository";

export class BcryptAdapter implements IHashRepository, IHashCompare {
    private readonly salt: number = 12;

    constructor() {
    }

    async compare(text: string, verify: string): Promise<boolean> {
        return await bcrypt.compare(text, verify);
    }

    async hash(text: string): Promise<string> {
        return await bcrypt.hash(text, this.salt);
    }
}

src/infrasctructure/driven-adapters/jwt-adapter.ts

import jwt from "jsonwebtoken";
import {IEncrypt} from "@/domain/models/gateways/encrypt-repository";

export const secret = "my_secret";

export class JwtAdapter implements IEncrypt {

    async encrypt(text: string | number | Buffer): Promise<IEncrypt.Result> {
        return jwt.sign({account: text}, secret, {expiresIn: "1d"});
    }
}

We must add the adapter to the supplier file so that the dependencies in the main container will be resolved. The updated file should look like this

_src/infrastructure/driven-adapters/providers/index.ts

import {AddUserServiceImpl} from "@/domain/use-cases/impl/add-user-service-impl";
import {AuthenticationServiceImpl} from "@/domain/use-cases/impl/authentication-service-impl";

import {JwtAdapter} from "@/infrastructure/driven-adapters/adapters/jwt-adapter";
import {BcryptAdapter} from "@/infrastructure/driven-adapters/adapters/bcrypt-adapter";
import {UserMongooseRepositoryAdapter} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/user-mongoose-repository-adapter";

import {ADD_USER_REPOSITORY} from "@/domain/models/gateways/add-user-repository";
import {CHECK_EMAIL_REPOSITORY} from "@/domain/models/gateways/check-email-repository";
import {ADD_USER_SERVICE} from "@/domain/use-cases/add-user-service";
import {HASH_COMPARE_REPOSITORY} from "@/domain/models/gateways/hash-compare-repository";
import {AUTHENTICATION_SERVICE} from "@/domain/use-cases/authentication-service";
import {HASH_REPOSITORY} from "@/domain/models/gateways/hash-repository";
import {ENCRYPT_REPOSITORY} from "@/domain/models/gateways/encrypt-repository";


export const adapters = [
    {
        classAdapter: BcryptAdapter,
        key: HASH_REPOSITORY
    },
    {
        classAdapter: UserMongooseRepositoryAdapter,
        key: ADD_USER_REPOSITORY
    },
    {
        classAdapter: UserMongooseRepositoryAdapter,
        key: CHECK_EMAIL_REPOSITORY
    },
    {
        classAdapter: BcryptAdapter,
        key: HASH_COMPARE_REPOSITORY
    },
    {
        classAdapter: JwtAdapter,
        key: ENCRYPT_REPOSITORY
    }
]

export const services = [
    {
        classAdapter: AddUserServiceImpl,
        key: ADD_USER_SERVICE
    },
    {
        classAdapter: AuthenticationServiceImpl,
        key: AUTHENTICATION_SERVICE
    }
]

We create the entry point for authentication and then we must add it to the index.ts to export it to the main container

scaffold create:controller --name=authentication

src/infrastructure/entry-points/api/authentication-controller.ts

import {Mapping, Inject, Post, Body, Adapter} from "@tsclean/core";
import {AUTHENTICATION_SERVICE, IAuthenticationService} from "@/domain/use-cases/authentication-service";
import {ValidateFields} from "@/infrastructure/helpers/validate-fields";

@Mapping('api/v1/authentication')
export class AuthenticationController {

    constructor(
        @Adapter(AUTHENTICATION_SERVICE) private readonly authenticationService: IAuthenticationService
    ) {
    }

    @Post()
    async authController(@Body() data: IAuthenticationService.Params): Promise<IAuthenticationService.Result | any> {

        const {errors, isValid} = ValidateFields.fieldsValidation(data);

        if (!isValid) return {statusCode: 422, body: {"message": errors}}

        const result = await this.authenticationService.auth(data);
        return {
            accessToken: result.accessToken,
            name: result.name
        }
    }
}

If everything went well and you have reached this point when you visit the endpoint http://localhost:9000/api/v1/authentication, it should generate the token.

next third part...

https://dev.to/japhernandez/authentication-based-on-clean-architecture-39np

First part, Authentication based on clean architecture

John Piedrahita — Mon, 25 Oct 2021 15:35:03 +0000

First part...

In this new installment I share with you several use cases for authenticating to an API, with the @clean/scaffold package.

Use cases:

A user may be able to register.
A user can log in to the system through jwt authentication.

We install the package globally on our pc.

npm i -g @tsclean/scaffold

We create the project.

scaffold create:project --name=authentication

We create the entity with the corresponding attributes, in this case we are going to store a user.

scaffold create:entity --name=user

src/domain/models/user.ts

export type UserModel = {
  id: string | number;
  name: string;
  email: string;
  password: string;
  roles: UserRoleModel[];
}

export type UserRoleModel = [
    {
        role: string
    }
]

export type AddUserParams = Omit<UserModel, 'id'>

Now we create the interface that will communicate the domain layer with the infrastructure layer. This interface will contain the use case.

Note: The interfaces when compiling the code to javascript are lost, for this reason to be able to apply the principle of Inversion of Dependencies, we must make reference in the communication of the components by means of a constant.

scaffold create:interface --name=add-user --path=models

src/domain/models/gateways/add-user-repository.ts

import {UserModel, AddUserParams} from "@/domain/models/user";

export const ADD_USER_REPOSITORY = "ADD_USER_REPOSITORY";

export interface IAddUserRepository {
    addUser: (data: AddUserParams) => Promise<UserModel>;
}

Now we create the service that is going to have all the logic to store the user.

scaffold create:service --name=add-user

Interface to communicate the service with external layers.

src/domain/use-cases/add-user-service.ts

import {AddUserParams} from "@/domain/models/user";

export const ADD_USER_SERVICE = "ADD_USER_SERVICE";

export interface IAddUserService {
    addUser: (data: AddUserParams) => Promise<IAddUserService.Result | IAddUserService.Exist>
}

export namespace IAddUserService {
    export type Exist = boolean;
    export type Result = {
        id?: string | number
    }
}

We create the business logic in the service, this involves applying some business rules.

src/domain/use-cases/impl/add-user-service-impl.ts

import {Adapter, Service} from "@tsclean/core";
import {IAddUserService} from "@/domain/use-cases/add-user-service";
import {AddUserParams} from "@/domain/models/user";
import {ADD_USER_REPOSITORY, IAddUserRepository} from "@/domain/models/gateways/add-user-repository";

@Service()
export class AddUserServiceImpl implements IAddUserService {
    constructor(
        @Adapter(ADD_USER_REPOSITORY) private readonly addUserRepository: IAddUserRepository
    ) {
    }

    async addUserService(data: AddUserParams): Promise<IAddUserService.Result | IAddUserService.Exist> {
        return await this.addUserRepository.addUserRepository(data);
    }
}

This is the basic logic for the service to store the user, but we must check that the email is unique and create a hash for the password, so we get closer to a real world application.

We must create two interfaces for this purpose, one for the email validation and the other to create the password hash.

src/domain/models/gateways/check-email-repository.ts

export const CHECK_EMAIL_REPOSITORY = "CHECK_EMAIL_REPOSITORY";

export interface ICheckEmailRepository {
    checkEmail: (email: string) => Promise<ICheckEmailRepository.Result>
}

export namespace ICheckEmailRepository {
    export type Result = {
        id: string | number;
        firstName: string;
        password: string;
    }

}

src/domain/models/gateways/hash-repository.ts

export const HASH_REPOSITORY = "HASH_REPOSITORY";

export interface IHashRepository {
    hash: (text: string) => Promise<string>
}

Now that the interfaces have been created to handle some of the business rules, we implement the interfaces in the service, passing them as a dependency in the constructor.

src/domain/use-cases/impl/add-user-service-impl.ts

import {Adapter, Service} from "@tsclean/core";
import {IAddUserService} from "@/domain/use-cases/add-user-service";
import {AddUserParams} from "@/domain/models/user";
import {ADD_USER_REPOSITORY, IAddUserRepository} from "@/domain/models/gateways/add-user-repository";
import {CHECK_EMAIL_REPOSITORY, ICheckEmailRepository} from "@/domain/models/gateways/check-email-repository";
import {HASH_REPOSITORY, IHashRepository} from "@/domain/models/gateways/hash-repository";

@Service()
export class AddUserServiceImpl implements IAddUserService {
    constructor(
        @Adapter(HASH_REPOSITORY) private readonly hash: IHashRepository,
        @Adapter(CHECK_EMAIL_REPOSITORY) private readonly checkEmailRepository: ICheckEmailRepository,
        @Adapter(ADD_USER_REPOSITORY) private readonly addUserRepository: IAddUserRepository
    ) {
    }

    async addUserService(data: AddUserParams): Promise<IAddUserService.Result | IAddUserService.Exist> {
        const userExist = await this.checkEmailRepository.checkEmail(data.email);
        if (userExist) return true;

        const hashPassword = await this.hash.hash(data.password);
        const user = await this.addUserRepository.addUserRepository({...data, password: hashPassword});
        if (user) return user;
    }
}

Now we create the adapter in infrastructure layer.

scaffold create:adapter-orm --name=user --orm=mongoose

You must configure in the .env the url that you will use in the connection with mongoose.

Note: An update has been made in the plugin to give a management to the providers generating a single file, in this we include all the providers that are being created and by means of the spread operator we include them in the main container of the application so that the dependencies are solved.

src/infrastructure/driven-adapters/adapters/orm/mongoose/models/user.ts

import { model, Schema } from "mongoose";
import { UserModel } from '@/domain/models/user';

const schema = new Schema<UserModel>({
    id: String,
    firstName: String,
    lastName: String,
    email: String,
    password: String,
});

export const UserModelSchema = model<UserModel>('users', schema);

src/infrastructure/driven-adapters/adapters/orm/mongoose/user-mongoose-repository-adapter.ts

import {AddUserParams, UserModel} from "@/domain/models/user";
import {UserModelSchema} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/models/user";
import {IAddUserRepository} from "@/domain/models/gateways/add-user-repository";
import {ICheckEmailRepository} from "@/domain/models/gateways/check-email-repository";

export class UserMongooseRepositoryAdapter implements IAddUserRepository,
ICheckEmailRepository {

// We create this function to manage the entity that exists in the domain.
    map(data: any): any {
        const {_id, firstName, lastName, email, password} = data
        return Object.assign({}, {id: _id.toString(), firstName, lastName, email, password})
    }

    async addUserRepository(data: AddUserParams): Promise<UserModel> {
        return await UserModelSchema.create(data);
    }

    async checkEmail(email: string): Promise<ICheckEmailRepository.Result> {
        const user = await UserModelSchema.findOne({email}).exec();
        return user && this.map(user);
    }
}

Now we create the adapter of an external library to create the hash of the password, for this we use bcrypt, where we make the implementation of the interface, decoupling completely the components.

src/infrastructure/driven-adapters/adapters/bcrypt-adapter.ts

import bcrypt from "bcrypt";
import {IHashRepository} from "@/domain/models/gateways/hash-repository";

export class BcryptAdapter implements IHashRepository {
    private readonly salt: number = 12;

    constructor() {
    }

    async hash(text: string): Promise<string> {
        return await bcrypt.hash(text, this.salt);
    }
}

src/infrastructure/driven-adapters/providers/index.ts

import {BcryptAdapter} from "@/infrastructure/driven-adapters/adapters/bcrypt-adapter";
import {UserMongooseRepositoryAdapter} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/user-mongoose-repository-adapter";
import {AddUserServiceImpl} from "@/domain/use-cases/impl/add-user-service-impl";
import {ADD_USER_REPOSITORY} from "@/domain/models/gateways/add-user-repository";
import {CHECK_EMAIL_REPOSITORY} from "@/domain/models/gateways/check-email-repository";
import {ADD_USER_SERVICE} from "@/domain/use-cases/add-user-service";
import {HASH_REPOSITORY} from "@/domain/models/gateways/hash-repository";


export const adapters = [
    {
        classAdapter: BcryptAdapter,
        key: HASH_REPOSITORY
    },
    {
        classAdapter: UserMongooseRepositoryAdapter,
        key: ADD_USER_REPOSITORY
    },
    {
        classAdapter: UserMongooseRepositoryAdapter,
        key: CHECK_EMAIL_REPOSITORY
    }
]

export const services = [
    {
        classAdapter: AddUserServiceImpl,
        key: ADD_USER_SERVICE
    }
]

We create the controller as an entry point.

scaffold create:controller --name=add-user

src/infrastructure/entry-points/api/add-user-controller.ts

import {Mapping, Post, Body, Adapter} from "@tsclean/core";
import {AddUserParams} from "@/domain/models/user";
import {ADD_USER_SERVICE, IAddUserService} from "@/domain/use-cases/add-user-service";

@Mapping('api/v1/add-user')
export class AddUserController {

    constructor(
        @Adapter(ADD_USER_SERVICE) private readonly addUserService: IAddUserService
    ) {
    }

    @Post()
    async addUserController(@Body() data: AddUserParams): Promise<IAddUserService.Result | IAddUserService.Exist> {
        return this.addUserService.addUserService(data);
    }
}

We are already validating in the use case that the email is unique, but it returns only a boolean value, we must handle this exception at the entry point, in this case the controller, in addition we validate that the email has the correct format and the body of the request does not bring empty fields.

To achieve this we create our own helper or we make use of an external library, if you make use of a library you must create the corresponding adapter for this purpose.

src/infrastructure/helpers/validate-fields.ts

export const REGEX = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/

export class ValidateFields {

    static fieldsValidation(data: any) {
        let errors = {}
        for (const key in data) {
            if (ValidateFields.isFieldEmpty(data[key])) {
                errors[key] = `${key} field is required`
            } else if (key === "email" && !REGEX.test(data[key])) {
                errors[key] = `${key} is invalid`
            }
        }

        return { errors, isValid: ValidateFields.isFieldEmpty(errors) }
    }

    private static isFieldEmpty (value: any): boolean {
        if (value === undefined || value === null ||
            typeof value === "object" && Object.keys(value).length === 0 ||
            typeof value === "string" && value.trim().length === 0) {
            return true
        }
    }
}

src/infrastructure/entry-points/api/add-user-controller.ts

import {Mapping, Post, Body, Adapter} from "@tsclean/core";
import {AddUserParams} from "@/domain/models/user";
import {ADD_USER_SERVICE, IAddUserService} from "@/domain/use-cases/add-user-service";
import {ValidateFields} from "@/infrastructure/helpers/validate-fields";

@Mapping('api/v1/add-user')
export class AddUserController {

    constructor(
        @Adapter(ADD_USER_SERVICE) private readonly addUserService: IAddUserService
    ) {
    }

    @Post()
    async addUserController(@Body() data: AddUserParams): Promise<IAddUserService.Result | IAddUserService.Exist | any> {

        const {errors, isValid} = ValidateFields.fieldsValidation(data);

        if (!isValid) return {statusCode: 422, body: {"message": errors}}

        const account = await this.addUserService.addUserService(data);

        if (account === true) return {statusCode: 400, body: {"message": "Email is already in use"}}

        return account;
    }
}

We create an index file to export all the controllers to the container.

src/infrastructure/entry-points/api/index.ts

import {AddUserController} from "@/infrastructure/entry-points/api/add-user-controller";

export const controllers = [
    AddUserController
]

Finally we configure all the components in the main container

src/application/app.ts

import {Container} from "@tsclean/core";
import {controllers} from "@/infrastructure/entry-points/api";
import {adapters, services} from "@/infrastructure/driven-adapters/providers";

@Container({
    imports: [],
    providers: [...services, ...adapters],
    controllers: [...controllers],
})

export class AppContainer {
}

The code looks much cleaner with the update that was made.

Previously when creating the adapter, the index.ts file that starts the application was updated with the necessary configuration to make the connection with the database manager.

src/index.ts

import 'module-alias/register'

import helmet from 'helmet';
import {connect} from 'mongoose';
import {StartProjectInit} from "@tsclean/core";

import {AppContainer} from "@/application/app";
import {MONGODB_URI, PORT} from "@/application/config/environment";

async function run(): Promise<void> {
    await connect(MONGODB_URI);
    console.log('DB Mongo connected')
    const app = await StartProjectInit.create(AppContainer);
    app.use(helmet());
    await app.listen(PORT, () => console.log('Running on port: ' + PORT))
}

run();

next second part...

https://dev.to/japhernandez/authentication-based-on-clean-architecture-38el

Clean Architecture with Nodejs, TypeScript and Mongo.

John Piedrahita — Thu, 21 Oct 2021 16:47:45 +0000

In this case we will use the package @tsclean/scaffold, which generates a structure based on Clean Architecture, it also has a CLI that helps us generating code to create the different components of the application. This package includes the (Dependency Injection, DI), design pattern in object oriented programming (OOP) and the design principle Inversion of Control, IoC), who resolves dependencies on application startup.

This time we are going to create a simple use case, but that contextualizes how the package works.

Use case for saving an entity in a database.

We install the package globally on our pc. ```

npm i -g @tsclean/scaffold


* We create the project.

scaffold create:project --name=app

This command generates the following project structure and installs the dependencies to make the application work.


* We create the entity with the corresponding attributes, in this case we are going to store a user.

scaffold create:entity --name=user

This command will create the following structure in the domain layer.

src
|- domain
|- entities
|- user.ts

```typescript


export type UserModel = {
  id: string | number;
  name: string;
  email: string;
}

export type AddUserParams = Omit<UserModel, 'id'>

Now we create the interface that will communicate the domain layer with the infrastructure layer. This interface will contain the use case.



scaffold create:interface --name=add-user --path=models

This command will create the following structure in the domain layer.



src
  |- domain
     |- entities
        |- contracts
           |- add-user-repository.ts



import {UserModel, AddUserParams} from "@/domain/models/user";

export const ADD_USER_REPOSITORY = "ADD_USER_REPOSITORY"

export interface IAddUserRepository {
    addUserRepository: (data: AddUserParams) => Promise<UserModel>;
}

Now we create the service that is going to have all the logic to store the user.



scaffold create:service --name=add-user

This command will create the following structure in the domain layer.



src
  |- domain
     |- use-cases
        |- impl
           |- add-user-service-impl.ts
        | - add-user-service.ts

Interface to communicate the service with external layers.



import {UserModel, AddUserParams} from "@/domain/models/user";

export const ADD_USER_SERVICE = "ADD_USER_SERVICE"

export interface IAddUserService {
  addUserService: (data: AddUserParams) => Promise<UserModel>
}

Service where we implement the interface.



import {Service} from "@tsclean/core";
import {UserModel} from "@/domain/models/user";
import {AddUserParams} from "@/domain/models/user";
import {IAddUserService} from "@/domain/use-cases/add-user-service";
import {ADD_USER_REPOSITORY, IAddUserRepository} from "@/domain/models/gateways/add-user-repository";

@Service()
export class AddUserServiceImpl implements IAddUserService {
    constructor(
        @Adapter(ADD_USER_REPOSITORY) private readonly addUserRepository: IAddUserRepository
    ) {
    }

    async addUserService(data: AddUserParams): Promise<UserModel> {
        return await this.addUserRepository.addUserRepository(data);
    }
}

Now we create the ORM adapter, in this case it is mongoose, but sequelize is also enabled.



scaffold create:adapter-orm --name=user --orm=mongo --manager=mongoose

This command creates the structure in the infrastructure layer, the mongoose-instance-ts file with the singleton to make the connection to Mongo, and updates the singleton.ts file adding the function that is then iterated in the index.ts to connect to the database.



src
  |- application
     |- config
        |- mongoose-instance.ts
     |- singleton.ts
  |- infrasctructure
     |- driven-adapters
        |- adapters
           |- orm
              |- mongoose
                 |- models
                    |- user.ts
                 |- user-mongoose-repository-adapter.ts
        |- providers
           |- index.ts

We create the model with the attributes of the entity that is in the domain, ensuring that the entries are the same.



import { model, Schema } from "mongoose";
import { UserModel } from '@/domain/models/user';

const schema = new Schema<UserModel>({
    id:  { type: String },
    name: { type: String, required: true },
    email:  { type: String, required: true }
});

export const UserModelSchema = model<UserModel>('users', schema);

At this point the implementation of the interface in the adapter helps us with the communication between the layers, so they are decoupled, we apply the SOLID principle of Dependency Inversion Principle (DIP).



import {UserModel, AddUserParams} from "@/domain/models/user";
import {IAddUserRepository} from "@/domain/models/gateways/add-user-repository";
import {UserModelSchema} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/models/user";

export class UserMongooseRepositoryAdapter implements IAddUserRepository {

    async addUserRepository(data: AddUserParams): Promise<UserModel> {
        return await UserModelSchema.create(data);
    }
}

The scaffold creates the class with the Singleton Pattern to handle the database connection.



import { connect, set } from "mongoose";
import { Logger } from "@tsclean/core";
import { MONGODB_URI } from "@/application/config/environment";

/** Class that manages the configuration and connection to a MongoDB database */
export class MongoConfiguration {
    /** Private logger instance for logging purposes */
    private logger: Logger;

    /** Private static instance variable to implement the Singleton pattern */
    private static instance: MongoConfiguration;

    /** Private constructor to ensure that only one instance is created */
    private constructor() {
        /** Initialize the logger with the class name */
        this.logger = new Logger(MongoConfiguration.name);
    }

    /** Method to get the instance of the class, following the Singleton pattern */
    public static getInstance(): MongoConfiguration {
        if (!this.instance) {
            this.instance = new MongoConfiguration();
        }
        return this.instance;
    }

    /** Asynchronous method to manage the MongoDB database connection */
    public async managerConnectionMongo(): Promise<void> {
        /** Set MongoDB configuration option to enforce strict queries */
        set("strictQuery", true);

        try {
            /** Attempt to connect to the MongoDB database using the provided URI */
            await connect(MONGODB_URI);
            /** Log a success message if the connection is successful */
            this.logger.log(`Connection successfully to database of Mongo: ${MONGODB_URI}`);
        } catch (error) {
            /** Log an error message if the connection fails */
            this.logger.error("Failed to connect to MongoDB", error);
        }
    }
}

Then the scaffold adds an asynchronous function to the singletonInitializers array found in the singleton.ts file. This array is initialized in the index.ts file to create the connection instances.



import { MongoConfiguration } from "@/application/config/mongoose-instance";

/**
   * This array has all the singleton instances of the application
   */
export const singletonInitializers: Array<() => Promise<void>> = [
    async () => {
        const mongooseConfig = MongoConfiguration.getInstance();
        await mongooseConfig.managerConnectionMongo();
    },
];

This class injects the dependencies, which are resolved at runtime.



import {ADD_USER_REPOSITORY} from "@/domain/models/gateways/add-user-repository";
import {ADD_USER_SERVICE} from "@/domain/use-cases/add-user-service";

import {AddUserServiceImpl} from "@/domain/use-cases/impl/add-user-service-impl";
import {UserMongooseRepositoryAdapter} from "@/infrastructure/driven-adapters/adapters/orm/mongoose/user-mongoose-repository-adapter";

export const providers = [
    {
        useClass: UserMongooseRepositoryAdapter,
        provide: ADD_USER_REPOSITORY
    }
]

export const services = [
    {
        useClass: AddUserServiceImpl,
        provide: ADD_USER_SERVICE
    }
]

index.ts



import "module-alias/register";

import helmet from 'helmet';
import { StartProjectInit } from "@tsclean/core";

import { AppContainer } from "@/application/app";
import { PORT } from "@/application/config/environment";
import { singletonInitializers } from "@/application/singleton";

async function init(): Promise<void> {
  /** Iterate the singleton functions */
  for (const initFn of singletonInitializers) {
    await initFn();
  }

  const app = await StartProjectInit.create(AppContainer)
  app.use(helmet());
  await app.listen(PORT, () => console.log(`Running on port: ${PORT}`))
}

void init().catch();

After this you must include in the .env file the mongo url to which you are going to connect.

At this point you can run the application on port 9000 and it should work.

Now we create the controller, entry point to the application. If you name the controller as in the service, it creates code where you inject the dependency and create the corresponding route. When creating the service the name that we gave him was add-user, we must use that same name for the controller.



scaffold create:controller --name=add-user

This command will create the following structure in the infrasctructure layer.



src
  |- infrasctructure
     |- entry-points
        |- api
           |- add-user-controller.ts
           |- index.ts



import {Mapping, Body, Post} from "@tsclean/core";
import {UserModel, AddUserParams} from "@/domain/models/user";
import {ADD_USER_SERVICE, IAddUserService} from "@/domain/use-cases/add-user-service";

@Mapping('api/v1/add-user')
export class AddUserController {

    constructor(
         @Adapter(ADD_USER_SERVICE) private readonly addUserService: IAddUserService
    ) {
    }

    @Post()
    async addUserController(@Body() data: AddUserParams): Promise<UserModel> {
        return await this.addUserService.addUserService(data);
    }
}



import {AddUserController} from "@/infrastructure/entry-points/api/add-user-controller";

export const controllers = [
    AddUserController
]

All the components are ready for the use case to be ready, they just need to be put together.

In the app.ts file that is in the application layer we must make this configuration.



import {Container} from "@tsclean/core";
import {controllers} from "@/infrastructure/entry-points/api";
import {adapters, services} from "@/infrastructure/driven-adapters/providers";

@Container({
    controllers: [...controllers],
    providers: [...services, ...adapters]
})

export class AppContainer {}

Congratulations, everything is ready, you can run the application in postman url http://localhost:9000/api/v1/add-user.

Final notes

This use case is basic, because it lacks some important elements, among them the validations:

The email must be unique.
Must have the correct format.
Character length must be validated.

The developer can include the validator of his choice or do it with his own script. If you do it with an external library you must create an adapter for this purpose.