Feature/admin

iam/admin/admin.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+import { ADMIN_REPOSITORY } from './domain/admin.repository';
+import { AdminRepositoryImpl } from './infrastructure/admin.repository.impl';
+import { MikroOrmModule } from '@mikro-orm/nestjs';
+import { AdminEntity } from './infrastructure/admin.entity';
+import { SharedModule } from 'src/shared/shared.module';
+import { AdminController } from './presentation/admin.controller';
+import { GetAdminUseCase } from './application/get/get-admin.use-case';
+import { CreateAdminUseCase } from './application/create/create.use-case';
+
+const usecases = [GetAdminUseCase, CreateAdminUseCase];
+
+@Module({
+  imports: [MikroOrmModule.forFeature([AdminEntity]), SharedModule],
+  providers: [
+    ...usecases,
+    {
+      provide: ADMIN_REPOSITORY,
+      useClass: AdminRepositoryImpl,
+    },
+  ],
+  exports: [...usecases],
+  controllers: [AdminController],
+})
+export class AdminModule {}

iam/admin/application/create/create.command.ts

@@ -0,0 +1,3 @@
+export class CreateAdminCommand {
+  constructor(public readonly name: string) {}
+}

iam/admin/application/create/create.result.ts

@@ -0,0 +1,3 @@
+export class CreateAdminResult {
+  constructor(public readonly adminId: string) {}
+}

iam/admin/application/create/create.use-case.ts

@@ -0,0 +1,29 @@
+import { ADMIN_REPOSITORY, AdminRepository } from 'iam/admin/domain/admin.repository';
+import { CreateAdminCommand } from './create.command';
+import { CreateAdminResult } from './create.result';
+import { Inject, Injectable } from '@nestjs/common';
+import { Admin } from 'iam/admin/domain/admin';
+import { Identifier } from 'src/shared/core/domain/identifier';
+
+@Injectable()
+export class CreateAdminUseCase {
+  constructor(
+    @Inject(ADMIN_REPOSITORY)
+    private readonly adminRepository: AdminRepository,
+  ) {}
+
+  async execute(command: CreateAdminCommand): Promise<CreateAdminResult> {
+    const { name } = command;
+
+    const admin = Admin.create({
+      id: Identifier.create(),
+      name,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await this.adminRepository.save(admin);
+
+    return { adminId: admin.id.value };
+  }
+}

iam/admin/application/get/get-admin.query.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class GetAdminQuery {
+  @IsString()
+  @IsNotEmpty()
+  adminId: string;
+}

iam/admin/application/get/get-admin.use-case.ts

@@ -0,0 +1,18 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { ADMIN_REPOSITORY, AdminRepository } from 'iam/admin/domain/admin.repository';
+import { GetAdminQuery } from './get-admin.query';
+import { AdminView } from 'iam/admin/domain/admin.view';
+
+@Injectable()
+export class GetAdminUseCase {
+  constructor(
+    @Inject(ADMIN_REPOSITORY)
+    private readonly adminRepository: AdminRepository,
+  ) {}
+
+  async execute(query: GetAdminQuery): Promise<AdminView> {
+    const admin = await this.adminRepository.loadById(query.adminId);
+
+    return { name: admin.name };
+  }
+}

iam/admin/domain/admin.repository.ts

@@ -0,0 +1,8 @@
+import { Admin } from './admin';
+
+export interface AdminRepository {
+  save(admin: Admin): Promise<void>;
+  loadById(id: string): Promise<Admin>;
+}
+
+export const ADMIN_REPOSITORY = Symbol('ADMIN_REPOSITORY');

iam/admin/domain/admin.ts

@@ -0,0 +1,35 @@
+import { AggregateRoot } from 'src/shared/core/domain/base.aggregate';
+import { BaseEntityProps } from 'src/shared/core/domain/base.entity';
+import { CustomException } from 'src/shared/exception/custom-exception';
+import { CustomExceptionCode } from 'src/shared/exception/custom-exception-code';
+
+export interface AdminProps extends BaseEntityProps {
+  name: string;
+}
+
+export class Admin extends AggregateRoot<AdminProps> {
+  protected constructor(props: AdminProps) {
+    super(props);
+  }
+
+  public static create(props: AdminProps): Admin {
+    const admin = new Admin(props);
+    admin.validate();
+
+    return admin;
+  }
+
+  public static of(props: AdminProps): Admin {
+    return new Admin(props);
+  }
+
+  public validate(): void {
+    if (this.props.name.length < 1 || this.props.name.length > 20) {
+      throw new CustomException(CustomExceptionCode.ADMIN_INVALID_NAME_LENGTH);
+    }
+  }
+
+  get name(): string {
+    return this.props.name;
+  }
+}

iam/admin/domain/admin.view.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class AdminView {
+  @ApiProperty({
+    example: '이름',
+    description: '관리자 이름',
+  })
+  name: string;
+}

iam/admin/infrastructure/admin.entity.ts

@@ -0,0 +1,8 @@
+import { Entity, Property } from '@mikro-orm/core';
+import { BaseEntity } from 'src/shared/core/infrastructure/orm-entity/base.entity';
+
+@Entity({ tableName: 'admin' })
+export class AdminEntity extends BaseEntity {
+  @Property({ type: 'varchar' })
+  name: string;
+}

iam/admin/infrastructure/admin.mapper.ts

@@ -0,0 +1,24 @@
+import { Identifier } from 'src/shared/core/domain/identifier';
+import { Admin } from '../domain/admin';
+import { AdminEntity } from './admin.entity';
+
+export class AdminMapper {
+  static toDomain(entity: AdminEntity): Admin {
+    return Admin.create({
+      id: Identifier.from(entity.id),
+      name: entity.name,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    });
+  }
+
+  static toEntity(domain: Admin): AdminEntity {
+    const entity = new AdminEntity();
+    entity.id = domain.id.value;
+    entity.name = domain.name;
+    entity.createdAt = domain.createdAt;
+    entity.updatedAt = domain.updatedAt;
+
+    return entity;
+  }
+}

iam/admin/infrastructure/admin.repository.impl.ts

@@ -0,0 +1,28 @@
+import { EntityManager, EntityRepository } from '@mikro-orm/mysql';
+import { Admin } from '../domain/admin';
+import { AdminRepository } from '../domain/admin.repository';
+import { AdminMapper } from './admin.mapper';
+import { AdminEntity } from './admin.entity';
+import { InjectRepository } from '@mikro-orm/nestjs';
+import { CustomException } from 'src/shared/exception/custom-exception';
+import { CustomExceptionCode } from 'src/shared/exception/custom-exception-code';
+
+export class AdminRepositoryImpl implements AdminRepository {
+  constructor(
+    @InjectRepository(AdminEntity)
+    private readonly ormRepository: EntityRepository<AdminEntity>,
+    private readonly em: EntityManager,
+  ) {}
+
+  async save(admin: Admin): Promise<void> {
+    const entity = AdminMapper.toEntity(admin);
+    await this.em.persistAndFlush(entity);
+  }
+
+  async loadById(id: string): Promise<Admin> {
+    const entity = await this.ormRepository.findOne({ id });
+    if (!entity) throw new CustomException(CustomExceptionCode.ADMIN_NOT_FOUND);
+
+    return AdminMapper.toDomain(entity);
+  }
+}

iam/admin/presentation/admin.controller.ts

@@ -0,0 +1,22 @@
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { GetAdminUseCase } from '../application/get/get-admin.use-case';
+import { RolesGuard } from 'iam/auth/auth-core/infrastructure/guard/role.guard';
+import { AuthGuard } from '@nestjs/passport';
+import { Roles } from 'src/shared/core/presentation/role.decorator';
+import { Role } from 'iam/auth/auth-core/domain/value-object/role';
+import { Admin, AdminPayload } from 'src/shared/core/presentation/admin.decorator';
+import { AdminView } from '../domain/admin.view';
+
+@ApiTags('admin')
+@Controller('admin')
+export class AdminController {
+  constructor(private readonly getAdminUseCase: GetAdminUseCase) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt-access'), RolesGuard)
+  @Roles(Role.ADMIN)
+  async getAdminInfo(@Admin() admin: AdminPayload): Promise<AdminView> {
+    return await this.getAdminUseCase.execute({ adminId: admin.adminId });
+  }
+}

iam/auth/auth-admin/application/login/login.command.ts

@@ -0,0 +1,6 @@
+export class AdminLoginCommand {
+  constructor(
+    public readonly accountId: string,
+    public readonly password: string,
+  ) {}
+}

iam/auth/auth-admin/application/login/login.result.ts

@@ -0,0 +1,3 @@
+export class AdminLoginResult {
+  constructor(public readonly accessToken: string) {}
+}

iam/auth/auth-admin/application/login/login.use-case.ts

@@ -0,0 +1,47 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AUTH_ADMIN_REPOSITORY, AuthAdminRepository } from '../../domain/auth-admin.repository';
+import { AdminLoginCommand } from './login.command';
+import { PASSWORD_HASHER, PasswordHasher } from 'iam/auth/auth-core/domain/password-hasher';
+import { CustomException } from 'src/shared/exception/custom-exception';
+import { CustomExceptionCode } from 'src/shared/exception/custom-exception-code';
+import { TokenType } from 'iam/auth/auth-core/infrastructure/jwt/jwt.factory';
+import { AuthAdmin } from '../../domain/auth-admin';
+import { Role } from 'iam/auth/auth-core/domain/value-object/role';
+import { JwtProvider } from 'iam/auth/auth-core/infrastructure/jwt/jwt.provider';
+import { AdminLoginResult } from './login.result';
+
+@Injectable()
+export class AdminLoginUseCase {
+  constructor(
+    @Inject(AUTH_ADMIN_REPOSITORY)
+    private readonly authAdminRepository: AuthAdminRepository,
+    @Inject(PASSWORD_HASHER)
+    private readonly passwordHasher: PasswordHasher,
+    private readonly jwtProvider: JwtProvider,
+  ) {}
+
+  async execute(command: AdminLoginCommand): Promise<AdminLoginResult> {
+    const { accountId, password } = command;
+
+    const authAdmin = await this.validateAccount(accountId.trim(), password.trim());
+    const { accessToken } = await this.generateToken(authAdmin.adminId.value);
+
+    return { accessToken };
+  }
+
+  private async validateAccount(accountId: string, password: string): Promise<AuthAdmin> {
+    const authAdmin = await this.authAdminRepository.loadByAccountId(accountId);
+    if (!authAdmin) throw new CustomException(CustomExceptionCode.AUTH_ADMIN_NOT_FOUND);
+
+    const isPasswordValid = await this.passwordHasher.compare(password, authAdmin.passwordHash.value);
+    if (!isPasswordValid) throw new CustomException(CustomExceptionCode.AUTH_INVALID_PASSWORD);
+
+    return authAdmin;
+  }
+
+  private async generateToken(organizationId: string): Promise<{ accessToken: string }> {
+    const { token: accessToken } = await this.jwtProvider.generateToken(TokenType.ACCESS, organizationId, [Role.ADMIN]);
+
+    return { accessToken };
+  }
+}

iam/auth/auth-admin/application/register/register-admin.command.ts

@@ -0,0 +1,7 @@
+export class RegisterAdminCommand {
+  constructor(
+    public readonly accountId: string,
+    public readonly password: string,
+    public readonly name: string,
+  ) {}
+}

iam/auth/auth-admin/application/register/register-admin.result.ts

@@ -0,0 +1,3 @@
+export class RegisterAdminResult {
+  accessToken: string;
+}

iam/auth/auth-admin/application/register/register-admin.use-case.ts

@@ -0,0 +1,71 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AUTH_ADMIN_REPOSITORY, AuthAdminRepository } from '../../domain/auth-admin.repository';
+import { JwtProvider } from 'iam/auth/auth-core/infrastructure/jwt/jwt.provider';
+import { RegisterAdminCommand } from './register-admin.command';
+import { RegisterAdminResult } from './register-admin.result';
+import { CustomException } from 'src/shared/exception/custom-exception';
+import { CustomExceptionCode } from 'src/shared/exception/custom-exception-code';
+import { AuthAdmin } from '../../domain/auth-admin';
+import { TokenType } from 'iam/auth/auth-core/infrastructure/jwt/jwt.factory';
+import { Role } from 'iam/auth/auth-core/domain/value-object/role';
+import { Identifier } from 'src/shared/core/domain/identifier';
+import { AccountId } from 'iam/auth/auth-organization/domain/vo/account-id';
+import { PasswordHash } from 'iam/auth/auth-core/domain/value-object/password-hash';
+import { CreateAdminUseCase } from 'iam/admin/application/create/create.use-case';
+import { CreateAdminCommand } from 'iam/admin/application/create/create.command';
+import { Transactional } from '@mikro-orm/core';
+import { PASSWORD_HASHER, PasswordHasher } from 'iam/auth/auth-core/domain/password-hasher';
+
+@Injectable()
+export class RegisterAdminUseCase {
+  constructor(
+    @Inject(AUTH_ADMIN_REPOSITORY)
+    private readonly authAdminRepository: AuthAdminRepository,
+    @Inject(PASSWORD_HASHER)
+    private readonly passwordHasher: PasswordHasher,
+    private readonly jwtProvider: JwtProvider,
+    private readonly createAdminUseCase: CreateAdminUseCase,
+  ) {}
+
+  @Transactional()
+  async execute(command: RegisterAdminCommand): Promise<RegisterAdminResult> {
+    const { accountId, password, name } = command;
+    const existingAdmin = await this.authAdminRepository.loadByAccountId(accountId);
+    if (existingAdmin) throw new CustomException(CustomExceptionCode.AUTH_ADMIN_ALREADY_EXISTS);
+
+    const adminId = await this.createAdmin(name);
+    const authAdmin = await this.createAuthAdmin(accountId, password, adminId);
+    const accessToken = await this.generateToken(authAdmin.adminId.value);
+
+    return { accessToken };
+  }
+
+  private async createAdmin(name: string): Promise<string> {
+    const { adminId } = await this.createAdminUseCase.execute(new CreateAdminCommand(name));
+    return adminId;
+  }
+
+  private async createAuthAdmin(accountId: string, password: string, adminId: string): Promise<AuthAdmin> {
+    const passwordHash = await this.passwordHasher.hash(password);
+
+    const authAdmin = AuthAdmin.create({
+      id: Identifier.create(),
+      accountId: AccountId.create(accountId),
+      passwordHash: PasswordHash.create(passwordHash),
+      adminId: Identifier.from(adminId),
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      isDeleted: false,
+      deletedAt: null,
+    });
+
+    await this.authAdminRepository.save(authAdmin);
+
+    return authAdmin;
+  }
+
+  private async generateToken(adminId: string): Promise<string> {
+    const { token: accessToken } = await this.jwtProvider.generateToken(TokenType.ACCESS, adminId, [Role.ADMIN]);
+    return accessToken;
+  }
+}