@flusys/nestjs-auth 1.0.0-beta → 1.0.0

package/cjs/validators/password.validator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IsStrongPassword", {
+    enumerable: true,
+    get: function() {
+        return IsStrongPassword;
+    }
+});
+const _classvalidator = require("class-validator");
+function IsStrongPassword(options = {}, validationOptions) {
+    const { minLength = 8, maxLength = 128, requireUppercase = true, requireLowercase = true, requireNumber = true, requireSpecialChar = true } = options;
+    return function(object, propertyName) {
+        (0, _classvalidator.registerDecorator)({
+            name: 'isStrongPassword',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate (value) {
+                    if (typeof value !== 'string') return false;
+                    const checks = [
+                        value.length >= minLength,
+                        value.length <= maxLength,
+                        !requireUppercase || /[A-Z]/.test(value),
+                        !requireLowercase || /[a-z]/.test(value),
+                        !requireNumber || /[0-9]/.test(value),
+                        !requireSpecialChar || /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/.test(value)
+                    ];
+                    return checks.every(Boolean);
+                },
+                defaultMessage (args) {
+                    const requirements = [];
+                    if (minLength > 0) requirements.push(`at least ${minLength} characters`);
+                    if (requireUppercase) requirements.push('one uppercase letter');
+                    if (requireLowercase) requirements.push('one lowercase letter');
+                    if (requireNumber) requirements.push('one number');
+                    if (requireSpecialChar) requirements.push('one special character (!@#$%^&*...)');
+                    return `Password must contain ${requirements.join(', ')}`;
+                }
+            }
+        });
+    };
+}

package/config/auth.constants.d.ts

@@ -1,4 +1,7 @@
 export declare const AUTH_MODULE_OPTIONS = "AUTH_MODULE_OPTIONS";
+export declare const USER_ENRICHER = "USER_ENRICHER";
 export declare const BCRYPT_SALT_ROUNDS = 12;
+export declare const DEFAULT_COOKIE_NAME = "fsn_refresh_token";
+export declare const MAX_COOKIE_BYTES = 3500;
 export declare const SESSION_CACHE_PREFIX = "auth:session";
 export declare const TOKEN_REVOKED_PREFIX = "auth:revoked";

package/controllers/authentication.controller.d.ts

@@ -1,22 +1,28 @@
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Request } from 'express';
-import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
 import { AuthConfigService } from '../services/auth-config.service';
+import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export declare class AuthenticationController {
     private readonly authService;
     private readonly authConfig?;
-    constructor(authService: AuthenticationService, authConfig?: AuthConfigService);
-    login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto>;
-    register(registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
+    private readonly authEmailService?;
+    constructor(authService: AuthenticationService, authConfig?: AuthConfigService, authEmailService?: AuthEmailService);
+    private buildAuthUrl;
+    private get emailService();
+    private get isEmailEnabled();
+    login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto | LoginResponseRequiresEmailVerificationDto>;
+    register(req: Request, registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
     refreshToken(req: Request, refreshTokenDto: RefreshTokenDto): Promise<{
         accessToken: string;
     }>;
     getCurrentUser(user: ILoggedUserInfo): Promise<MeResponseDto>;
-    logout(userId: string): Promise<{
-        message: string;
-    }>;
-    changePassword(userId: string, dto: ChangePasswordDto): Promise<{
-        message: string;
-    }>;
+    logout(userId: string): Promise<MessageResponseDto>;
+    changePassword(userId: string, dto: ChangePasswordDto): Promise<MessageResponseDto>;
+    forgotPassword(req: Request, dto: ForgotPasswordDto): Promise<MessageResponseDto>;
+    resetPassword(dto: ResetPasswordDto): Promise<MessageResponseDto>;
+    resendVerification(req: Request, dto: ResendVerificationDto): Promise<MessageResponseDto>;
+    verifyEmail(dto: VerifyEmailDto): Promise<MessageResponseDto | RegistrationResponseDto>;
 }

package/controllers/company-selection.controller.d.ts

@@ -6,9 +6,13 @@ export declare class CompanySelectionController {
     select(dto: SelectDto): Promise<LoginResponseDto>;
     switchCompany(userId: string, dto: SwitchCompanyDto): Promise<LoginResponseDto>;
     getUserCompanies(userId: string): Promise<{
-        companies: import("..").Company[];
+        success: boolean;
+        message: string;
+        data: import("..").Company[];
     }>;
     getUserBranches(userId: string, companyId: string): Promise<{
-        branches: import("..").CompanyBranch[];
+        success: boolean;
+        message: string;
+        data: import("..").CompanyBranch[];
     }>;
 }

package/controllers/user-permission.controller.d.ts

@@ -1,8 +1,8 @@
-import { AssignUserCompanyDto, AssignUserBranchDto, UserCompaniesResponseDto, UserBranchesResponseDto } from '../dtos/user-permission.dto';
+import { AssignUserBranchDto, AssignUserCompanyDto, UserBranchesResponseDto, UserCompaniesResponseDto } from '../dtos/user-permission.dto';
 import { UserPermissionService } from '../services/user-permission.service';
 export declare class UserPermissionController {
-    private readonly userPermissionService;
-    constructor(userPermissionService: UserPermissionService);
+    private readonly permissionService;
+    constructor(permissionService: UserPermissionService);
     assignUserCompany(dto: AssignUserCompanyDto): Promise<{
         success: boolean;
         message: string;
@@ -12,5 +12,6 @@ export declare class UserPermissionController {
         success: boolean;
         message: string;
     }>;
-    getUserBranches(userId: string): Promise<UserBranchesResponseDto>;
+    getUserBranches(userId: string, companyId?: string): Promise<UserBranchesResponseDto>;
+    private processBatchPermissions;
 }

package/controllers/user.controller.d.ts

@@ -1,5 +1,6 @@
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { CreateUserDto, UpdateUserDto, UserResponseDto } from '../dtos/user.dto';
+import { IUser } from '../interfaces/user.interface';
 import { UserService } from '../services/user.service';
 declare const UserController_base: abstract new (service: UserService) => {
     service: UserService;
@@ -14,18 +15,50 @@ declare const UserController_base: abstract new (service: UserService) => {
 export declare class UserController extends UserController_base {
     service: UserService;
     constructor(service: UserService);
+    getProfileWithExtras(id: string, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        data: {
+            user: IUser;
+            extras?: import("..").IProfileExtras;
+        };
+    }>;
     verifyEmail(id: string): Promise<{
+        success: boolean;
         message: string;
     }>;
     verifyPhone(id: string): Promise<{
+        success: boolean;
         message: string;
     }>;
     updateStatus(id: string, isActive: boolean, user: ILoggedUserInfo): Promise<{
+        success: boolean;
         message: string;
     }>;
     profile(dto: UpdateUserDto, user: ILoggedUserInfo): Promise<{
+        success: boolean;
         message: string;
         data: string;
     }>;
+    getProfileSections(): Promise<{
+        success: boolean;
+        message: string;
+        data: import("..").IProfileSection[];
+    }>;
+    getProfileSectionData(id: string, sectionId: string, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        message: string;
+        data: import("..").IProfileSectionData;
+    }>;
+    updateProfileSection(id: string, sectionId: string, data: Record<string, any>, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getProfileCompletion(id: string, user: ILoggedUserInfo): Promise<{
+        success: boolean;
+        message: string;
+        data: {
+            completionPercentage: number;
+        };
+    }>;
 }
 export {};

package/dtos/authentication.dto.d.ts

@@ -51,14 +51,12 @@ export declare class BranchSelectionInfoDto {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
 }
 export declare class CompanyWithBranchesDto {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
     branches: BranchSelectionInfoDto[];
 }
@@ -68,15 +66,14 @@ export declare class LoginResponseDto {
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled?: boolean;
 }
 export declare class RegistrationResponseDto {
-    accessToken: string;
-    refreshToken: string;
+    accessToken?: string;
+    refreshToken?: string;
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled: boolean;
+    requiresEmailVerification?: boolean;
 }
 export declare class MeResponseDto {
     user: UserInfoDto;
@@ -90,3 +87,20 @@ export declare class CompanySelectionResponseDto {
     user: UserInfoDto;
     companies: CompanyWithBranchesDto[];
 }
+export declare class LoginResponseRequiresEmailVerificationDto {
+    requiresEmailVerification: true;
+    email: string;
+    message: string;
+}
+export declare class ForgotPasswordDto {
+    email: string;
+}
+export declare class ResetPasswordDto {
+    token: string;
+    newPassword: string;
+}
+export declare class VerifyEmailDto {
+    token: string;
+}
+export declare class ResendVerificationDto extends ForgotPasswordDto {
+}

package/dtos/company-branch.dto.d.ts

@@ -1,5 +1,4 @@
 export declare class CreateCompanyBranchDto {
-    [key: string]: unknown;
     name: string;
     slug: string;
     companyId: string;

package/dtos/company.dto.d.ts

@@ -1,5 +1,4 @@
 export declare class CreateCompanyDto {
-    [key: string]: unknown;
     name: string;
     slug: string;
     logoId?: string;

package/dtos/index.d.ts

@@ -1,6 +1,5 @@
 export * from './authentication.dto';
 export * from './company-branch.dto';
 export * from './company.dto';
-export * from './user-company-permission.dto';
 export * from './user.dto';
 export * from './user-permission.dto';

package/dtos/user-permission.dto.d.ts

@@ -26,8 +26,12 @@ export declare class UserBranchPermissionDto {
     companyId: string;
 }
 export declare class UserCompaniesResponseDto {
+    success: boolean;
+    message: string;
     data: UserCompanyPermissionDto[];
 }
 export declare class UserBranchesResponseDto {
+    success: boolean;
+    message: string;
     data: UserBranchPermissionDto[];
 }

package/dtos/user.dto.d.ts

@@ -1,5 +1,4 @@
 export declare class CreateUserDto {
-    [key: string]: unknown;
     name: string;
     phone?: string;
     email: string;
@@ -16,6 +15,7 @@ export declare class UpdateUserDto {
     phone?: string;
     email?: string;
     password?: string;
+    oldPassword?: string;
     profilePictureId?: string;
     isActive?: boolean;
     emailVerified?: boolean;
@@ -23,7 +23,6 @@ export declare class UpdateUserDto {
     additionalFields?: Record<string, any>;
 }
 export declare class UserResponseDto {
-    [key: string]: unknown;
     id: string;
     name: string;
     phone?: string | null;

package/entities/index.d.ts

@@ -1,12 +1,16 @@
 export * from './company-branch.entity';
 export * from './company.entity';
+export * from './pending-registration.entity';
 export { PermissionType, UserCompanyPermission } from './user-company-permission.entity';
 export * from './user.entity';
+export * from './user-token.entity';
 import { CompanyBranch } from './company-branch.entity';
 import { Company } from './company.entity';
+import { PendingRegistration } from './pending-registration.entity';
 import { UserCompanyPermission } from './user-company-permission.entity';
 import { User } from './user.entity';
-export declare const CoreEntities: (typeof User)[];
+import { UserToken } from './user-token.entity';
+export declare const CoreEntities: (typeof PendingRegistration | typeof UserToken | typeof User)[];
 export declare const CompanyEntities: (typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
-export declare const AllEntities: (typeof Company | typeof CompanyBranch | typeof User | typeof UserCompanyPermission)[];
-export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof Company | typeof CompanyBranch | typeof User | typeof UserCompanyPermission)[];
+export declare const AllEntities: (typeof PendingRegistration | typeof UserToken | typeof User | typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
+export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof PendingRegistration | typeof UserToken | typeof User | typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];

package/entities/pending-registration.entity.d.ts

@@ -0,0 +1,17 @@
+export declare class PendingRegistration {
+    id: string;
+    email: string;
+    name: string | null;
+    phone: string | null;
+    passwordHash: string;
+    token: string;
+    expiresAt: Date;
+    companyData: {
+        companySlug?: string;
+        branchSlug?: string;
+        newCompanyName?: string;
+        newCompanyPhone?: string;
+        newCompanyAddress?: string;
+    } | null;
+    createdAt: Date;
+}

package/entities/user-company-permission.entity.d.ts

@@ -7,7 +7,7 @@ export declare class UserCompanyPermission {
     id: string;
     userId: string;
     user?: User;
-    permissionType: PermissionType;
+    permissionType: string;
     targetId: string;
     metadata?: Record<string, any>;
     isActive: boolean;
@@ -15,6 +15,4 @@ export declare class UserCompanyPermission {
     branch?: CompanyBranch;
     createdAt: Date;
     updatedAt: Date;
-    isCompanyPermission(): boolean;
-    isBranchPermission(): boolean;
 }

package/entities/user-token.entity.d.ts

@@ -0,0 +1,15 @@
+export declare enum TokenType {
+    PASSWORD_RESET = "password_reset",
+    EMAIL_VERIFICATION = "email_verification",
+    EMAIL_CHANGE = "email_change"
+}
+export declare class UserToken {
+    id: string;
+    userId: string;
+    type: TokenType;
+    token: string;
+    expiresAt: Date;
+    usedAt: Date | null;
+    metadata: string | null;
+    createdAt: Date;
+}

package/fesm/config/auth.constants.js

@@ -1,7 +1,11 @@
 // Injection Tokens
 export const AUTH_MODULE_OPTIONS = 'AUTH_MODULE_OPTIONS';
-// Security Configuration
-/** Bcrypt salt rounds (12 = ~250ms hashing time) */ export const BCRYPT_SALT_ROUNDS = 12;
+export const USER_ENRICHER = 'USER_ENRICHER';
+// Security
+export const BCRYPT_SALT_ROUNDS = 12;
+// Cookie
+export const DEFAULT_COOKIE_NAME = 'fsn_refresh_token';
+export const MAX_COOKIE_BYTES = 3500;
 // Cache Key Prefixes
 export const SESSION_CACHE_PREFIX = 'auth:session';
 export const TOKEN_REVOKED_PREFIX = 'auth:revoked';