cca-auth-module 0.1.54 → 0.1.56

package/dist/index.mjs

@@ -129,30 +129,10 @@ var createConfigInstance = /* @__PURE__ */ __name(async () => {
 
 // src/infrastructure/container/createAuthContainer.ts
 import { BaseContainer } from "cca-core";
-import { AuthEntity as AuthEntity6 } from "cca-entities";
+import { AuthEntity as AuthEntity5 } from "cca-entities";
 
 // src/application/useCase/LoginUseCase.ts
 import { validateRepository } from "cca-core";
-import { UserEntity as UserEntity2 } from "cca-entities";
-
-// src/application/dtos/UserDTO.ts
-import { AutoMap } from "@automapper/classes";
-var _UserDTO = class _UserDTO {
-};
-__name(_UserDTO, "UserDTO");
-__decorateClass([
-  AutoMap()
-], _UserDTO.prototype, "id", 2);
-__decorateClass([
-  AutoMap()
-], _UserDTO.prototype, "name", 2);
-__decorateClass([
-  AutoMap()
-], _UserDTO.prototype, "email", 2);
-__decorateClass([
-  AutoMap()
-], _UserDTO.prototype, "role", 2);
-var UserDTO = _UserDTO;
 
 // src/application/validators/authValidation.ts
 import * as yup from "yup";
@@ -247,6 +227,73 @@ var validateAdminSecret = /* @__PURE__ */ __name(async (secretPassword) => {
   }
 }, "validateAdminSecret");
 
+// src/application/useCase/LoginUseCase.ts
+var _LoginUseCase = class _LoginUseCase {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async initialize() {
+    await validateRepository(this.repository, (repo) => repo.getAll());
+  }
+  async execute(loginDTO) {
+    const auth = await this.validateLogin(loginDTO);
+    return auth.user.id;
+  }
+  async validateLogin(loginDTO) {
+    const auth = await validateLoginDTO(loginDTO, this.repository);
+    return auth;
+  }
+};
+__name(_LoginUseCase, "LoginUseCase");
+var LoginUseCase = _LoginUseCase;
+
+// src/application/useCase/LoginAdminUseCase.ts
+import { validateRepository as validateRepository2 } from "cca-core";
+var _LoginAdminUseCase = class _LoginAdminUseCase {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async initialize() {
+    await validateRepository2(this.repository, (repo) => repo.getAll());
+  }
+  async execute(loginDTO, adminPassword) {
+    const auth = await this.validateLogin(loginDTO, adminPassword);
+    return auth.user.id;
+  }
+  async validateLogin(loginDTO, adminPassword) {
+    const auth = await validateLoginDTO(loginDTO, this.repository);
+    await validateAdminSecret(adminPassword);
+    return auth;
+  }
+};
+__name(_LoginAdminUseCase, "LoginAdminUseCase");
+var LoginAdminUseCase = _LoginAdminUseCase;
+
+// src/application/useCase/LogoutUseCase.ts
+import { validateRepository as validateRepository3 } from "cca-core";
+var _LogoutUseCase = class _LogoutUseCase {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async initialize() {
+    await validateRepository3(this.repository, (repo) => repo.getAll());
+  }
+  async execute(authId) {
+    try {
+      await this.repository.logout(authId);
+    } catch (error) {
+      new NotFoundError("Auth not found");
+    }
+  }
+};
+__name(_LogoutUseCase, "LogoutUseCase");
+var LogoutUseCase = _LogoutUseCase;
+
+// src/application/useCase/RegisterUseCase.ts
+import { validateRepository as validateRepository4 } from "cca-core";
+import * as bcrypt2 from "bcrypt";
+import { AuthEntity as AuthEntity3, UserEntity as UserEntity2, UserRole as UserRole2 } from "cca-entities";
+
 // src/application/mappers/utils/mapper.ts
 import { createMapper } from "@automapper/core";
 import { classes } from "@automapper/classes";
@@ -261,6 +308,25 @@ var _RegisterDTO = class _RegisterDTO {
 __name(_RegisterDTO, "RegisterDTO");
 var RegisterDTO = _RegisterDTO;
 
+// src/application/dtos/UserDTO.ts
+import { AutoMap } from "@automapper/classes";
+var _UserDTO = class _UserDTO {
+};
+__name(_UserDTO, "UserDTO");
+__decorateClass([
+  AutoMap()
+], _UserDTO.prototype, "id", 2);
+__decorateClass([
+  AutoMap()
+], _UserDTO.prototype, "name", 2);
+__decorateClass([
+  AutoMap()
+], _UserDTO.prototype, "email", 2);
+__decorateClass([
+  AutoMap()
+], _UserDTO.prototype, "role", 2);
+var UserDTO = _UserDTO;
+
 // src/application/dtos/AdminDTO.ts
 import { AutoMap as AutoMap2 } from "@automapper/classes";
 var _AdminDTO = class _AdminDTO {
@@ -322,127 +388,7 @@ var mapper = createMapper({
 });
 createUserMappings(mapper);
 
-// src/application/useCase/LoginUseCase.ts
-var _LoginUseCase = class _LoginUseCase {
-  constructor(repository, authService) {
-    this.repository = repository;
-    this.authService = authService;
-  }
-  async initialize() {
-    await validateRepository(this.repository, (repo) => repo.getAll());
-  }
-  async execute(loginDTO) {
-    const auth = await this.validateLogin(loginDTO);
-    const token = await this.handleAuthentication(auth);
-    const userDTO = this.mapUserToDTO(auth.user);
-    return { token, user: userDTO };
-  }
-  async validateLogin(loginDTO) {
-    const auth = await validateLoginDTO(loginDTO, this.repository);
-    return auth;
-  }
-  async handleAuthentication(auth) {
-    const token = this.generateTokens(auth);
-    await this.updateUserStatus(auth);
-    await this.updateUserRefreshToken(auth, token.refreshToken);
-    return token;
-  }
-  generateTokens(auth) {
-    return {
-      accessToken: this.authService.generateAccessToken(auth.user, auth.role),
-      refreshToken: this.authService.generateRefreshToken(auth.user)
-    };
-  }
-  async updateUserStatus(auth) {
-    auth.user.lastLoginAt = /* @__PURE__ */ new Date();
-    auth.user.isActive = true;
-    await this.repository.update(auth.id, auth);
-  }
-  async updateUserRefreshToken(auth, refreshToken) {
-    auth.refreshToken = refreshToken;
-    await this.repository.update(auth.id, { refreshToken });
-  }
-  mapUserToDTO(user) {
-    return mapper.map(user, UserEntity2, UserDTO);
-  }
-};
-__name(_LoginUseCase, "LoginUseCase");
-var LoginUseCase = _LoginUseCase;
-
-// src/application/useCase/LoginAdminUseCase.ts
-import { validateRepository as validateRepository2 } from "cca-core";
-import { AdminEntity as AdminEntity2 } from "cca-entities";
-var _LoginAdminUseCase = class _LoginAdminUseCase {
-  constructor(repository, authService) {
-    this.repository = repository;
-    this.authService = authService;
-  }
-  async initialize() {
-    await validateRepository2(this.repository, (repo) => repo.getAll());
-  }
-  async execute(loginDTO, adminPassword) {
-    const auth = await this.validateLogin(loginDTO, adminPassword);
-    const token = await this.handleAuthentication(auth);
-    const userDTO = this.mapUserToDTO(auth.admin);
-    return { token, user: userDTO };
-  }
-  async validateLogin(loginDTO, adminPassword) {
-    const auth = await validateLoginDTO(loginDTO, this.repository);
-    await validateAdminSecret(adminPassword);
-    return auth;
-  }
-  async handleAuthentication(auth) {
-    const token = this.generateTokens(auth);
-    await this.updateUserStatus(auth);
-    await this.updateUserRefreshToken(auth, token.refreshToken);
-    return token;
-  }
-  generateTokens(auth) {
-    return {
-      accessToken: this.authService.generateAccessToken(auth.admin, auth.role),
-      refreshToken: this.authService.generateRefreshToken(auth.admin)
-    };
-  }
-  async updateUserStatus(auth) {
-    auth.admin.lastLoginAt = /* @__PURE__ */ new Date();
-    auth.admin.isActive = true;
-    await this.repository.update(auth.id, auth);
-  }
-  async updateUserRefreshToken(auth, refreshToken) {
-    auth.refreshToken = refreshToken;
-    await this.repository.update(auth.id, { refreshToken });
-  }
-  mapUserToDTO(admin) {
-    return mapper.map(admin, AdminEntity2, AdminDTO);
-  }
-};
-__name(_LoginAdminUseCase, "LoginAdminUseCase");
-var LoginAdminUseCase = _LoginAdminUseCase;
-
-// src/application/useCase/LogoutUseCase.ts
-import { validateRepository as validateRepository3 } from "cca-core";
-var _LogoutUseCase = class _LogoutUseCase {
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async initialize() {
-    await validateRepository3(this.repository, (repo) => repo.getAll());
-  }
-  async execute(authId) {
-    try {
-      await this.repository.logout(authId);
-    } catch (error) {
-      new NotFoundError("Auth not found");
-    }
-  }
-};
-__name(_LogoutUseCase, "LogoutUseCase");
-var LogoutUseCase = _LogoutUseCase;
-
 // src/application/useCase/RegisterUseCase.ts
-import { validateRepository as validateRepository4 } from "cca-core";
-import * as bcrypt2 from "bcrypt";
-import { AuthEntity as AuthEntity5, UserEntity as UserEntity3, UserRole as UserRole3 } from "cca-entities";
 var _RegisterUseCase = class _RegisterUseCase {
   constructor(repository) {
     this.SALT_ROUNDS = 10;
@@ -451,7 +397,7 @@ var _RegisterUseCase = class _RegisterUseCase {
   async initialize() {
     await validateRepository4(this.repository, (repo) => repo.getAll());
   }
-  async execute(email, name, password, role = UserRole3.GUEST, adminPassword) {
+  async execute(email, name, password, role = UserRole2.GUEST, adminPassword) {
     try {
       const normalizedDTO = this.normalizeAuthDTO({
         email,
@@ -460,7 +406,7 @@ var _RegisterUseCase = class _RegisterUseCase {
         role,
         adminPassword
       });
-      if (role === UserRole3.ADMIN && adminPassword) {
+      if (role === UserRole2.ADMIN && adminPassword) {
         await validateAdminSecret(adminPassword);
       }
       await validateRegisterDTO(normalizedDTO, this.repository);
@@ -487,8 +433,8 @@ var _RegisterUseCase = class _RegisterUseCase {
     return await bcrypt2.hash(password, this.SALT_ROUNDS);
   }
   async createAuthEntity(dto, hashedPassword) {
-    const authEntity = mapper.map(dto, RegisterDTO, AuthEntity5);
-    const userEntity = mapper.map(dto, RegisterDTO, UserEntity3);
+    const authEntity = mapper.map(dto, RegisterDTO, AuthEntity3);
+    const userEntity = mapper.map(dto, RegisterDTO, UserEntity2);
     authEntity.password = hashedPassword;
     authEntity.refreshToken = "";
     authEntity.user = userEntity;
@@ -512,23 +458,34 @@ var _RefreshTokenUseCase = class _RefreshTokenUseCase {
   async execute(refreshToken) {
     try {
       const decoded = await this.service.verifyRefreshToken(refreshToken);
-      const auth = decoded.userId ? await this.repository.findById(decoded.userId) : null;
-      if (!auth || auth.refreshToken !== refreshToken) {
+      const user = decoded.userId ? await this.repository.findById(decoded.userId) : null;
+      if (!user) {
+        console.error("User not found for id:", decoded.userId);
         return null;
       }
-      const accessToken = this.service.generateAccessToken(auth.user, auth.role);
-      const newRefreshToken = this.service.generateRefreshToken(auth.user);
-      await this.repository.update(auth.id, {
-        refreshToken: newRefreshToken
-      });
+      console.log("User entity found with role:", user.role);
+      let authEntity = null;
+      if (user.role === "user" && user.user) {
+        authEntity = await this.repository.findByUseAdminId(user.user.id);
+      } else if (user.role === "admin" && user.admin) {
+        authEntity = await this.repository.findByUseAdminId(user.admin.id, true);
+      } else {
+        console.error("User role not recognized or missing relations:", user.role);
+        return null;
+      }
+      if (!authEntity || authEntity.refreshToken !== refreshToken) {
+        console.error("Invalid refresh token or auth entity not found.");
+        return null;
+      }
+      const accessToken = this.service.generateAccessToken(user.user, authEntity.role);
+      const newRefreshToken = this.service.generateRefreshToken(authEntity.user);
+      await this.repository.update(authEntity.id, { refreshToken: newRefreshToken });
       return { accessToken, refreshToken: newRefreshToken };
     } catch (error) {
+      console.error("Error in refresh token process:", error);
       return null;
     }
   }
-  async verityToken(token) {
-    return await this.service.verifyAccessToken(token);
-  }
 };
 __name(_RefreshTokenUseCase, "RefreshTokenUseCase");
 var RefreshTokenUseCase = _RefreshTokenUseCase;
@@ -610,12 +567,13 @@ var TwoFactorEnableUseCase = _TwoFactorEnableUseCase;
 
 // src/application/useCase/TwoFactorVerifyUseCase.ts
 import { validateRepository as validateRepository7 } from "cca-core";
+import { AdminEntity as AdminEntity2, UserEntity as UserEntity3 } from "cca-entities";
 var _TwoFactorVerifyUseCase = class _TwoFactorVerifyUseCase {
   constructor(twoFactorService, authRepository, jwtService) {
-    this.isInitialized = false;
     this.twoFactorService = twoFactorService;
     this.authRepository = authRepository;
     this.jwtService = jwtService;
+    this.isInitialized = false;
   }
   async initialize() {
     if (this.isInitialized) return;
@@ -624,7 +582,6 @@ var _TwoFactorVerifyUseCase = class _TwoFactorVerifyUseCase {
       this.jwtService.initialize(),
       validateRepository7(this.authRepository, (repo) => repo.getAll())
     ]);
-    4;
     this.isInitialized = true;
   }
   async execute(dto) {
@@ -633,18 +590,53 @@ var _TwoFactorVerifyUseCase = class _TwoFactorVerifyUseCase {
     }
     const { userId, token } = dto;
     if (!userId || !token) {
-      throw new TwoFactorError("user ID and token are required");
+      throw new TwoFactorError("User ID and token are required.");
     }
     const auth = await this.authRepository.findByUserId(userId);
     if (!auth || !auth.twoFactorSecret || !auth.twoFactorEnabled) {
-      throw new TwoFactorError("Invalid request");
+      throw new TwoFactorError("Invalid request.");
     }
     const isValid = this.twoFactorService.verifyToken(token, auth.twoFactorSecret);
     if (!isValid) {
-      throw new TwoFactorError("Invalid verification code");
+      throw new TwoFactorError("Invalid verification code.");
     }
+    const tokenPair = this.generateTokens(auth);
+    await this.updateUserStatus(auth);
+    await this.updateUserRefreshToken(auth, tokenPair.refreshToken);
+    if (auth.admin) {
+      return {
+        token: tokenPair.accessToken,
+        refreshToken: tokenPair.refreshToken,
+        data: this.mapAdminToDTO(auth.admin)
+      };
+    }
+    if (auth.user) {
+      return {
+        token: tokenPair.accessToken,
+        refreshToken: tokenPair.refreshToken,
+        data: this.mapUserToDTO(auth.user)
+      };
+    }
+    return null;
+  }
+  mapAdminToDTO(admin) {
+    return mapper.map(admin, AdminEntity2, AdminDTO);
+  }
+  mapUserToDTO(user) {
+    return mapper.map(user, UserEntity3, UserDTO);
+  }
+  async updateUserStatus(auth) {
+    auth.user.lastLoginAt = /* @__PURE__ */ new Date();
+    auth.user.isActive = true;
+    await this.authRepository.update(auth.id, auth);
+  }
+  async updateUserRefreshToken(auth, refreshToken) {
+    auth.refreshToken = refreshToken;
+    await this.authRepository.update(auth.id, { refreshToken });
+  }
+  generateTokens(auth) {
     return {
-      token: this.jwtService.generateAccessToken(auth.user, auth.role),
+      accessToken: this.jwtService.generateAccessToken(auth.user, auth.role),
       refreshToken: this.jwtService.generateRefreshToken(auth.user)
     };
   }
@@ -694,8 +686,16 @@ var _AuthController = class _AuthController {
     this.login = /* @__PURE__ */ __name(async (req, res, next) => {
       try {
         const { adminPassword, ...loginDTO } = req.body;
-        const result = await this.loginUseCase.execute(loginDTO);
-        res.status(201).json(result);
+        const id = await this.loginUseCase.execute(loginDTO);
+        res.status(201).json(
+          {
+            status: "pending",
+            message: "Enter 2FA code",
+            data: {
+              userId: id
+            }
+          }
+        );
       } catch (error) {
         next(error);
       }
@@ -724,6 +724,7 @@ var _AuthController = class _AuthController {
       try {
         const { email, name, password, role, adminPassword } = req.body;
         await this.registerUseCase.execute(email, name, password, role, adminPassword);
+        res.status(200).json({ status: "success" });
       } catch (error) {
         next(error);
       }
@@ -733,9 +734,6 @@ var _AuthController = class _AuthController {
       const result = await this.refreshTokenUseCase.execute(refreshToken);
       res.json(result);
     }, "refreshToken");
-    this.verifyToken = /* @__PURE__ */ __name(async (token) => {
-      return await this.refreshTokenUseCase.verityToken(token);
-    }, "verifyToken");
     this.setup2FA = /* @__PURE__ */ __name(async (req, res, next) => {
       try {
         const userId = req.auth.id;
@@ -772,7 +770,10 @@ var _AuthController = class _AuthController {
         const userId = req.auth.id;
         const dto = req.body;
         await this.twoFactorDisableUseCase.execute(userId, dto);
-        res.status(200).json({ message: "Two-factor authentication has been disabled successfully" });
+        res.status(200).json({
+          status: "success",
+          message: "Two-factor authentication has been disabled successfully"
+        });
       } catch (error) {
         next(error);
       }
@@ -838,6 +839,15 @@ var _AuthRepository = class _AuthRepository extends BaseRepository {
     return await query.getOne();
     ;
   }
+  async findByUseAdminId(userId, isAdmin = false) {
+    const query = this.repository.createQueryBuilder("auth").addSelect("auth.twoFactorSecret");
+    if (isAdmin) {
+      query.leftJoinAndSelect("auth.admin", "admin").where("admin.id = :userId", { userId });
+    } else {
+      query.leftJoinAndSelect("auth.user", "user").where("user.id = :userId", { userId });
+    }
+    return await query.getOne();
+  }
   async logout(userId) {
     const auth = await this.findByUserId(userId);
     if (!auth) {
@@ -1057,7 +1067,7 @@ var TwoFactorService = _TwoFactorService;
 async function createAuthContainer(database) {
   const container = new BaseContainer({ database });
   const authRepository = new AuthRepository(
-    database.getRepository(AuthEntity6)
+    database.getRepository(AuthEntity5)
   );
   container.registerRepository("AuthRepository", authRepository);
   const jwtAuthService = new JwtAuthService(authRepository);
@@ -1066,10 +1076,9 @@ async function createAuthContainer(database) {
   const twoFactorService = new TwoFactorService(configData);
   container.registerService("TwoFactorService", twoFactorService);
   const requireComplete2FA = new RequireComplete2FA(jwtAuthService);
-  const loginUseCase = new LoginUseCase(authRepository, jwtAuthService);
+  const loginUseCase = new LoginUseCase(authRepository);
   const loginAdminUseCase = new LoginAdminUseCase(
-    authRepository,
-    jwtAuthService
+    authRepository
   );
   const logoutUseCase = new LogoutUseCase(authRepository);
   const registerUseCase = new RegisterUseCase(authRepository);