@flusys/nestjs-auth 3.0.0 → 4.0.0-lts

package/fesm/services/branch.service.js

@@ -79,7 +79,7 @@ export class BranchService extends RequestScopedApiService {
         return result;
     }
     constructor(cacheManager, utilsService, dataSourceProvider, authConfig){
-        super('company_branch', null, cacheManager, utilsService, BranchService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "authConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig;
+        super('company_branch', null, cacheManager, utilsService, BranchService.name, true, 'auth'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "authConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig;
     }
 }
 BranchService = _ts_decorate([

package/fesm/services/company-selection-session.service.js

@@ -25,15 +25,14 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
+import { LogAction } from '@flusys/nestjs-shared';
 import { HybridCache } from '@flusys/nestjs-shared/classes';
 import { Inject, Injectable } from '@nestjs/common';
 import { randomUUID } from 'crypto';
 import { SESSION_CACHE_PREFIX } from '../config/auth.constants';
 const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 export class CompanySelectionSessionService {
-    /**
-   * Create a new session for company/branch selection
-   */ async createSession(userId) {
+    async createSession(userId) {
         const sessionId = randomUUID();
         const now = new Date();
         const expiresAt = new Date(now.getTime() + SESSION_TTL_MS);
@@ -58,9 +57,7 @@ export class CompanySelectionSessionService {
         }
         return session;
     }
-    /**
-   * Get and delete session (one-time use)
-   */ async consumeSession(sessionId) {
+    async consumeSession(sessionId) {
         const session = await this.getSession(sessionId);
         if (session) {
             await this.deleteSession(sessionId);
@@ -82,6 +79,28 @@ export class CompanySelectionSessionService {
         this.cacheManager = cacheManager;
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'session.create',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], CompanySelectionSessionService.prototype, "createSession", null);
+_ts_decorate([
+    LogAction({
+        action: 'session.consume',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], CompanySelectionSessionService.prototype, "consumeSession", null);
 CompanySelectionSessionService = _ts_decorate([
     Injectable(),
     _ts_param(0, Inject('CACHE_INSTANCE')),

package/fesm/services/company.service.js

@@ -64,7 +64,7 @@ export class CompanyService extends RequestScopedApiService {
         };
     }
     constructor(cacheManager, utilsService, dataSourceProvider){
-        super('company', null, cacheManager, utilsService, CompanyService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
+        super('company', null, cacheManager, utilsService, CompanyService.name, true, 'auth'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
     }
 }
 CompanyService = _ts_decorate([

package/fesm/services/user-permission.service.js

@@ -25,7 +25,9 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
+import { LogAction } from '@flusys/nestjs-shared';
 import { ConflictException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { USER_PERMISSION_MESSAGES } from '../config';
 import { PermissionType, UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 export class UserPermissionService {
@@ -62,7 +64,13 @@ export class UserPermissionService {
             }
         });
         if (existing) {
-            throw new ConflictException(`User already assigned to this ${typeName}`);
+            throw new ConflictException({
+                message: `User already assigned to this ${typeName}`,
+                messageKey: USER_PERMISSION_MESSAGES.ALREADY_ASSIGNED,
+                messageParams: {
+                    type: typeName
+                }
+            });
         }
         try {
             await repository.save(repository.create({
@@ -72,8 +80,15 @@ export class UserPermissionService {
                 metadata
             }));
         } catch (error) {
-            if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
-                throw new ConflictException(`User already assigned to this ${typeName}. Please refresh and try again.`);
+            const err = error;
+            if (err?.code === 'ER_DUP_ENTRY' || String(err?.message).includes('Duplicate entry')) {
+                throw new ConflictException({
+                    message: `User already assigned to this ${typeName}. Please refresh and try again.`,
+                    messageKey: USER_PERMISSION_MESSAGES.ALREADY_ASSIGNED,
+                    messageParams: {
+                        type: typeName
+                    }
+                });
             }
             throw error;
         }
@@ -89,7 +104,13 @@ export class UserPermissionService {
             }
         });
         if (!permission) {
-            throw new NotFoundException(`${typeName.charAt(0).toUpperCase() + typeName.slice(1)} permission not found`);
+            throw new NotFoundException({
+                message: `${typeName.charAt(0).toUpperCase() + typeName.slice(1)} permission not found`,
+                messageKey: USER_PERMISSION_MESSAGES.PERMISSION_NOT_FOUND,
+                messageParams: {
+                    type: typeName.charAt(0).toUpperCase() + typeName.slice(1)
+                }
+            });
         }
         await repository.remove(permission);
     }
@@ -117,6 +138,33 @@ export class UserPermissionService {
         this.findUserCompanies = (userId)=>this.findUserPermissions(userId, PermissionType.COMPANY);
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'user.assignPermission',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof PermissionType === "undefined" ? Object : PermissionType,
+        typeof Record === "undefined" ? Object : Record
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserPermissionService.prototype, "assignPermission", null);
+_ts_decorate([
+    LogAction({
+        action: 'user.revokePermission',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof PermissionType === "undefined" ? Object : PermissionType
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserPermissionService.prototype, "revokePermission", null);
 UserPermissionService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST

package/fesm/services/user.service.js

@@ -26,13 +26,17 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { LogAction } from '@flusys/nestjs-shared';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { ErrorHandler } from '@flusys/nestjs-shared/utils';
 import { BadRequestException, ForbiddenException, Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
+import { AUTH_MESSAGES, USER_MESSAGES, USER_PERMISSION_MESSAGES } from '../config';
 import * as bcrypt from 'bcrypt';
 import { AuthConfigService } from './auth-config.service';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 import { BCRYPT_SALT_ROUNDS, USER_ENRICHER } from '../config';
+import { CreateUserDto } from '../dtos/user.dto';
 import { PermissionType } from '../enums';
 import { IUserEnricher } from '../interfaces/user-enricher.interface';
 import { UserCompanyPermission } from '../entities/user-company-permission.entity';
@@ -58,7 +62,10 @@ export class UserService extends RequestScopedApiService {
     }
     async getUserForProfile(userId, user) {
         if (userId !== user.id) {
-            throw new ForbiddenException('Cannot access another user\'s profile');
+            throw new ForbiddenException({
+                message: 'Cannot access another user\'s profile',
+                messageKey: AUTH_MESSAGES.PROFILE_ACCESS_DENIED
+            });
         }
         await this.ensureRepositoryInitialized();
         const userEntity = await this.repository.findOne({
@@ -67,7 +74,10 @@ export class UserService extends RequestScopedApiService {
             }
         });
         if (!userEntity) {
-            throw new NotFoundException('User not found');
+            throw new NotFoundException({
+                message: 'User not found',
+                messageKey: USER_MESSAGES.NOT_FOUND
+            });
         }
         return userEntity;
     }
@@ -105,7 +115,10 @@ export class UserService extends RequestScopedApiService {
                 }
             });
             if (!permission) {
-                throw new NotFoundException('User company permission not found');
+                throw new NotFoundException({
+                    message: 'User company permission not found',
+                    messageKey: USER_PERMISSION_MESSAGES.PERMISSION_NOT_FOUND
+                });
             }
             permission.isActive = isActive;
             await this.permissionRepository.save(permission);
@@ -235,7 +248,7 @@ export class UserService extends RequestScopedApiService {
     async insert(dto, user) {
         const isCompanyFeatureEnabled = this.authConfig.isCompanyFeatureEnabled();
         if (!isCompanyFeatureEnabled || !this.dataSource || !user?.companyId || !this.permissionRepository) {
-            return super.insert(dto, user);
+            return await super.insert(dto, user);
         }
         const queryRunner = this.dataSource.createQueryRunner();
         await queryRunner.connect();
@@ -284,10 +297,7 @@ export class UserService extends RequestScopedApiService {
             return this.convertEntityToResponseDto(savedUser, false);
         } catch (error) {
             await queryRunner.rollbackTransaction();
-            ErrorHandler.logError(this.logger, error, 'insert', {
-                entity: this.entityName
-            });
-            ErrorHandler.rethrowError(error);
+            throw error;
         } finally{
             await queryRunner.release();
         }
@@ -334,10 +344,16 @@ export class UserService extends RequestScopedApiService {
     async updateProfileSection(userId, sectionId, data, user) {
         const userEntity = await this.getUserForProfile(userId, user);
         if (!this.dataSource) {
-            throw new BadRequestException('DataSource not available');
+            throw new BadRequestException({
+                message: 'DataSource not available',
+                messageKey: SYSTEM_MESSAGES.DATASOURCE_NOT_AVAILABLE
+            });
         }
         if (!this.userEnricher?.updateProfileSection) {
-            throw new BadRequestException('Profile sections not supported');
+            throw new BadRequestException({
+                message: 'Profile sections not supported',
+                messageKey: AUTH_MESSAGES.PROFILE_SECTIONS_NOT_SUPPORTED
+            });
         }
         const queryRunner = this.dataSource.createQueryRunner();
         await queryRunner.connect();
@@ -350,11 +366,7 @@ export class UserService extends RequestScopedApiService {
             ]);
         } catch (error) {
             await queryRunner.rollbackTransaction();
-            ErrorHandler.logError(this.logger, error, 'updateProfileSection', {
-                entity: this.entityName,
-                sectionId
-            });
-            ErrorHandler.rethrowError(error);
+            throw error;
         } finally{
             await queryRunner.release();
         }
@@ -369,7 +381,10 @@ export class UserService extends RequestScopedApiService {
     async profile(dto, user) {
         await this.ensureRepositoryInitialized();
         if (!this.dataSource) {
-            throw new BadRequestException('DataSource not available');
+            throw new BadRequestException({
+                message: 'DataSource not available',
+                messageKey: SYSTEM_MESSAGES.DATASOURCE_NOT_AVAILABLE
+            });
         }
         const userId = dto.id ?? user.id;
         if (dto.extras && this.userEnricher?.validateProfileExtras) {
@@ -385,17 +400,26 @@ export class UserService extends RequestScopedApiService {
                 }
             });
             if (!findUser) {
-                throw new NotFoundException('User not found');
+                throw new NotFoundException({
+                    message: 'User not found',
+                    messageKey: USER_MESSAGES.NOT_FOUND
+                });
             }
             if (dto.password) {
                 const isOwnProfile = !dto.id || dto.id === user.id;
                 if (isOwnProfile) {
                     if (!dto.oldPassword) {
-                        throw new BadRequestException('Current password is required to change your password');
+                        throw new BadRequestException({
+                            message: 'Current password is required to change your password',
+                            messageKey: AUTH_MESSAGES.PASSWORD_CHANGE_CURRENT_REQUIRED
+                        });
                     }
                     const isPasswordValid = await bcrypt.compare(dto.oldPassword, findUser.password);
                     if (!isPasswordValid) {
-                        throw new BadRequestException('Current password is incorrect');
+                        throw new BadRequestException({
+                            message: 'Current password is incorrect',
+                            messageKey: AUTH_MESSAGES.PASSWORD_CHANGE_INVALID_CURRENT
+                        });
                     }
                 }
                 findUser.password = await bcrypt.hash(dto.password, BCRYPT_SALT_ROUNDS);
@@ -413,18 +437,91 @@ export class UserService extends RequestScopedApiService {
             return findUser.id;
         } catch (error) {
             await queryRunner.rollbackTransaction();
-            ErrorHandler.logError(this.logger, error, 'profile', {
-                entity: this.entityName
-            });
-            ErrorHandler.rethrowError(error);
+            throw error;
         } finally{
             await queryRunner.release();
         }
     }
     constructor(cacheManager, utilsService, dataSourceProvider, authConfig, userEnricher){
-        super('user', null, cacheManager, utilsService, UserService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "authConfig", void 0), _define_property(this, "userEnricher", void 0), _define_property(this, "permissionRepository", void 0), _define_property(this, "dataSource", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig, this.userEnricher = userEnricher;
+        super('user', null, cacheManager, utilsService, UserService.name, true, 'auth'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "authConfig", void 0), _define_property(this, "userEnricher", void 0), _define_property(this, "permissionRepository", void 0), _define_property(this, "dataSource", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.authConfig = authConfig, this.userEnricher = userEnricher;
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'user.verifyEmail',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserService.prototype, "verifyEmail", null);
+_ts_decorate([
+    LogAction({
+        action: 'user.verifyPhone',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserService.prototype, "verifyPhone", null);
+_ts_decorate([
+    LogAction({
+        action: 'user.updateStatus',
+        module: 'auth'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        Boolean,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserService.prototype, "updateStatus", null);
+_ts_decorate([
+    LogAction({
+        action: 'user.create',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CreateUserDto === "undefined" ? Object : CreateUserDto,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserService.prototype, "insert", null);
+_ts_decorate([
+    LogAction({
+        action: 'user.updateProfileSection',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof Record === "undefined" ? Object : Record,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserService.prototype, "updateProfileSection", null);
+_ts_decorate([
+    LogAction({
+        action: 'user.updateProfile',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UserService.prototype, "profile", null);
 UserService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST

package/fesm/strategies/jwt.strategy.js

@@ -20,7 +20,9 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
+import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
 import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { AUTH_MESSAGES, USER_MESSAGES } from '../config';
 import { ModuleRef } from '@nestjs/core';
 import { PassportStrategy } from '@nestjs/passport';
 import { ExtractJwt, Strategy } from 'passport-jwt';
@@ -42,7 +44,10 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
             }
         });
         if (!user) {
-            throw new UnauthorizedException('User not found or inactive');
+            throw new UnauthorizedException({
+                message: 'User not found or inactive',
+                messageKey: USER_MESSAGES.NOT_FOUND
+            });
         }
         return this.buildUserInfo(payload);
     }
@@ -55,9 +60,15 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
                 return provider.getRepository(User);
             }
         } catch  {
-            throw new UnauthorizedException('Unable to access user data');
+            throw new UnauthorizedException({
+                message: 'Unable to access user data',
+                messageKey: SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE
+            });
         }
-        throw new UnauthorizedException('User repository not available');
+        throw new UnauthorizedException({
+            message: 'User repository not available',
+            messageKey: SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE
+        });
     }
     async checkTokenRevocation(payload) {
         if (!payload.iat) return;
@@ -66,7 +77,10 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
                 strict: false
             });
             if (authService && await authService.isTokenRevoked(payload.id, payload.iat)) {
-                throw new UnauthorizedException('Token has been revoked');
+                throw new UnauthorizedException({
+                    message: 'Token has been revoked',
+                    messageKey: AUTH_MESSAGES.TOKEN_REVOKED
+                });
             }
         } catch (err) {
             if (err instanceof UnauthorizedException) throw err;

package/interfaces/auth-module-options.interface.d.ts

@@ -19,8 +19,8 @@ export interface AuthOptionsFactory extends IModuleOptionsFactory<IAuthModuleCon
 }
 export interface AuthModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
     bootstrapAppConfig: IBootstrapAppConfig;
-    useFactory?: (...args: any[]) => Promise<IAuthModuleConfig> | IAuthModuleConfig;
-    inject?: any[];
+    useFactory?: (...args: unknown[]) => Promise<IAuthModuleConfig> | IAuthModuleConfig;
+    inject?: unknown[];
     useClass?: Type<AuthOptionsFactory>;
     useExisting?: Type<AuthOptionsFactory>;
     providers?: Provider[];

package/interfaces/authentication.interface.d.ts

@@ -60,4 +60,5 @@ export interface LoginResponseRequiresEmailVerification {
     requiresEmailVerification: true;
     email: string;
     message: string;
+    messageKey: string;
 }

package/modules/auth.module.d.ts

@@ -1,5 +1,6 @@
 import { IBootstrapAppConfig } from '@flusys/nestjs-core';
 import { DynamicModule } from '@nestjs/common';
+import { getEntitiesByConfig } from '../entities';
 import { AuthModuleAsyncOptions, AuthModuleOptions } from '../interfaces/auth-module-options.interface';
 export declare class AuthModule {
     static forRoot(options: AuthModuleOptions): DynamicModule;
@@ -11,5 +12,5 @@ export declare class AuthModule {
     private static buildProviders;
     private static buildExports;
     private static createAsyncProviders;
-    static getEntities(config: IBootstrapAppConfig): any[];
+    static getEntities(config: IBootstrapAppConfig): ReturnType<typeof getEntitiesByConfig>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-auth",
-  "version": "3.0.0",
+  "version": "4.0.0-lts",
   "description": "Authentication and authorization infrastructure for NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -88,10 +88,12 @@
     "passport": "^0.7.0",
     "passport-jwt": "^4.0.0",
     "passport-local": "^1.0.0",
-    "typeorm": "^0.3.0"
+    "typeorm": "^0.3.0",
+    "express": "^4.18.0",
+    "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "3.0.0",
-    "@flusys/nestjs-shared": "3.0.0"
+    "@flusys/nestjs-core": "4.0.0-lts",
+    "@flusys/nestjs-shared": "4.0.0-lts"
   }
 }

package/services/auth-config.service.d.ts

@@ -2,10 +2,8 @@ import { DatabaseMode } from '@flusys/nestjs-core';
 import { IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
 export declare class AuthConfigService implements IModuleConfigService {
-    private readonly logger;
     private readonly options;
     private readonly config;
-    private refreshTokenSecretWarned;
     constructor(injectedOptions?: AuthModuleOptions);
     getDatabaseMode(): DatabaseMode;
     isMultiTenant(): boolean;

package/services/auth-datasource.provider.d.ts

@@ -1,12 +1,10 @@
-import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared';
 import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
-import { Logger } from '@nestjs/common';
 import { Request } from 'express';
 import { DataSource } from 'typeorm';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
 export declare class AuthDataSourceProvider extends MultiTenantDataSourceService {
     private readonly authOptions;
-    protected readonly logger: Logger;
     protected static readonly tenantConnections: Map<string, DataSource>;
     protected static singleDataSource: DataSource | null;
     protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;

package/services/auth-email.service.d.ts

@@ -4,7 +4,6 @@ import { AuthDataSourceProvider } from './auth-datasource.provider';
 export declare class AuthEmailService {
     private readonly dataSourceProvider?;
     private readonly emailProvider?;
-    private readonly logger;
     private readonly PASSWORD_RESET_EXPIRY;
     private readonly EMAIL_VERIFICATION_EXPIRY;
     constructor(dataSourceProvider?: AuthDataSourceProvider, emailProvider?: IAuthEmailProvider);
@@ -12,7 +11,6 @@ export declare class AuthEmailService {
     private getRepository;
     private generateToken;
     private hashToken;
-    private getErrorMessage;
     private assertEmailEnabled;
     private sendVerificationEmailSafe;
     private validateTokenNotExpiredOrUsed;
@@ -23,19 +21,22 @@ export declare class AuthEmailService {
         phone?: string;
         password: string;
         companyData?: PendingRegistration['companyData'];
-        additionalFields?: Record<string, any>;
+        additionalFields?: Record<string, unknown>;
         verifyUrlBase: string;
     }): Promise<{
         success: boolean;
         message: string;
+        messageKey: string;
     }>;
     forgotPassword(email: string, resetUrlBase: string): Promise<{
         success: boolean;
         message: string;
+        messageKey: string;
     }>;
     resetPassword(token: string, newPassword: string): Promise<{
         success: boolean;
         message: string;
+        messageKey: string;
     }>;
     verifyEmail(token: string): Promise<{
         type: 'pending';
@@ -43,10 +44,12 @@ export declare class AuthEmailService {
     } | {
         type: 'verified';
         message: string;
+        messageKey: string;
     }>;
     resendVerificationEmail(email: string, verifyUrlBase: string): Promise<{
         success: boolean;
         message: string;
+        messageKey: string;
     }>;
     cleanupExpired(): Promise<{
         deletedTokens: number;

package/services/authentication.service.d.ts

@@ -1,4 +1,5 @@
 import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { INotificationAdapter } from '@flusys/nestjs-shared/interfaces';
 import { JwtService } from '@nestjs/jwt';
 import { IUserEnricher } from '../interfaces/user-enricher.interface';
 import { RegistrationDto } from '../dtos/authentication.dto';
@@ -18,8 +19,8 @@ export declare class AuthenticationService {
     private readonly sessionService?;
     private readonly authEmailService?;
     private readonly userEnricher?;
-    private readonly logger;
-    constructor(jwtService: JwtService, authConfig: AuthConfigService, cacheManager?: HybridCache, dataSourceProvider?: AuthDataSourceProvider, sessionService?: CompanySelectionSessionService, authEmailService?: AuthEmailService, userEnricher?: IUserEnricher);
+    private readonly notificationAdapter?;
+    constructor(jwtService: JwtService, authConfig: AuthConfigService, cacheManager?: HybridCache, dataSourceProvider?: AuthDataSourceProvider, sessionService?: CompanySelectionSessionService, authEmailService?: AuthEmailService, userEnricher?: IUserEnricher, notificationAdapter?: INotificationAdapter);
     private isCompanyFeatureEnabled;
     private isEmailVerificationEnabled;
     private getUserRepository;
@@ -31,6 +32,7 @@ export declare class AuthenticationService {
     register(dto: RegistrationDto, verifyUrlBase?: string): Promise<RegistrationResponse | {
         requiresEmailVerification: true;
         message: string;
+        messageKey: string;
     }>;
     private handleExistingUserCompanyRegistration;
     private createUserDirectly;
@@ -62,6 +64,7 @@ export declare class AuthenticationService {
     private generateTokens;
     private generateLoginResponse;
     private generateLoginResponseWithCompany;
+    private sendLoginNotification;
     private generateCompanySelectionResponse;
     private generateRegistrationResponse;
     private generateRegistrationResponseWithCompany;

package/services/branch.service.d.ts

@@ -1,4 +1,5 @@
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
@@ -23,7 +24,7 @@ export declare class BranchService extends RequestScopedApiService<CreateCompany
         query: SelectQueryBuilder<CompanyBranch>;
         isRaw: boolean;
     }>;
-    protected getExtraManipulateQuery(query: SelectQueryBuilder<CompanyBranch>, filterDto: any, user: ILoggedUserInfo | null): Promise<{
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<CompanyBranch>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<CompanyBranch>;
         isRaw: boolean;
     }>;