Feat/authorize

.github/workflows/ci.yml

@@ -2,9 +2,9 @@
 name: Nest.JS clean architecture CI
 on:
   push:
-    branches: ['*']
+    branches: [main, develop]
   pull_request:
-    branches: [main]
+    branches: [main, develop]
 jobs:
   lint-commit:
     runs-on: ubuntu-latest

.husky/pre-commit

@@ -1,2 +1,2 @@
-pnpm lint-staged
+pnpm lint-staged && pnpm test
 

eslint.config.mjs

@@ -32,7 +32,7 @@ export default tseslint.config(
       '@typescript-eslint/no-explicit-any': 'off',
       'no-unused-vars': 'off',
       '@typescript-eslint/no-unused-vars': 'off',
-      'no-console': 'warn',
+      'no-console': 'error',
       '@typescript-eslint/no-var-requires': 'off',
       '@typescript-eslint/no-namespace': 'off',
     },

package.json

@@ -82,9 +82,7 @@
   "lint-staged": {
     "*.ts": [
       "pnpm lint",
-      "pnpm format",
-      "pnpm run test",
-      "pnpm run test:e2e"
+      "pnpm format"
     ]
   }
 }

src/application/di/auth.module.ts

@@ -0,0 +1,46 @@
+import { AuthFacadeUsecase } from '@/domain/auth';
+import { AuthorizeUsecase } from '@/domain/auth/usecases';
+import { UserRepository } from '@/domain/user';
+import { AuthController } from '@/presentation/controllers/auth';
+
+import { UserModel } from '@/infrastructure/typeorm/models';
+import { UserEntity } from '@/domain/user';
+import { UserRepositoryImpl } from '@/infrastructure/typeorm/repositories';
+import { Module } from '@nestjs/common';
+import { Mapper } from '@/core';
+import { UserMapper } from '@/infrastructure/typeorm/mappers';
+import { CacheService } from '@/infrastructure/redis/cache';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+@Module({})
+export class AuthFacadeModule {
+  static register() {
+    return {
+      module: AuthFacadeModule,
+      imports: [TypeOrmModule.forFeature([UserModel])],
+      providers: [
+        AuthFacadeUsecase,
+        AuthorizeUsecase,
+
+        {
+          provide: UserRepository,
+          useClass: UserRepositoryImpl,
+        },
+
+        {
+          provide: Mapper<UserEntity, UserModel>,
+          useClass: UserMapper,
+        },
+      ],
+      exports: [AuthFacadeUsecase, AuthorizeUsecase],
+    };
+  }
+}
+
+@Module({
+  imports: [AuthFacadeModule.register()],
+  controllers: [AuthController],
+  providers: [CacheService],
+  exports: [],
+})
+export class AuthModule {}

src/application/di/index.ts

@@ -1,3 +1,5 @@
 export { PresentationModule } from './presentation.module';
 export { TypeOrmModule } from './typeorm.module';
 export { AppModule } from './app.module';
+export { AuthModule } from './auth.module';
+export { UserModule } from './user.module';

src/application/di/presentation.module.ts

@@ -1,9 +1,9 @@
 import { Module } from '@nestjs/common';
-import { UserFacadeUsecase } from '@/domain/user';
 import { UserModule } from './user.module';
+import { AuthModule } from './auth.module';
 
 @Module({
-  imports: [UserModule],
+  imports: [UserModule, AuthModule],
   controllers: [],
   providers: [],
 })

src/application/di/user.module.ts

@@ -5,33 +5,33 @@ import { UserController } from '@/presentation/controllers/user';
 import { Module } from '@nestjs/common';
 
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { UserModel as TypeormUserModel } from '@/infrastructure/typeorm/models';
+import { UserModel } from '@/infrastructure/typeorm/models';
 import { UserEntity } from '@/domain/user';
-import { UserRepositoryImpl as RepoTypeorm } from '@/infrastructure/typeorm/repositories';
+import { UserRepositoryImpl } from '@/infrastructure/typeorm/repositories';
 
 import { Mapper } from '@/core';
-import { UserMapper as TypeormUserMapper } from '@/infrastructure/typeorm/mappers';
+import { UserMapper } from '@/infrastructure/typeorm/mappers';
 
 @Module({})
 export class UserFacadeModule {
   static register() {
     return {
       module: UserFacadeModule,
 
-      imports: [TypeOrmModule.forFeature([TypeormUserModel])],
+      imports: [TypeOrmModule.forFeature([UserModel])],
       providers: [
         UserFacadeUsecase,
         CreateUserUsecase,
         GetUserUsecase,
 
         {
           provide: UserRepository,
-          useClass: RepoTypeorm,
+          useClass: UserRepositoryImpl,
         },
 
         {
-          provide: Mapper<UserEntity, TypeormUserModel>,
-          useClass: TypeormUserMapper,
+          provide: Mapper<UserEntity, UserModel>,
+          useClass: UserMapper,
         },
       ],
       exports: [UserFacadeUsecase, CreateUserUsecase, GetUserUsecase],
@@ -42,7 +42,13 @@ export class UserFacadeModule {
 @Module({
   imports: [UserFacadeModule.register()],
   controllers: [UserController],
-  providers: [CacheService],
+  providers: [
+    CacheService,
+    {
+      provide: Mapper<UserEntity, UserModel>,
+      useClass: UserMapper,
+    },
+  ],
   exports: [],
 })
 export class UserModule {}

src/application/dtos/auth/authorize.dto.ts

@@ -0,0 +1,9 @@
+import { Length } from 'class-validator';
+
+export class AuthorizeDto {
+  @Length(4, 20)
+  username: string;
+
+  @Length(6)
+  password: string;
+}

src/application/dtos/user/create-user.dto.ts

@@ -1,4 +1,4 @@
-import { IsNotEmpty, IsString, Length } from 'class-validator';
+import { IsString, Length } from 'class-validator';
 
 export class CreateUserDto {
   @IsString()

src/core/mapper.ts

@@ -1,4 +1,4 @@
-export abstract class Mapper<D, E> {
-  abstract toEntity(entity: Partial<E>): Partial<D>;
-  abstract toModel(domain: Partial<D>): Partial<E>;
+export abstract class Mapper<E, M> {
+  abstract toEntity(entity: Partial<M>): Partial<E>;
+  abstract toModel(domain: Partial<E>): Partial<M>;
 }

src/core/repository.ts

@@ -10,4 +10,6 @@ export abstract class Repository<TEntity extends Entity> {
   ): Promise<Partial<TEntity>>;
   abstract delete(id: string): Promise<Partial<TEntity>>;
   abstract create(data: Partial<TEntity>): Promise<Partial<TEntity>>;
+
+  abstract findOne(filter: Partial<TEntity>): Promise<Partial<TEntity>>;
 }

src/core/usecase.ts

@@ -1,3 +1,3 @@
-export abstract class Usecase<T> {
+export abstract class Usecase<T = unknown> {
   abstract execute(...args: any[]): Promise<Partial<T>>;
 }

src/domain/auth/auth.facade.usecase.ts

@@ -0,0 +1,15 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AuthorizeUsecase } from './usecases';
+import { AuthorizeDto } from '@/application/dtos/auth/authorize.dto';
+
+@Injectable()
+export class AuthFacadeUsecase {
+  constructor(
+    @Inject(AuthorizeUsecase)
+    private readonly authorizeUsecase: AuthorizeUsecase,
+  ) {}
+
+  authorize(payload: AuthorizeDto) {
+    return this.authorizeUsecase.execute(payload);
+  }
+}

src/domain/auth/auth.usecase.ts

@@ -0,0 +1,3 @@
+import { Usecase } from '@/core';
+
+export abstract class AuthUsecase extends Usecase {}

src/domain/auth/index.ts

@@ -0,0 +1,2 @@
+export { AuthUsecase } from './auth.usecase';
+export { AuthFacadeUsecase } from './auth.facade.usecase';

src/domain/auth/usecases/authorize.usecase.spec.ts

@@ -0,0 +1,65 @@
+import { Test } from '@nestjs/testing';
+import { AuthUsecase } from '../auth.usecase';
+import { AuthorizeUsecase } from './authorize.usecase';
+import { UserEntity, UserRepository } from '@/domain/user';
+import { faker } from '@faker-js/faker';
+import bcrypt from 'bcryptjs';
+
+const mockPayload = {
+  username: faker.internet.userName(),
+  password: faker.internet.password(),
+};
+const mockUser = {
+  id: faker.string.uuid(),
+  username: mockPayload.username,
+  password: bcrypt.hashSync(mockPayload.password, 10),
+  createdAt: new Date(),
+  deletedAt: null,
+  updatedAt: new Date(),
+};
+
+describe('AuthorizeUsecase', () => {
+  let usecase: AuthUsecase;
+  let repository: UserRepository;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      providers: [
+        AuthorizeUsecase,
+        {
+          provide: UserRepository,
+          useValue: {
+            findOne: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+    usecase = module.get<AuthUsecase>(AuthorizeUsecase);
+    repository = module.get<UserRepository>(UserRepository);
+  });
+
+  it('should be defined', () => {
+    expect(usecase).toBeDefined();
+    expect(repository).toBeDefined();
+  });
+  it('should return null if user not found', async () => {
+    jest.spyOn(repository, 'findOne').mockResolvedValue(null);
+    expect(
+      await usecase.execute({ username: 'username', password: 'password' }),
+    ).toBeNull();
+  });
+
+  it('should return user if user found', async () => {
+    jest.spyOn(repository, 'findOne').mockResolvedValue(mockUser);
+    const result = (await usecase.execute(mockPayload)) as UserEntity;
+    expect(result.id).toEqual(mockUser.id);
+  });
+  it('should return null if password is invalid', async () => {
+    jest.spyOn(repository, 'findOne').mockResolvedValue(mockUser);
+    const result = (await usecase.execute({
+      username: 'test',
+      password: 'wrong password',
+    })) as UserEntity;
+    expect(result).toEqual(null);
+  });
+});

src/domain/auth/usecases/authorize.usecase.ts

@@ -0,0 +1,22 @@
+import { AuthorizeDto } from '@/application/dtos/auth/authorize.dto';
+import { AuthUsecase } from '@/domain/auth';
+import { UserRepository } from '@/domain/user';
+import { Injectable } from '@nestjs/common';
+import bcrypt from 'bcryptjs';
+
+@Injectable()
+export class AuthorizeUsecase extends AuthUsecase {
+  constructor(private readonly userRepository: UserRepository) {
+    super();
+  }
+
+  async execute(payload: AuthorizeDto): Promise<Partial<any>> {
+    const { username, password } = payload;
+    const user = await this.userRepository.findOne({ username });
+
+    if (!user) return null;
+    const isValidPassword = bcrypt.compareSync(password, user.password);
+    if (!isValidPassword) return null;
+    return user;
+  }
+}

src/domain/auth/usecases/index.ts

@@ -0,0 +1 @@
+export { AuthorizeUsecase } from './authorize.usecase';

src/domain/user/user.entity.ts

@@ -1,16 +1,20 @@
 import { Entity } from '@/core/entity';
+import { Exclude } from 'class-transformer';
 
 export class UserEntity extends Entity {
+  @Exclude()
+  public password: string;
   constructor(
     public id: string,
     public username: string,
+    password: string,
 
     public createdAt: Date,
     public updatedAt: Date,
     public deletedAt: Date,
-
-    public password?: string,
   ) {
     super();
+
+    this.password = password;
   }
 }

src/domain/user/user.facade.usecase.ts

@@ -10,11 +10,11 @@ export class UserFacadeUsecase {
     @Inject(CreateUserUsecase) private readonly createUserUsecase: UserUsecase,
   ) {}
 
-  async createUser(data: Partial<UserEntity>) {
+  createUser(data: Partial<UserEntity>) {
     return this.createUserUsecase.execute(data);
   }
 
-  async getUser(id: string) {
+  getUser(id: string) {
     return this.getUserUsecase.execute(id);
   }
 }

src/infrastructure/typeorm/mappers/user.mapper.ts

@@ -8,6 +8,7 @@ export class UserMapper extends Mapper<UserEntity, UserModel> {
       return new UserEntity(
         data.id,
         data.username,
+        data.password,
         data.createdAt,
         data.updatedAt,
         data.deletedAt,

src/infrastructure/typeorm/models/user.model.ts

@@ -23,7 +23,7 @@ export class UserModel {
   username: string;
 
   @Column({
-    select: false,
+    select: true,
   })
   password?: string;
 

src/infrastructure/typeorm/repositories/user.repository.impl.ts

@@ -17,6 +17,14 @@ export class UserRepositoryImpl extends UserRepository {
   ) {
     super();
   }
+
+  async findOne(filter: Partial<UserEntity>): Promise<Partial<UserEntity>> {
+    const userTypeorm = await this.userRepository.findOne({
+      where: filter,
+    });
+    return this.userMapper.toEntity(userTypeorm);
+  }
+
   async findUnique(id: string) {
     this.logger.log('[Typeorm] findUnique', id);
     if (!uuid.validate(id)) return null;

src/infrastructure/typeorm/repositories/user.repository.spec.ts

@@ -159,4 +159,12 @@ describe('UserRepository', () => {
     const result = await repository.findMany({});
     expect(result).toEqual(users);
   });
+  it('should return only one user', async () => {
+    const user = mockUser;
+    jest
+      .spyOn(userRepository, 'findOne')
+      .mockImplementation(() => Promise.resolve(user));
+    const result = await repository.findOne({ username: user.username });
+    expect(result).toEqual(user);
+  });
 });