cca-auth-module 0.0.1

package/dist/application/dtos/LoginDTO.d.ts

@@ -0,0 +1,7 @@
+import { UserRole } from "cca-entities";
+export declare class LoginDTO {
+    email: string;
+    password: string;
+    adminPassword?: string;
+    role: UserRole;
+}

package/dist/application/dtos/RegisterDTO.d.ts

@@ -0,0 +1,8 @@
+import { UserRole } from "cca-entities";
+export declare class RegisterDTO {
+    email: string;
+    name: string;
+    password: string;
+    role: UserRole;
+    adminPassword?: string;
+}

package/dist/application/dtos/UserDTO.d.ts

@@ -0,0 +1,8 @@
+import { UserRole } from "cca-entities";
+export declare class UserDTO {
+    id: string;
+    name: string;
+    email: string;
+    role: UserRole;
+    adminPassword?: string;
+}

package/dist/application/mappers/createUserMappings.d.ts

@@ -0,0 +1,2 @@
+import { Mapper } from '@automapper/core';
+export declare function createUserMappings(mapper: Mapper): void;

package/dist/application/mappers/utils/mapper.d.ts

@@ -0,0 +1 @@
+export declare const mapper: import("@automapper/core").Mapper;

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

@@ -0,0 +1,20 @@
+import { IBaseService } from "cca-core";
+import { AuthRepository } from "../../infrastructure/repository/AuthRepository";
+import { JwtAuthService } from "../../infrastructure/auth/JwtAuthService";
+import { UserDTO } from "../dtos/UserDTO";
+import { LoginDTO } from "../dtos/LoginDTO";
+export declare class LoginUseCase implements IBaseService {
+    private readonly repository;
+    private readonly authService;
+    constructor(repository: AuthRepository, authService: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(loginDTO: LoginDTO, adminPassword?: string): Promise<{
+        token: {
+            accessToken: string;
+            refreshToken: string;
+        };
+        user: UserDTO;
+    }>;
+    private generateTokens;
+    private updateUserRefreshToken;
+}

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

@@ -0,0 +1,15 @@
+import { IBaseService } from "cca-core";
+import { IDecodedToken } from "../../domain/interfaces/IDecodedToken";
+import { JwtAuthService } from "../../infrastructure/auth/JwtAuthService";
+import { AuthRepository } from "../../infrastructure/repository/AuthRepository";
+export declare class RefreshTokenUseCase implements IBaseService {
+    private readonly repository;
+    private readonly service;
+    constructor(repository: AuthRepository, service: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    } | null>;
+    verityToken(token: string): Promise<IDecodedToken>;
+}

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

@@ -0,0 +1,13 @@
+import { IBaseService } from "cca-core";
+import { AuthEntity, UserRole } from "cca-entities";
+import { AuthRepository } from "../../infrastructure/repository/AuthRepository";
+export declare class RegisterUseCase implements IBaseService {
+    private readonly repository;
+    private readonly SALT_ROUNDS;
+    constructor(repository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(email: string, name: string, password: string, role?: UserRole): Promise<AuthEntity>;
+    private normalizeAuthDTO;
+    private hashPassword;
+    private createAuthEntity;
+}

package/dist/application/validators/authValidation.d.ts

@@ -0,0 +1,10 @@
+import { AuthEntity } from "cca-entities";
+import { AuthRepository } from "../../infrastructure/repository/AuthRepository";
+import { RegisterDTO } from "../dtos/RegisterDTO";
+import { LoginDTO } from "../dtos/LoginDTO";
+export declare const validateEmail: (email: string, repository: AuthRepository) => Promise<AuthEntity>;
+export declare const validatePassword: (password?: string) => Promise<void>;
+export declare const validateEmailUniqueness: (repository: AuthRepository, email: string, excludeUserId?: string) => Promise<void>;
+export declare const validateRegisterDTO: (auth: RegisterDTO, repository: AuthRepository) => Promise<void>;
+export declare const validateLoginDTO: (data: LoginDTO, repository: AuthRepository) => Promise<AuthEntity>;
+export declare const validateAdminSecret: (secretPassword?: string) => Promise<void>;

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

@@ -0,0 +1,9 @@
+import { AuthEntity, UserEntity } from "cca-entities";
+import { IDecodedToken } from "./IDecodedToken";
+export interface IAuthService {
+    validateUser(email: string, password: string): Promise<AuthEntity | null>;
+    generateAccessToken(user: UserEntity): string;
+    generateRefreshToken(user: UserEntity): string;
+    verifyAccessToken(token: string): Promise<IDecodedToken>;
+    verifyRefreshToken(token: string): IDecodedToken;
+}

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

@@ -0,0 +1,9 @@
+import { BaseDatabase } from 'cca-core';
+import { IBaseCacheService } from 'cca-core';
+import { Mapper } from '@automapper/core';
+export interface IBaseContainerConfig {
+    database: BaseDatabase;
+    cacheService?: IBaseCacheService;
+    mapper?: Mapper;
+    jwtSecret: string;
+}

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

@@ -0,0 +1,5 @@
+export interface IConfigFinderOptions {
+    fileName?: string;
+    maxDepth?: number;
+    startPath?: string;
+}

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

@@ -0,0 +1,6 @@
+import { JwtPayload } from "jsonwebtoken";
+export interface IDecodedToken extends JwtPayload {
+    userId?: string;
+    email?: string;
+    role?: string;
+}

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

@@ -0,0 +1,9 @@
+import { AuthEntity, UserEntity } from "cca-entities";
+import { IDecodedToken } from "./IDecodedToken";
+export interface IJwtAuth {
+    validateUser(email: string, password: string): Promise<AuthEntity | null>;
+    generateAccessToken(user: UserEntity): string;
+    generateRefreshToken(user: UserEntity): string;
+    verifyAccessToken(token: string): Promise<IDecodedToken>;
+    verifyRefreshToken(token: string): IDecodedToken;
+}

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

@@ -0,0 +1,6 @@
+export interface IJwtConfig {
+    accessTokenSecret: string;
+    refreshTokenSecret: string;
+    accessTokenExpiry: string;
+    refreshTokenExpiry: string;
+}

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

@@ -0,0 +1,3 @@
+export interface IRefreshTokenRequest {
+    refreshToken: string;
+}

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

@@ -0,0 +1,4 @@
+export interface RegisterResponse {
+    status: number;
+    error?: string;
+}

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

@@ -0,0 +1,6 @@
+export type TokenEncoding = 'hex' | 'base64' | 'base64url';
+export interface ITokenConfig {
+    minLength: number;
+    defaultEncoding: TokenEncoding;
+    supportedEncodings: TokenEncoding[];
+}

package/dist/index.d.mts

@@ -0,0 +1,118 @@
+import { BaseRepository, IExtendedBaseRepository, IBaseService, BaseDatabase, BaseContainer } from 'cca-core';
+import { Request, Response, NextFunction } from 'express';
+import { AuthEntity, UserRole, UserEntity } from 'cca-entities';
+import { Repository } from 'typeorm';
+import { JwtPayload } from 'jsonwebtoken';
+
+declare class AuthRepository extends BaseRepository<AuthEntity> implements IExtendedBaseRepository<AuthEntity> {
+    constructor(repository: Repository<AuthEntity>);
+    findByEmail(email: string): Promise<AuthEntity | null>;
+    create(entity: Omit<AuthEntity, "createdAt">): Promise<AuthEntity>;
+}
+
+declare class RegisterUseCase implements IBaseService {
+    private readonly repository;
+    private readonly SALT_ROUNDS;
+    constructor(repository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(email: string, name: string, password: string, role?: UserRole): Promise<AuthEntity>;
+    private normalizeAuthDTO;
+    private hashPassword;
+    private createAuthEntity;
+}
+
+interface IJwtConfig {
+    accessTokenSecret: string;
+    refreshTokenSecret: string;
+    accessTokenExpiry: string;
+    refreshTokenExpiry: string;
+}
+
+interface IDecodedToken extends JwtPayload {
+    userId?: string;
+    email?: string;
+    role?: string;
+}
+
+interface IAuthService {
+    validateUser(email: string, password: string): Promise<AuthEntity | null>;
+    generateAccessToken(user: UserEntity): string;
+    generateRefreshToken(user: UserEntity): string;
+    verifyAccessToken(token: string): Promise<IDecodedToken>;
+    verifyRefreshToken(token: string): IDecodedToken;
+}
+
+declare class JwtAuthService implements IBaseService, IAuthService {
+    private readonly jwtConfig;
+    private readonly repository;
+    constructor(repository: AuthRepository, config?: IJwtConfig);
+    initialize(): Promise<void>;
+    private validateConfiguration;
+    validateUser(email: string, password: string): Promise<AuthEntity | null>;
+    generateAccessToken(user: UserEntity): string;
+    generateRefreshToken(user: UserEntity): string;
+    verifyAccessToken(token: string): Promise<IDecodedToken>;
+    verifyRefreshToken(token: string): Promise<IDecodedToken>;
+    private verifyToken;
+}
+
+declare class UserDTO {
+    id: string;
+    name: string;
+    email: string;
+    role: UserRole;
+    adminPassword?: string;
+}
+
+declare class LoginDTO {
+    email: string;
+    password: string;
+    adminPassword?: string;
+    role: UserRole;
+}
+
+declare class LoginUseCase implements IBaseService {
+    private readonly repository;
+    private readonly authService;
+    constructor(repository: AuthRepository, authService: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(loginDTO: LoginDTO, adminPassword?: string): Promise<{
+        token: {
+            accessToken: string;
+            refreshToken: string;
+        };
+        user: UserDTO;
+    }>;
+    private generateTokens;
+    private updateUserRefreshToken;
+}
+
+declare class RefreshTokenUseCase implements IBaseService {
+    private readonly repository;
+    private readonly service;
+    constructor(repository: AuthRepository, service: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    } | null>;
+    verityToken(token: string): Promise<IDecodedToken>;
+}
+
+declare class AuthController {
+    private loginUseCase;
+    private registerUseCase;
+    private refreshTokenUseCase;
+    constructor(loginUseCase: LoginUseCase, registerUseCase: RegisterUseCase, refreshTokenUseCase: RefreshTokenUseCase);
+    login: (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>;
+}
+
+declare function createAuthContainer(database: BaseDatabase): {
+    container: BaseContainer;
+    authController: AuthController;
+};
+
+export { createAuthContainer };

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+import { BaseRepository, IExtendedBaseRepository, IBaseService, BaseDatabase, BaseContainer } from 'cca-core';
+import { Request, Response, NextFunction } from 'express';
+import { AuthEntity, UserRole, UserEntity } from 'cca-entities';
+import { Repository } from 'typeorm';
+import { JwtPayload } from 'jsonwebtoken';
+
+declare class AuthRepository extends BaseRepository<AuthEntity> implements IExtendedBaseRepository<AuthEntity> {
+    constructor(repository: Repository<AuthEntity>);
+    findByEmail(email: string): Promise<AuthEntity | null>;
+    create(entity: Omit<AuthEntity, "createdAt">): Promise<AuthEntity>;
+}
+
+declare class RegisterUseCase implements IBaseService {
+    private readonly repository;
+    private readonly SALT_ROUNDS;
+    constructor(repository: AuthRepository);
+    initialize(): Promise<void>;
+    execute(email: string, name: string, password: string, role?: UserRole): Promise<AuthEntity>;
+    private normalizeAuthDTO;
+    private hashPassword;
+    private createAuthEntity;
+}
+
+interface IJwtConfig {
+    accessTokenSecret: string;
+    refreshTokenSecret: string;
+    accessTokenExpiry: string;
+    refreshTokenExpiry: string;
+}
+
+interface IDecodedToken extends JwtPayload {
+    userId?: string;
+    email?: string;
+    role?: string;
+}
+
+interface IAuthService {
+    validateUser(email: string, password: string): Promise<AuthEntity | null>;
+    generateAccessToken(user: UserEntity): string;
+    generateRefreshToken(user: UserEntity): string;
+    verifyAccessToken(token: string): Promise<IDecodedToken>;
+    verifyRefreshToken(token: string): IDecodedToken;
+}
+
+declare class JwtAuthService implements IBaseService, IAuthService {
+    private readonly jwtConfig;
+    private readonly repository;
+    constructor(repository: AuthRepository, config?: IJwtConfig);
+    initialize(): Promise<void>;
+    private validateConfiguration;
+    validateUser(email: string, password: string): Promise<AuthEntity | null>;
+    generateAccessToken(user: UserEntity): string;
+    generateRefreshToken(user: UserEntity): string;
+    verifyAccessToken(token: string): Promise<IDecodedToken>;
+    verifyRefreshToken(token: string): Promise<IDecodedToken>;
+    private verifyToken;
+}
+
+declare class UserDTO {
+    id: string;
+    name: string;
+    email: string;
+    role: UserRole;
+    adminPassword?: string;
+}
+
+declare class LoginDTO {
+    email: string;
+    password: string;
+    adminPassword?: string;
+    role: UserRole;
+}
+
+declare class LoginUseCase implements IBaseService {
+    private readonly repository;
+    private readonly authService;
+    constructor(repository: AuthRepository, authService: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(loginDTO: LoginDTO, adminPassword?: string): Promise<{
+        token: {
+            accessToken: string;
+            refreshToken: string;
+        };
+        user: UserDTO;
+    }>;
+    private generateTokens;
+    private updateUserRefreshToken;
+}
+
+declare class RefreshTokenUseCase implements IBaseService {
+    private readonly repository;
+    private readonly service;
+    constructor(repository: AuthRepository, service: JwtAuthService);
+    initialize(): Promise<void>;
+    execute(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    } | null>;
+    verityToken(token: string): Promise<IDecodedToken>;
+}
+
+declare class AuthController {
+    private loginUseCase;
+    private registerUseCase;
+    private refreshTokenUseCase;
+    constructor(loginUseCase: LoginUseCase, registerUseCase: RegisterUseCase, refreshTokenUseCase: RefreshTokenUseCase);
+    login: (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>;
+}
+
+declare function createAuthContainer(database: BaseDatabase): {
+    container: BaseContainer;
+    authController: AuthController;
+};
+
+export { createAuthContainer };