cca-auth-module 0.1.32 → 0.1.34

package/dist/application/useCase/LoginUseCase.d.ts

@@ -1,6 +1,6 @@
 import { IBaseService } from "cca-core";
 import { AuthRepository } from "../../infrastructure/repository/AuthRepository";
-import { JwtAuthService } from "../../infrastructure/auth/JwtAuthService";
+import { JwtAuthService } from "../../infrastructure/services/JwtAuthService";
 import { UserDTO } from "../dtos/UserDTO";
 import { LoginDTO } from "../dtos/LoginDTO";
 interface TokenPair {

package/dist/application/useCase/RefreshTokenUseCase.d.ts

@@ -1,6 +1,6 @@
 import { IBaseService } from "cca-core";
 import { IDecodedToken } from "../../domain/interfaces/IDecodedToken";
-import { JwtAuthService } from "../../infrastructure/auth/JwtAuthService";
+import { JwtAuthService } from "../../infrastructure/services/JwtAuthService";
 import { AuthRepository } from "../../infrastructure/repository/AuthRepository";
 export declare class RefreshTokenUseCase implements IBaseService {
     private readonly repository;

package/dist/application/useCase/TwoFactorDisableUseCase.d.ts

@@ -0,0 +1,12 @@
+import { IBaseService } from 'cca-core';
+import { TwoFactorService } from '../../infrastructure/services/TwoFactorService';
+import { AuthRepository } from '../../infrastructure/repository/AuthRepository';
+import { ITwoFactorEnable } from '../../domain/interfaces/ITwoFactorEnable';
+export declare class TwoFactorDisableUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string, dto: ITwoFactorEnable): Promise<void>;
+}

package/dist/application/useCase/TwoFactorEnableUseCase.d.ts

@@ -0,0 +1,12 @@
+import { IBaseService } from 'cca-core';
+import { TwoFactorService } from '../../infrastructure/services/TwoFactorService';
+import { AuthRepository } from '../../infrastructure/repository/AuthRepository';
+import { ITwoFactorEnable } from '../../domain/interfaces/ITwoFactorEnable';
+export declare class TwoFactorEnableUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string, dto: ITwoFactorEnable): Promise<void>;
+}

package/dist/application/useCase/TwoFactorSetupUseCase.d.ts

@@ -0,0 +1,12 @@
+import { IBaseService } from 'cca-core';
+import { TwoFactorService } from '../../infrastructure/services/TwoFactorService';
+import { AuthRepository } from '../../infrastructure/repository/AuthRepository';
+import { ITwoFactorSetupResponse } from '../../domain/interfaces/ITwoFactorSetupResponse';
+export declare class TwoFactorSetupUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string): Promise<ITwoFactorSetupResponse>;
+}

package/dist/application/useCase/TwoFactorVerifyUseCase.d.ts

@@ -0,0 +1,17 @@
+import { IBaseService } from 'cca-core';
+import { TwoFactorService } from '../../infrastructure/services/TwoFactorService';
+import { AuthRepository } from '../../infrastructure/repository/AuthRepository';
+import { JwtAuthService } from '../../infrastructure/services/JwtAuthService';
+import { ITwoFactorVerify } from '../../domain/interfaces/ITwoFactorVerify';
+export declare class TwoFactorVerifyUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private jwtService;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository, jwtService: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(dto: ITwoFactorVerify): Promise<{
+        token: string;
+        refreshToken: string;
+    }>;
+}

package/dist/domain/interfaces/ITwoFactorEnable.d.ts

@@ -0,0 +1,3 @@
+export interface ITwoFactorEnable {
+    token: string;
+}

package/dist/domain/interfaces/ITwoFactorSetupResponse.d.ts

@@ -0,0 +1,5 @@
+export interface ITwoFactorSetupResponse {
+    secret: string;
+    otpAuthUrl: string;
+    qrCodeUrl: string;
+}

package/dist/domain/interfaces/ITwoFactorVerify.d.ts

@@ -0,0 +1,4 @@
+export interface ITwoFactorVerify {
+    userId: string;
+    token: string;
+}

package/dist/domain/interfaces/configTypes.d.ts

@@ -4,5 +4,8 @@ export interface IConfig {
     accessTokenExpiry: string;
     refreshTokenExpiry: string;
     adminSecretPassword: string;
+    app_name: string;
+    secretLength: string;
+    tokenWindow: string;
 }
 export type ConfigSource = () => Promise<IConfig>;

package/dist/index.d.mts

@@ -11,6 +11,9 @@ interface IConfig {
     accessTokenExpiry: string;
     refreshTokenExpiry: string;
     adminSecretPassword: string;
+    app_name: string;
+    secretLength: string;
+    tokenWindow: string;
 }
 type ConfigSource = () => Promise<IConfig>;
 
@@ -22,6 +25,11 @@ declare class AuthRepository extends BaseRepository<AuthEntity> implements IExte
     create(entity: Omit<AuthEntity, "createdAt">): Promise<AuthEntity>;
     findByUserId(userId: string): Promise<AuthEntity | null>;
     logout(userId: string): Promise<void>;
+    updateTwoFactorSecret(userId: string, secret: string): Promise<void>;
+    enableTwoFactor(userId: string): Promise<void>;
+    disableTwoFactor(userId: string): Promise<void>;
+    isTwoFactorEnabled(userId: string): Promise<boolean>;
+    getTwoFactorSecret(userId: string): Promise<string | null>;
 }
 
 declare class RegisterUseCase implements IBaseService {
@@ -128,22 +136,108 @@ declare class RefreshTokenUseCase implements IBaseService {
     verityToken(token: string): Promise<IDecodedToken>;
 }
 
+declare class TwoFactorService implements IBaseService {
+    private readonly config;
+    private initialized;
+    private readonly twoFactorConfig;
+    constructor(config: IConfig);
+    initialize(): Promise<void>;
+    private validateConfiguration;
+    private ensureInitialized;
+    generateSecret(email: string): {
+        secret: string;
+        otpAuthUrl: string;
+    };
+    generateQRCode(otpAuthUrl: string): Promise<string>;
+    verifyToken(token: string, secret: string): boolean;
+}
+
+interface ITwoFactorSetupResponse {
+    secret: string;
+    otpAuthUrl: string;
+    qrCodeUrl: string;
+}
+
+declare class TwoFactorSetupUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string): Promise<ITwoFactorSetupResponse>;
+}
+
+interface ITwoFactorEnable {
+    token: string;
+}
+
+declare class TwoFactorEnableUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string, dto: ITwoFactorEnable): Promise<void>;
+}
+
+interface ITwoFactorVerify {
+    userId: string;
+    token: string;
+}
+
+declare class TwoFactorVerifyUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private jwtService;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository, jwtService: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(dto: ITwoFactorVerify): Promise<{
+        token: string;
+        refreshToken: string;
+    }>;
+}
+
+declare class TwoFactorDisableUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string, dto: ITwoFactorEnable): Promise<void>;
+}
+
 declare class AuthController {
-    private loginUseCase;
+    private readonly loginUseCase;
     private readonly logoutUseCase;
-    private registerUseCase;
-    private refreshTokenUseCase;
-    constructor(loginUseCase: LoginUseCase, logoutUseCase: LogoutUseCase, registerUseCase: RegisterUseCase, refreshTokenUseCase: RefreshTokenUseCase);
+    private readonly registerUseCase;
+    private readonly refreshTokenUseCase;
+    private twoFactorSetupUseCase;
+    private twoFactorEnableUseCase;
+    private twoFactorVerifyUseCase;
+    private twoFactorDisableUseCase;
+    constructor(loginUseCase: LoginUseCase, logoutUseCase: LogoutUseCase, registerUseCase: RegisterUseCase, refreshTokenUseCase: RefreshTokenUseCase, twoFactorSetupUseCase: TwoFactorSetupUseCase, twoFactorEnableUseCase: TwoFactorEnableUseCase, twoFactorVerifyUseCase: TwoFactorVerifyUseCase, twoFactorDisableUseCase: TwoFactorDisableUseCase);
     login: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     logout: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     register: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     refreshToken: (req: Request, res: Response) => Promise<void>;
     verifyToken: (token: string) => Promise<IDecodedToken>;
+    setup2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    enable2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    verify2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    disable2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+}
+
+declare class RequireComplete2FA {
+    private readonly jwtService;
+    constructor(jwtService: JwtAuthService);
+    execute(req: Request, res: Response, next: NextFunction): Promise<Response<any, Record<string, any>> | undefined>;
 }
 
-declare function createAuthContainer(database: BaseDatabase): {
+declare function createAuthContainer(database: BaseDatabase): Promise<{
     container: BaseContainer;
     authController: AuthController;
-};
+    requireComplete2FA: RequireComplete2FA;
+}>;
 
 export { AuthController, type ConfigSource, type IConfig, authConfig, createAuthContainer };

package/dist/index.d.ts

@@ -11,6 +11,9 @@ interface IConfig {
     accessTokenExpiry: string;
     refreshTokenExpiry: string;
     adminSecretPassword: string;
+    app_name: string;
+    secretLength: string;
+    tokenWindow: string;
 }
 type ConfigSource = () => Promise<IConfig>;
 
@@ -22,6 +25,11 @@ declare class AuthRepository extends BaseRepository<AuthEntity> implements IExte
     create(entity: Omit<AuthEntity, "createdAt">): Promise<AuthEntity>;
     findByUserId(userId: string): Promise<AuthEntity | null>;
     logout(userId: string): Promise<void>;
+    updateTwoFactorSecret(userId: string, secret: string): Promise<void>;
+    enableTwoFactor(userId: string): Promise<void>;
+    disableTwoFactor(userId: string): Promise<void>;
+    isTwoFactorEnabled(userId: string): Promise<boolean>;
+    getTwoFactorSecret(userId: string): Promise<string | null>;
 }
 
 declare class RegisterUseCase implements IBaseService {
@@ -128,22 +136,108 @@ declare class RefreshTokenUseCase implements IBaseService {
     verityToken(token: string): Promise<IDecodedToken>;
 }
 
+declare class TwoFactorService implements IBaseService {
+    private readonly config;
+    private initialized;
+    private readonly twoFactorConfig;
+    constructor(config: IConfig);
+    initialize(): Promise<void>;
+    private validateConfiguration;
+    private ensureInitialized;
+    generateSecret(email: string): {
+        secret: string;
+        otpAuthUrl: string;
+    };
+    generateQRCode(otpAuthUrl: string): Promise<string>;
+    verifyToken(token: string, secret: string): boolean;
+}
+
+interface ITwoFactorSetupResponse {
+    secret: string;
+    otpAuthUrl: string;
+    qrCodeUrl: string;
+}
+
+declare class TwoFactorSetupUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string): Promise<ITwoFactorSetupResponse>;
+}
+
+interface ITwoFactorEnable {
+    token: string;
+}
+
+declare class TwoFactorEnableUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string, dto: ITwoFactorEnable): Promise<void>;
+}
+
+interface ITwoFactorVerify {
+    userId: string;
+    token: string;
+}
+
+declare class TwoFactorVerifyUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private jwtService;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository, jwtService: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(dto: ITwoFactorVerify): Promise<{
+        token: string;
+        refreshToken: string;
+    }>;
+}
+
+declare class TwoFactorDisableUseCase implements IBaseService {
+    private twoFactorService;
+    private authRepository;
+    private isInitialized;
+    constructor(twoFactorService: TwoFactorService, authRepository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(userId: string, dto: ITwoFactorEnable): Promise<void>;
+}
+
 declare class AuthController {
-    private loginUseCase;
+    private readonly loginUseCase;
     private readonly logoutUseCase;
-    private registerUseCase;
-    private refreshTokenUseCase;
-    constructor(loginUseCase: LoginUseCase, logoutUseCase: LogoutUseCase, registerUseCase: RegisterUseCase, refreshTokenUseCase: RefreshTokenUseCase);
+    private readonly registerUseCase;
+    private readonly refreshTokenUseCase;
+    private twoFactorSetupUseCase;
+    private twoFactorEnableUseCase;
+    private twoFactorVerifyUseCase;
+    private twoFactorDisableUseCase;
+    constructor(loginUseCase: LoginUseCase, logoutUseCase: LogoutUseCase, registerUseCase: RegisterUseCase, refreshTokenUseCase: RefreshTokenUseCase, twoFactorSetupUseCase: TwoFactorSetupUseCase, twoFactorEnableUseCase: TwoFactorEnableUseCase, twoFactorVerifyUseCase: TwoFactorVerifyUseCase, twoFactorDisableUseCase: TwoFactorDisableUseCase);
     login: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     logout: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     register: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     refreshToken: (req: Request, res: Response) => Promise<void>;
     verifyToken: (token: string) => Promise<IDecodedToken>;
+    setup2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    enable2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    verify2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    disable2FA: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+}
+
+declare class RequireComplete2FA {
+    private readonly jwtService;
+    constructor(jwtService: JwtAuthService);
+    execute(req: Request, res: Response, next: NextFunction): Promise<Response<any, Record<string, any>> | undefined>;
 }
 
-declare function createAuthContainer(database: BaseDatabase): {
+declare function createAuthContainer(database: BaseDatabase): Promise<{
     container: BaseContainer;
     authController: AuthController;
-};
+    requireComplete2FA: RequireComplete2FA;
+}>;
 
 export { AuthController, type ConfigSource, type IConfig, authConfig, createAuthContainer };