cca-auth-module 0.1.53 → 0.1.55

package/dist/index.js

@@ -164,30 +164,10 @@ var createConfigInstance = /* @__PURE__ */ __name(async () => {
 
 // src/infrastructure/container/createAuthContainer.ts
 var import_cca_core11 = require("cca-core");
-var import_cca_entities6 = require("cca-entities");
+var import_cca_entities5 = require("cca-entities");
 
 // src/application/useCase/LoginUseCase.ts
 var import_cca_core = require("cca-core");
-var import_cca_entities3 = require("cca-entities");
-
-// src/application/dtos/UserDTO.ts
-var import_classes = require("@automapper/classes");
-var _UserDTO = class _UserDTO {
-};
-__name(_UserDTO, "UserDTO");
-__decorateClass([
-  (0, import_classes.AutoMap)()
-], _UserDTO.prototype, "id", 2);
-__decorateClass([
-  (0, import_classes.AutoMap)()
-], _UserDTO.prototype, "name", 2);
-__decorateClass([
-  (0, import_classes.AutoMap)()
-], _UserDTO.prototype, "email", 2);
-__decorateClass([
-  (0, import_classes.AutoMap)()
-], _UserDTO.prototype, "role", 2);
-var UserDTO = _UserDTO;
 
 // src/application/validators/authValidation.ts
 var yup = __toESM(require("yup"));
@@ -282,6 +262,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 (0, import_cca_core.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
+var import_cca_core2 = require("cca-core");
+var _LoginAdminUseCase = class _LoginAdminUseCase {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async initialize() {
+    await (0, import_cca_core2.validateRepository)(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
+var import_cca_core3 = require("cca-core");
+var _LogoutUseCase = class _LogoutUseCase {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async initialize() {
+    await (0, import_cca_core3.validateRepository)(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
+var import_cca_core4 = require("cca-core");
+var bcrypt2 = __toESM(require("bcrypt"));
+var import_cca_entities3 = require("cca-entities");
+
 // src/application/mappers/utils/mapper.ts
 var import_core2 = require("@automapper/core");
 var import_classes3 = require("@automapper/classes");
@@ -296,6 +343,25 @@ var _RegisterDTO = class _RegisterDTO {
 __name(_RegisterDTO, "RegisterDTO");
 var RegisterDTO = _RegisterDTO;
 
+// src/application/dtos/UserDTO.ts
+var import_classes = require("@automapper/classes");
+var _UserDTO = class _UserDTO {
+};
+__name(_UserDTO, "UserDTO");
+__decorateClass([
+  (0, import_classes.AutoMap)()
+], _UserDTO.prototype, "id", 2);
+__decorateClass([
+  (0, import_classes.AutoMap)()
+], _UserDTO.prototype, "name", 2);
+__decorateClass([
+  (0, import_classes.AutoMap)()
+], _UserDTO.prototype, "email", 2);
+__decorateClass([
+  (0, import_classes.AutoMap)()
+], _UserDTO.prototype, "role", 2);
+var UserDTO = _UserDTO;
+
 // src/application/dtos/AdminDTO.ts
 var import_classes2 = require("@automapper/classes");
 var _AdminDTO = class _AdminDTO {
@@ -357,127 +423,7 @@ var mapper = (0, import_core2.createMapper)({
 });
 createUserMappings(mapper);
 
-// src/application/useCase/LoginUseCase.ts
-var _LoginUseCase = class _LoginUseCase {
-  constructor(repository, authService) {
-    this.repository = repository;
-    this.authService = authService;
-  }
-  async initialize() {
-    await (0, import_cca_core.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, import_cca_entities3.UserEntity, UserDTO);
-  }
-};
-__name(_LoginUseCase, "LoginUseCase");
-var LoginUseCase = _LoginUseCase;
-
-// src/application/useCase/LoginAdminUseCase.ts
-var import_cca_core2 = require("cca-core");
-var import_cca_entities4 = require("cca-entities");
-var _LoginAdminUseCase = class _LoginAdminUseCase {
-  constructor(repository, authService) {
-    this.repository = repository;
-    this.authService = authService;
-  }
-  async initialize() {
-    await (0, import_cca_core2.validateRepository)(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, import_cca_entities4.AdminEntity, AdminDTO);
-  }
-};
-__name(_LoginAdminUseCase, "LoginAdminUseCase");
-var LoginAdminUseCase = _LoginAdminUseCase;
-
-// src/application/useCase/LogoutUseCase.ts
-var import_cca_core3 = require("cca-core");
-var _LogoutUseCase = class _LogoutUseCase {
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async initialize() {
-    await (0, import_cca_core3.validateRepository)(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
-var import_cca_core4 = require("cca-core");
-var bcrypt2 = __toESM(require("bcrypt"));
-var import_cca_entities5 = require("cca-entities");
 var _RegisterUseCase = class _RegisterUseCase {
   constructor(repository) {
     this.SALT_ROUNDS = 10;
@@ -486,7 +432,7 @@ var _RegisterUseCase = class _RegisterUseCase {
   async initialize() {
     await (0, import_cca_core4.validateRepository)(this.repository, (repo) => repo.getAll());
   }
-  async execute(email, name, password, role = import_cca_entities5.UserRole.GUEST, adminPassword) {
+  async execute(email, name, password, role = import_cca_entities3.UserRole.GUEST, adminPassword) {
     try {
       const normalizedDTO = this.normalizeAuthDTO({
         email,
@@ -495,7 +441,7 @@ var _RegisterUseCase = class _RegisterUseCase {
         role,
         adminPassword
       });
-      if (role === import_cca_entities5.UserRole.ADMIN && adminPassword) {
+      if (role === import_cca_entities3.UserRole.ADMIN && adminPassword) {
         await validateAdminSecret(adminPassword);
       }
       await validateRegisterDTO(normalizedDTO, this.repository);
@@ -522,8 +468,8 @@ var _RegisterUseCase = class _RegisterUseCase {
     return await bcrypt2.hash(password, this.SALT_ROUNDS);
   }
   async createAuthEntity(dto, hashedPassword) {
-    const authEntity = mapper.map(dto, RegisterDTO, import_cca_entities5.AuthEntity);
-    const userEntity = mapper.map(dto, RegisterDTO, import_cca_entities5.UserEntity);
+    const authEntity = mapper.map(dto, RegisterDTO, import_cca_entities3.AuthEntity);
+    const userEntity = mapper.map(dto, RegisterDTO, import_cca_entities3.UserEntity);
     authEntity.password = hashedPassword;
     authEntity.refreshToken = "";
     authEntity.user = userEntity;
@@ -547,6 +493,7 @@ var _RefreshTokenUseCase = class _RefreshTokenUseCase {
   async execute(refreshToken) {
     try {
       const decoded = await this.service.verifyRefreshToken(refreshToken);
+      console.log("Decoded refresh token:", decoded);
       const auth = decoded.userId ? await this.repository.findById(decoded.userId) : null;
       if (!auth || auth.refreshToken !== refreshToken) {
         return null;
@@ -558,13 +505,9 @@ var _RefreshTokenUseCase = class _RefreshTokenUseCase {
       });
       return { accessToken, refreshToken: newRefreshToken };
     } catch (error) {
-      console.error("Error in RefreshTokenUseCase:", error);
-      return null;
+      return error;
     }
   }
-  async verityToken(token) {
-    return await this.service.verifyAccessToken(token);
-  }
 };
 __name(_RefreshTokenUseCase, "RefreshTokenUseCase");
 var RefreshTokenUseCase = _RefreshTokenUseCase;
@@ -646,12 +589,13 @@ var TwoFactorEnableUseCase = _TwoFactorEnableUseCase;
 
 // src/application/useCase/TwoFactorVerifyUseCase.ts
 var import_cca_core7 = require("cca-core");
+var import_cca_entities4 = require("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;
@@ -660,7 +604,6 @@ var _TwoFactorVerifyUseCase = class _TwoFactorVerifyUseCase {
       this.jwtService.initialize(),
       (0, import_cca_core7.validateRepository)(this.authRepository, (repo) => repo.getAll())
     ]);
-    4;
     this.isInitialized = true;
   }
   async execute(dto) {
@@ -669,18 +612,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, import_cca_entities4.AdminEntity, AdminDTO);
+  }
+  mapUserToDTO(user) {
+    return mapper.map(user, import_cca_entities4.UserEntity, 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)
     };
   }
@@ -730,8 +708,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);
       }
@@ -760,6 +746,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);
       }
@@ -769,9 +756,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;
@@ -783,11 +767,7 @@ var _AuthController = class _AuthController {
     }, "setup2FA");
     this.enable2FA = /* @__PURE__ */ __name(async (req, res, next) => {
       try {
-        console.log("enable2FA req", req);
-        console.log("enable2FA called", req.body);
-        console.log("req.auth", req.auth);
-        console.log("req.auth.id", req.auth?.id);
-        const userId = req.auth.id;
+        const userId = req.auth?.id;
         const dto = req.body;
         await this.twoFactorEnableUseCase.execute(userId, dto);
         res.status(200).json({ message: "Two-factor authentication has been enabled successfully" });
@@ -812,7 +792,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);
       }
@@ -982,8 +965,11 @@ var _JwtAuthService = class _JwtAuthService {
   }
   async verifyToken(token, secret) {
     try {
+      console.log("Verifying token:", token);
+      console.log("Using secret:", secret);
       return jwt.verify(token, secret);
-    } catch {
+    } catch (error) {
+      console.error("Error verifying token:", error);
       throw new UnauthorizedError();
     }
   }
@@ -1094,7 +1080,7 @@ var TwoFactorService = _TwoFactorService;
 async function createAuthContainer(database) {
   const container = new import_cca_core11.BaseContainer({ database });
   const authRepository = new AuthRepository(
-    database.getRepository(import_cca_entities6.AuthEntity)
+    database.getRepository(import_cca_entities5.AuthEntity)
   );
   container.registerRepository("AuthRepository", authRepository);
   const jwtAuthService = new JwtAuthService(authRepository);
@@ -1103,10 +1089,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);