@flusys/nestjs-auth 7.1.0 → 8.0.0

package/cjs/strategies/jwt.strategy.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "JwtStrategy", {
-    enumerable: true,
-    get: function() {
-        return JwtStrategy;
-    }
-});
-const _constants = require("@flusys/nestjs-shared/constants");
-const _common = require("@nestjs/common");
-const _core = require("@nestjs/core");
-const _passport = require("@nestjs/passport");
-const _passportjwt = require("passport-jwt");
-const _config = require("../config");
-const _appuserentity = require("../entities/app-user.entity");
-const _authconfigservice = require("../services/auth-config.service");
-const _authdatasourceprovider = require("../services/auth-datasource.provider");
-const _authenticationservice = require("../services/authentication.service");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function hasCompanyContext(payload) {
-    return 'companyId' in payload && payload.companyId != null;
-}
-let JwtStrategy = class JwtStrategy extends (0, _passport.PassportStrategy)(_passportjwt.Strategy, 'jwt') {
-    async validate(_req, payload) {
-        const userRepo = await this.resolveUserRepository();
-        await this.checkTokenRevocation(payload);
-        const user = await userRepo.findOne({
-            where: {
-                id: payload.id,
-                isActive: true
-            }
-        });
-        if (!user) {
-            throw new _common.UnauthorizedException({
-                message: 'User not found or inactive',
-                messageKey: _config.USER_MESSAGES.NOT_FOUND
-            });
-        }
-        return this.buildUserInfo(payload);
-    }
-    async resolveUserRepository() {
-        try {
-            const provider = await this.moduleRef.resolve(_authdatasourceprovider.AuthDataSourceProvider, undefined, {
-                strict: false
-            });
-            if (provider) {
-                return provider.getRepository(_appuserentity.AppUser);
-            }
-        } catch  {
-            throw new _common.UnauthorizedException({
-                message: 'Unable to access user data',
-                messageKey: _constants.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
-                messageVariables: {
-                    provider: 'DataSourceProvider',
-                    available: ''
-                }
-            });
-        }
-        throw new _common.UnauthorizedException({
-            message: 'User repository not available',
-            messageKey: _constants.SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE,
-            messageVariables: {
-                entity: 'User'
-            }
-        });
-    }
-    async checkTokenRevocation(payload) {
-        if (!payload.iat) return;
-        try {
-            const authService = await this.moduleRef.resolve(_authenticationservice.AuthenticationService, undefined, {
-                strict: false
-            });
-            if (authService && await authService.isTokenRevoked(payload.id, payload.iat)) {
-                throw new _common.UnauthorizedException({
-                    message: 'Token has been revoked',
-                    messageKey: _config.AUTH_MESSAGES.TOKEN_REVOKED
-                });
-            }
-        } catch (err) {
-            if (err instanceof _common.UnauthorizedException) throw err;
-        }
-    }
-    buildUserInfo(payload) {
-        const base = {
-            id: payload.id,
-            email: payload.email
-        };
-        if (!hasCompanyContext(payload)) {
-            return base;
-        }
-        return {
-            ...base,
-            companyId: payload.companyId,
-            ...payload.branchId && {
-                branchId: payload.branchId
-            }
-        };
-    }
-    constructor(authConfig, moduleRef){
-        super({
-            jwtFromRequest: _passportjwt.ExtractJwt.fromAuthHeaderAsBearerToken(),
-            ignoreExpiration: false,
-            secretOrKeyProvider: (_req, _token, done)=>{
-                done(null, this.authConfig.getJwtSecret());
-            },
-            passReqToCallback: true
-        }), _define_property(this, "authConfig", void 0), _define_property(this, "moduleRef", void 0), this.authConfig = authConfig, this.moduleRef = moduleRef;
-    }
-};
-JwtStrategy = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authconfigservice.AuthConfigService === "undefined" ? Object : _authconfigservice.AuthConfigService,
-        typeof _core.ModuleRef === "undefined" ? Object : _core.ModuleRef
-    ])
-], JwtStrategy);

package/cjs/strategies/jwt.strategy.spec.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _repositorymock = require("@test-utils/mocks/repository.mock");
-const _jwtstrategy = require("./jwt.strategy");
-const _authdatasourceprovider = require("../services/auth-datasource.provider");
-const _authenticationservice = require("../services/authentication.service");
-describe('JwtStrategy', ()=>{
-    let strategy;
-    let userRepo;
-    let mockAuthConfig;
-    let mockModuleRef;
-    let mockDataSourceProvider;
-    let mockAuthService;
-    beforeEach(()=>{
-        userRepo = (0, _repositorymock.createMockRepository)();
-        mockAuthConfig = {
-            getJwtSecret: jest.fn().mockReturnValue('jwt-secret')
-        };
-        mockDataSourceProvider = {
-            getRepository: jest.fn().mockResolvedValue(userRepo)
-        };
-        mockAuthService = {
-            isTokenRevoked: jest.fn().mockResolvedValue(false)
-        };
-        mockModuleRef = {
-            resolve: jest.fn().mockImplementation(async (token)=>{
-                if (token === _authdatasourceprovider.AuthDataSourceProvider) return mockDataSourceProvider;
-                if (token === _authenticationservice.AuthenticationService) return mockAuthService;
-                return null;
-            })
-        };
-        strategy = new _jwtstrategy.JwtStrategy(mockAuthConfig, mockModuleRef);
-    });
-    describe('validate', ()=>{
-        const req = {};
-        it('returns basic user info for a payload without company context', async ()=>{
-            userRepo.findOne.mockResolvedValue({
-                id: 'user-1',
-                isActive: true
-            });
-            const result = await strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access'
-            });
-            expect(result).toEqual({
-                id: 'user-1',
-                email: 'user@example.com'
-            });
-        });
-        it('includes companyId and branchId when present in the payload', async ()=>{
-            userRepo.findOne.mockResolvedValue({
-                id: 'user-1',
-                isActive: true
-            });
-            const result = await strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access',
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            });
-            expect(result).toEqual({
-                id: 'user-1',
-                email: 'user@example.com',
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            });
-        });
-        it('omits branchId when only companyId is present', async ()=>{
-            userRepo.findOne.mockResolvedValue({
-                id: 'user-1',
-                isActive: true
-            });
-            const result = await strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access',
-                companyId: 'company-1'
-            });
-            expect(result).toEqual({
-                id: 'user-1',
-                email: 'user@example.com',
-                companyId: 'company-1'
-            });
-        });
-        it('throws UnauthorizedException when the user is not found or inactive', async ()=>{
-            userRepo.findOne.mockResolvedValue(null);
-            await expect(strategy.validate(req, {
-                id: 'missing-user',
-                email: 'x@example.com',
-                type: 'access'
-            })).rejects.toThrow(_common.UnauthorizedException);
-        });
-        it('throws UnauthorizedException when the token has been revoked', async ()=>{
-            userRepo.findOne.mockResolvedValue({
-                id: 'user-1',
-                isActive: true
-            });
-            mockAuthService.isTokenRevoked.mockResolvedValue(true);
-            await expect(strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access',
-                iat: 1000
-            })).rejects.toThrow(_common.UnauthorizedException);
-        });
-        it('skips revocation check when the payload has no iat', async ()=>{
-            userRepo.findOne.mockResolvedValue({
-                id: 'user-1',
-                isActive: true
-            });
-            await strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access'
-            });
-            expect(mockAuthService.isTokenRevoked).not.toHaveBeenCalled();
-        });
-        it('throws UnauthorizedException when the data source provider cannot be resolved', async ()=>{
-            mockModuleRef.resolve.mockImplementation(async (token)=>{
-                if (token === _authdatasourceprovider.AuthDataSourceProvider) return null;
-                return mockAuthService;
-            });
-            await expect(strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access'
-            })).rejects.toThrow(_common.UnauthorizedException);
-        });
-        it('propagates an UnauthorizedException raised while resolving the data source provider', async ()=>{
-            mockModuleRef.resolve.mockImplementation(async (token)=>{
-                if (token === _authdatasourceprovider.AuthDataSourceProvider) throw new Error('resolution failed');
-                return mockAuthService;
-            });
-            await expect(strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access'
-            })).rejects.toThrow(_common.UnauthorizedException);
-        });
-        it('does not fail validation when the authentication service cannot be resolved for revocation checks', async ()=>{
-            userRepo.findOne.mockResolvedValue({
-                id: 'user-1',
-                isActive: true
-            });
-            mockModuleRef.resolve.mockImplementation(async (token)=>{
-                if (token === _authdatasourceprovider.AuthDataSourceProvider) return mockDataSourceProvider;
-                return null;
-            });
-            const result = await strategy.validate(req, {
-                id: 'user-1',
-                email: 'user@example.com',
-                type: 'access',
-                iat: 1000
-            });
-            expect(result).toEqual({
-                id: 'user-1',
-                email: 'user@example.com'
-            });
-        });
-    });
-});

package/cjs/validators/password.validator.js

@@ -1,45 +0,0 @@
-"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/cjs/validators/password.validator.spec.js

@@ -1,161 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _classvalidator = require("class-validator");
-const _passwordvalidator = require("./password.validator");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-let DefaultPasswordDto = class DefaultPasswordDto {
-    constructor(){
-        _define_property(this, "password", void 0);
-    }
-};
-_ts_decorate([
-    (0, _passwordvalidator.IsStrongPassword)(),
-    _ts_metadata("design:type", String)
-], DefaultPasswordDto.prototype, "password", void 0);
-let CustomPasswordDto = class CustomPasswordDto {
-    constructor(){
-        _define_property(this, "password", void 0);
-    }
-};
-_ts_decorate([
-    (0, _passwordvalidator.IsStrongPassword)({
-        minLength: 12,
-        requireSpecialChar: false
-    }),
-    _ts_metadata("design:type", String)
-], CustomPasswordDto.prototype, "password", void 0);
-let NoComplexityPasswordDto = class NoComplexityPasswordDto {
-    constructor(){
-        _define_property(this, "password", void 0);
-    }
-};
-_ts_decorate([
-    (0, _passwordvalidator.IsStrongPassword)({
-        requireUppercase: false,
-        requireLowercase: false,
-        requireNumber: false,
-        requireSpecialChar: false,
-        minLength: 4
-    }),
-    _ts_metadata("design:type", String)
-], NoComplexityPasswordDto.prototype, "password", void 0);
-async function validatePassword(dto) {
-    const errors = await (0, _classvalidator.validate)(dto);
-    return errors.length === 0;
-}
-describe('IsStrongPassword', ()=>{
-    describe('default options', ()=>{
-        it('accepts a password meeting all default complexity rules', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'StrongP@ss1';
-            expect(await validatePassword(dto)).toBe(true);
-        });
-        it('rejects a password shorter than the minimum length', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'Sh0rt!';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('accepts a password at exactly the minimum length boundary', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'Ab1!Ab1!'; // 8 chars
-            expect(await validatePassword(dto)).toBe(true);
-        });
-        it('rejects a password longer than the maximum length', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'A1!' + 'a'.repeat(127); // 130 chars total
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('accepts a password at exactly the maximum length boundary', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'A1!' + 'a'.repeat(125); // 128 chars total
-            expect(await validatePassword(dto)).toBe(true);
-        });
-        it('rejects a password missing an uppercase letter', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'lowercase1!';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('rejects a password missing a lowercase letter', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'UPPERCASE1!';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('rejects a password missing a number', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'NoNumbers!';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('rejects a password missing a special character', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'NoSpecial1';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('rejects a non-string value', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 12345678;
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('rejects an empty string', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = '';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('produces a descriptive default error message', async ()=>{
-            const dto = new DefaultPasswordDto();
-            dto.password = 'bad';
-            const errors = await (0, _classvalidator.validate)(dto);
-            expect(errors).toHaveLength(1);
-            const message = Object.values(errors[0].constraints ?? {})[0];
-            expect(message).toContain('at least 8 characters');
-            expect(message).toContain('one uppercase letter');
-            expect(message).toContain('one lowercase letter');
-            expect(message).toContain('one number');
-            expect(message).toContain('one special character');
-        });
-    });
-    describe('custom options', ()=>{
-        it('enforces a custom minimum length', async ()=>{
-            const dto = new CustomPasswordDto();
-            dto.password = 'Short1Aa';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-        it('accepts a password without special chars when requireSpecialChar is false', async ()=>{
-            const dto = new CustomPasswordDto();
-            dto.password = 'LongEnoughPassword1';
-            expect(await validatePassword(dto)).toBe(true);
-        });
-        it('allows fully relaxed complexity requirements', async ()=>{
-            const dto = new NoComplexityPasswordDto();
-            dto.password = 'abcd';
-            expect(await validatePassword(dto)).toBe(true);
-        });
-        it('still enforces minLength when complexity checks are disabled', async ()=>{
-            const dto = new NoComplexityPasswordDto();
-            dto.password = 'abc';
-            expect(await validatePassword(dto)).toBe(false);
-        });
-    });
-});

package/fesm/config/auth.constants.js

@@ -1,14 +0,0 @@
-// Injection Tokens
-export const AUTH_MODULE_OPTIONS = 'AUTH_MODULE_OPTIONS';
-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';
-export const SOCIAL_STATE_PREFIX = 'auth:social:state';
-// Social Login
-export const SOCIAL_STATE_TTL_MS = 10 * 60 * 1000; // 10 minutes

package/fesm/config/event-actions.js

@@ -1,26 +0,0 @@
-/**
- * Domain event actions published by the auth module, alongside the CRUD
- * lifecycle actions every ApiService emits.
- */ export const AUTH_EVENT_ACTIONS = {
-    LOGGED_IN: 'logged-in',
-    LOGGED_OUT: 'logged-out',
-    TOKEN_REFRESHED: 'token-refreshed',
-    COMPANY_SWITCHED: 'company-switched',
-    REGISTERED: 'registered',
-    PASSWORD_CHANGED: 'password-changed',
-    PASSWORD_RESET_REQUESTED: 'password-reset-requested',
-    PASSWORD_RESET: 'password-reset',
-    EMAIL_VERIFIED: 'email-verified',
-    PERMISSION_GRANTED: 'permission-granted',
-    PERMISSION_REVOKED: 'permission-revoked',
-    SOCIAL_LOGGED_IN: 'social-logged-in'
-};
-/** Every entity the auth module publishes under, ApiService backed or not */ export const AUTH_EVENT_ENTITIES = {
-    USER: 'appuser',
-    COMPANY: 'company',
-    COMPANY_BRANCH: 'company_branch',
-    SESSION: 'session',
-    USER_PERMISSION: 'user_company_permission',
-    SOCIAL_AUTH_CONFIG: 'social_auth_config'
-};
-export const AUTH_EVENT_MODULE = 'auth';

package/fesm/config/message-keys.js

@@ -1,99 +0,0 @@
-// ==================== AUTH MODULE MESSAGE KEYS ====================
-export const AUTH_MESSAGES = {
-    LOGIN_SUCCESS: 'auth.login.success',
-    LOGIN_REQUIRES_SELECTION: 'auth.login.requires.selection',
-    LOGIN_INVALID_CREDENTIALS: 'auth.login.invalid.credentials',
-    LOGIN_EMAIL_NOT_VERIFIED: 'auth.login.email.not.verified',
-    LOGIN_ACCOUNT_DEACTIVATED: 'auth.login.account.deactivated',
-    LOGOUT_SUCCESS: 'auth.logout.success',
-    REGISTER_SUCCESS: 'auth.register.success',
-    REGISTER_FAILED: 'auth.register.failed',
-    REFRESH_SUCCESS: 'auth.refresh.success',
-    ME_SUCCESS: 'auth.me.success',
-    SELECT_SUCCESS: 'auth.select.success',
-    SWITCH_COMPANY_SUCCESS: 'auth.switch.company.success',
-    REGISTER_EMAIL_EXISTS: 'auth.register.email.exists',
-    REGISTER_ACCOUNT_DELETED: 'auth.register.account.deleted',
-    REGISTER_COMPANY_ALREADY_ASSIGNED: 'auth.register.company.already.assigned',
-    REGISTER_SIGNUP_DISABLED: 'auth.register.signup.disabled',
-    PASSWORD_CHANGE_SUCCESS: 'auth.password.change.success',
-    PASSWORD_CHANGE_INVALID_CURRENT: 'auth.password.change.invalid.current',
-    PASSWORD_CHANGE_CURRENT_REQUIRED: 'auth.password.change.current.required',
-    PASSWORD_RESET_EMAIL_SENT: 'auth.password.reset.email.sent',
-    PASSWORD_RESET_SUCCESS: 'auth.password.reset.success',
-    TOKEN_REQUIRED: 'auth.token.required',
-    TOKEN_INVALID: 'auth.token.invalid',
-    TOKEN_EXPIRED: 'auth.token.expired',
-    TOKEN_REVOKED: 'auth.token.revoked',
-    TOKEN_TOO_LARGE: 'auth.token.too.large',
-    COMPANY_LIST_SUCCESS: 'auth.company.list.success',
-    COMPANY_NO_ACCESS: 'auth.company.no.access',
-    COMPANY_NOT_FOUND: 'auth.company.not.found',
-    COMPANY_REQUIRED: 'auth.company.required',
-    COMPANY_FEATURE_NOT_ENABLED: 'auth.company.feature.not.enabled',
-    BRANCH_LIST_SUCCESS: 'auth.branch.list.success',
-    BRANCH_NO_ACCESS: 'auth.branch.no.access',
-    BRANCH_NOT_FOUND: 'auth.branch.not.found',
-    EMAIL_NOT_CONFIGURED: 'auth.email.not.configured',
-    EMAIL_SEND_FAILED: 'auth.email.send.failed',
-    SESSION_INVALID: 'auth.session.invalid',
-    SESSION_NOT_AVAILABLE: 'auth.session.not.available',
-    PROFILE_ACCESS_DENIED: 'auth.profile.access.denied',
-    PROFILE_SECTIONS_NOT_SUPPORTED: 'auth.profile.sections.not.supported',
-    LOGOUT_SERVICE_UNAVAILABLE: 'auth.logout.service.unavailable',
-    PASSWORD_RESET_TOKEN_EXPIRED: 'auth.password.reset.token.expired',
-    PASSWORD_RESET_TOKEN_USED: 'auth.password.reset.token.used'
-};
-export const EMAIL_VERIFICATION_MESSAGES = {
-    VERIFICATION_SENT: 'email.verification.sent',
-    VERIFICATION_SUCCESS: 'email.verification.success',
-    VERIFICATION_TOKEN_INVALID: 'email.verification.token.invalid',
-    VERIFICATION_TOKEN_EXPIRED: 'email.verification.token.expired',
-    VERIFICATION_NOT_ENABLED: 'email.verification.not.enabled',
-    RESEND_SUCCESS: 'email.verification.resend.success'
-};
-export const SOCIAL_AUTH_MESSAGES = {
-    PROVIDERS_SUCCESS: 'auth.social.providers.success',
-    AUTHORIZE_SUCCESS: 'auth.social.authorize.success',
-    LOGIN_SUCCESS: 'auth.social.login.success',
-    PROVIDER_DISABLED: 'auth.social.provider.disabled',
-    PROVIDER_NOT_CONFIGURED: 'auth.social.provider.not.configured',
-    STATE_INVALID: 'auth.social.state.invalid',
-    REDIRECT_URI_MISMATCH: 'auth.social.redirect.uri.mismatch',
-    EXCHANGE_FAILED: 'auth.social.exchange.failed',
-    PROFILE_INCOMPLETE: 'auth.social.profile.incomplete',
-    ACCOUNT_NOT_LINKED: 'auth.social.account.not.linked',
-    COMPANY_REQUIRED: 'auth.social.company.required',
-    EMAIL_REQUIRED: 'auth.social.email.required',
-    EMAIL_NOT_VERIFIED: 'auth.social.email.not.verified',
-    ACCOUNT_DELETED: 'auth.social.account.deleted'
-};
-export const SOCIAL_AUTH_CONFIG_MESSAGES = {
-    PROVIDER_ALREADY_CONFIGURED: 'social.config.provider.already.configured'
-};
-export const USER_MESSAGES = {
-    NOT_FOUND: 'user.not.found',
-    PROFILE_UPDATE_SUCCESS: 'user.profile.update.success',
-    PROFILE_EXTRAS_SUCCESS: 'user.profile.extras.success',
-    PROFILE_SECTIONS_SUCCESS: 'user.profile.sections.success',
-    PROFILE_SECTION_DATA_SUCCESS: 'user.profile.section.data.success',
-    PROFILE_SECTION_UPDATE_SUCCESS: 'user.profile.section.update.success',
-    PROFILE_COMPLETION_SUCCESS: 'user.profile.completion.success',
-    EMAIL_VERIFY_SUCCESS: 'user.email.verify.success',
-    PHONE_VERIFY_SUCCESS: 'user.phone.verify.success',
-    STATUS_UPDATE_SUCCESS: 'user.status.update.success',
-    LOOKUP_SUCCESS: 'user.lookup.success'
-};
-export const COMPANY_MESSAGES = {
-    READONLY_DELETE_FORBIDDEN: 'company.readonly.delete.forbidden'
-};
-export const BRANCH_MESSAGES = {
-    READONLY_DELETE_FORBIDDEN: 'branch.readonly.delete.forbidden'
-};
-export const USER_PERMISSION_MESSAGES = {
-    COMPANY_LIST_SUCCESS: 'user.permission.company.list.success',
-    BRANCH_LIST_SUCCESS: 'user.permission.branch.list.success',
-    BATCH_SUCCESS: 'user.permission.batch.success',
-    ALREADY_ASSIGNED: 'user.permission.already.assigned',
-    PERMISSION_NOT_FOUND: 'user.permission.not.found'
-};