@flusys/nestjs-shared 1.1.0-beta → 1.2.0-rc.1

package/fesm/entities/identity.js

@@ -26,10 +26,10 @@ export class Identity {
         _define_property(this, "id", void 0);
         _define_property(this, "createdAt", void 0);
         _define_property(this, "updatedAt", void 0);
-        _define_property(this, "deletedAt", void 0);
-        _define_property(this, "createdById", void 0);
-        _define_property(this, "updatedById", void 0);
-        _define_property(this, "deletedById", void 0);
+        _define_property(this, "deletedAt", null);
+        _define_property(this, "createdById", null);
+        _define_property(this, "updatedById", null);
+        _define_property(this, "deletedById", null);
     }
 }
 _ts_decorate([
@@ -39,14 +39,16 @@ _ts_decorate([
 _ts_decorate([
     CreateDateColumn({
         name: 'created_at',
-        type: 'timestamp'
+        type: 'timestamp',
+        select: false
     }),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], Identity.prototype, "createdAt", void 0);
 _ts_decorate([
     UpdateDateColumn({
         name: 'updated_at',
-        type: 'timestamp'
+        type: 'timestamp',
+        select: false
     }),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], Identity.prototype, "updatedAt", void 0);
@@ -54,6 +56,7 @@ _ts_decorate([
     DeleteDateColumn({
         name: 'deleted_at',
         type: 'timestamp',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)
@@ -62,6 +65,7 @@ _ts_decorate([
     Column({
         name: 'created_by_id',
         type: 'uuid',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)
@@ -70,6 +74,7 @@ _ts_decorate([
     Column({
         name: 'updated_by_id',
         type: 'uuid',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)
@@ -78,6 +83,7 @@ _ts_decorate([
     Column({
         name: 'deleted_by_id',
         type: 'uuid',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)

package/fesm/entities/index.js

@@ -1,2 +1,3 @@
 export * from './identity';
+export * from './raw-type';
 export * from './user-root';

package/fesm/entities/raw-type.js

@@ -0,0 +1 @@
+export { };

package/fesm/entities/user-root.js

@@ -20,27 +20,27 @@ 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 { getJsonColumnType } from '@flusys/nestjs-shared';
 import { Column, CreateDateColumn, DeleteDateColumn, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
 export class UserRoot {
     constructor(){
         _define_property(this, "id", void 0);
-        _define_property(this, "name", void 0);
-        _define_property(this, "password", void 0);
+        _define_property(this, "name", null);
+        _define_property(this, "password", null);
         _define_property(this, "email", void 0);
-        _define_property(this, "phone", void 0);
-        _define_property(this, "isActive", void 0);
-        _define_property(this, "emailVerified", void 0);
-        _define_property(this, "phoneVerified", void 0);
-        _define_property(this, "profilePictureId", void 0);
-        _define_property(this, "lastLoginAt", void 0);
-        _define_property(this, "additionalFields", void 0);
+        _define_property(this, "phone", null);
+        _define_property(this, "isActive", true);
+        _define_property(this, "emailVerified", false);
+        _define_property(this, "phoneVerified", false);
+        _define_property(this, "profilePictureId", null);
+        _define_property(this, "lastLoginAt", null);
+        _define_property(this, "additionalFields", null);
         _define_property(this, "createdAt", void 0);
         _define_property(this, "updatedAt", void 0);
-        _define_property(this, "deletedAt", void 0);
-        // Audit columns (for ApiService compatibility)
-        _define_property(this, "createdById", void 0);
-        _define_property(this, "updatedById", void 0);
-        _define_property(this, "deletedById", void 0);
+        _define_property(this, "deletedAt", null);
+        _define_property(this, "createdById", null);
+        _define_property(this, "updatedById", null);
+        _define_property(this, "deletedById", null);
     }
 }
 _ts_decorate([
@@ -125,7 +125,7 @@ _ts_decorate([
 ], UserRoot.prototype, "lastLoginAt", void 0);
 _ts_decorate([
     Column({
-        type: 'json',
+        type: getJsonColumnType(),
         nullable: true,
         name: 'additional_fields'
     }),

package/fesm/enums/index.js

@@ -0,0 +1,3 @@
+export * from './notification-type.enum';
+export * from './participant-status.enum';
+export * from './recurrence-type.enum';

package/fesm/enums/notification-type.enum.js

@@ -0,0 +1,7 @@
+export var NotificationType = /*#__PURE__*/ function(NotificationType) {
+    NotificationType["INFO"] = "info";
+    NotificationType["WARNING"] = "warning";
+    NotificationType["SUCCESS"] = "success";
+    NotificationType["ERROR"] = "error";
+    return NotificationType;
+}({});

package/fesm/enums/participant-status.enum.js

@@ -0,0 +1,7 @@
+export var ParticipantStatus = /*#__PURE__*/ function(ParticipantStatus) {
+    ParticipantStatus["PENDING"] = "pending";
+    ParticipantStatus["ACCEPTED"] = "accepted";
+    ParticipantStatus["DECLINED"] = "declined";
+    ParticipantStatus["TENTATIVE"] = "tentative";
+    return ParticipantStatus;
+}({});

package/fesm/enums/recurrence-type.enum.js

@@ -0,0 +1,8 @@
+export var RecurrenceType = /*#__PURE__*/ function(RecurrenceType) {
+    RecurrenceType["NONE"] = "none";
+    RecurrenceType["DAILY"] = "daily";
+    RecurrenceType["WEEKLY"] = "weekly";
+    RecurrenceType["BIWEEKLY"] = "biweekly";
+    RecurrenceType["MONTHLY"] = "monthly";
+    return RecurrenceType;
+}({});

package/fesm/exceptions/base-app.exception.js

@@ -0,0 +1,115 @@
+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;
+}
+import { HttpException, HttpStatus } from '@nestjs/common';
+import { ERROR_MESSAGES } from '../constants/message-keys';
+export class BaseAppException extends HttpException {
+    constructor(options){
+        const status = options.status || HttpStatus.BAD_REQUEST;
+        super({
+            success: false,
+            message: options.message,
+            messageKey: options.messageKey || ERROR_MESSAGES.GENERIC,
+            messageVariables: options.messageVariables,
+            errors: options.errors
+        }, status), _define_property(this, "messageKey", void 0), _define_property(this, "messageVariables", void 0), _define_property(this, "errors", void 0), _define_property(this, "metadata", void 0);
+        this.messageKey = options.messageKey || ERROR_MESSAGES.GENERIC;
+        this.messageVariables = options.messageVariables;
+        this.errors = options.errors;
+        this.metadata = options.metadata;
+    }
+}
+export class NotFoundException extends BaseAppException {
+    constructor(entity, id){
+        super({
+            message: id ? `${entity} with id "${id}" not found` : `${entity} not found`,
+            messageKey: ERROR_MESSAGES.NOT_FOUND,
+            status: HttpStatus.NOT_FOUND,
+            metadata: {
+                entity,
+                id
+            }
+        });
+    }
+}
+export class ValidationException extends BaseAppException {
+    constructor(errors){
+        super({
+            message: 'Validation failed',
+            messageKey: ERROR_MESSAGES.VALIDATION,
+            status: HttpStatus.BAD_REQUEST,
+            errors
+        });
+    }
+}
+export class UnauthorizedException extends BaseAppException {
+    constructor(message = 'Unauthorized access'){
+        super({
+            message,
+            messageKey: ERROR_MESSAGES.UNAUTHORIZED,
+            status: HttpStatus.UNAUTHORIZED
+        });
+    }
+}
+export class ForbiddenException extends BaseAppException {
+    constructor(message = 'Access forbidden'){
+        super({
+            message,
+            messageKey: ERROR_MESSAGES.FORBIDDEN,
+            status: HttpStatus.FORBIDDEN
+        });
+    }
+}
+export class ConflictException extends BaseAppException {
+    constructor(entity, field){
+        super({
+            message: field ? `${entity} with this ${field} already exists` : `${entity} already exists`,
+            messageKey: ERROR_MESSAGES.CONFLICT,
+            messageVariables: {
+                entity,
+                ...field !== undefined && {
+                    field
+                }
+            },
+            status: HttpStatus.CONFLICT,
+            metadata: {
+                entity,
+                field
+            }
+        });
+    }
+}
+export class InternalServerException extends BaseAppException {
+    constructor(message = 'Internal server error'){
+        super({
+            message,
+            messageKey: ERROR_MESSAGES.INTERNAL,
+            status: HttpStatus.INTERNAL_SERVER_ERROR
+        });
+    }
+}
+export class ServiceUnavailableException extends BaseAppException {
+    constructor(service){
+        super({
+            message: `${service} is temporarily unavailable`,
+            messageKey: ERROR_MESSAGES.SERVICE_UNAVAILABLE,
+            messageVariables: {
+                service
+            },
+            status: HttpStatus.SERVICE_UNAVAILABLE,
+            metadata: {
+                service
+            }
+        });
+    }
+}

package/fesm/exceptions/index.js

@@ -1 +1,2 @@
+export * from './base-app.exception';
 export * from './permission.exception';

package/fesm/exceptions/permission.exception.js

@@ -1,37 +1,35 @@
 import { ForbiddenException, InternalServerErrorException } from '@nestjs/common';
-/**
- * Exception thrown when permission system is unavailable
- */ export class PermissionSystemUnavailableException extends InternalServerErrorException {
-    constructor(message = 'Permission system temporarily unavailable. Please try again later.'){
+import { ERROR_MESSAGES } from '../constants/message-keys';
+export class PermissionSystemUnavailableException extends InternalServerErrorException {
+    constructor(){
         super({
             success: false,
-            message,
-            code: 'PERMISSION_SYSTEM_UNAVAILABLE'
+            message: 'Permission system temporarily unavailable',
+            messageKey: ERROR_MESSAGES.PERMISSION_SYSTEM_UNAVAILABLE
         });
     }
 }
-/**
- * Exception thrown when user lacks required permissions
- */ export class InsufficientPermissionsException extends ForbiddenException {
-    constructor(missingPermissions, operator = 'and'){
-        const message = operator === 'or' ? `Requires at least one of: ${missingPermissions.join(', ')}` : `Missing required permissions: ${missingPermissions.join(', ')}`;
+export class InsufficientPermissionsException extends ForbiddenException {
+    constructor(missingPermissions, operator = 'AND'){
+        const messageKey = operator === 'OR' ? ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS_OR : ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS;
         super({
             success: false,
-            message,
-            code: 'INSUFFICIENT_PERMISSIONS',
+            message: 'Insufficient permissions',
+            messageKey,
+            messageVariables: {
+                permissions: missingPermissions.join(', ')
+            },
             missingPermissions,
             operator
         });
     }
 }
-/**
- * Exception thrown when no permissions found for user
- */ export class NoPermissionsFoundException extends ForbiddenException {
+export class NoPermissionsFoundException extends ForbiddenException {
     constructor(){
         super({
             success: false,
-            message: 'No permissions found. Please contact administrator.',
-            code: 'NO_PERMISSIONS_FOUND'
+            message: 'No permissions found',
+            messageKey: ERROR_MESSAGES.NO_PERMISSIONS_FOUND
         });
     }
 }

package/fesm/filters/global-exception.filter.js

@@ -0,0 +1,269 @@
+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;
+}
+import { Catch, HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { QueryFailedError } from 'typeorm';
+import { ERROR_MESSAGES } from '../constants/message-keys';
+import { BaseAppException, ConflictException } from '../exceptions/base-app.exception';
+import { getCompanyId, getRequestId, getTenantId, getUserId } from '../middlewares/logger.middleware';
+export class GlobalExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const request = ctx.getRequest();
+        const response = ctx.getResponse();
+        const responseTime = Date.now() - (request._startTime || Date.now());
+        const requestId = getRequestId() || request.headers['x-request-id'] || 'no-request-id';
+        const { statusCode, errorResponse } = this.resolveException(exception, requestId, responseTime);
+        const logContext = {
+            requestId,
+            userId: getUserId(),
+            tenantId: getTenantId(),
+            companyId: getCompanyId(),
+            method: request.method,
+            url: request.originalUrl,
+            path: request.path,
+            statusCode,
+            duration: `${responseTime}ms`,
+            messageKey: errorResponse.messageKey
+        };
+        const logMessage = `Exception caught "HTTP/1.1" "${request.method}" "${request.originalUrl}" - ${statusCode} "${errorResponse.messageKey}" ${responseTime}ms | ${errorResponse.message}`;
+        if (statusCode >= 500) {
+            this.logger.error(logMessage, exception instanceof Error ? exception.stack : undefined, logContext);
+        } else if (statusCode >= 400) {
+            this.logger.warn(logMessage, logContext);
+        }
+        response.status(statusCode).json(errorResponse);
+    }
+    resolveException(exception, requestId, responseTime) {
+        const meta = {
+            requestId,
+            timestamp: new Date().toISOString(),
+            responseTime
+        };
+        if (exception instanceof BaseAppException) {
+            return {
+                statusCode: exception.getStatus(),
+                errorResponse: {
+                    success: false,
+                    message: exception.message,
+                    messageKey: exception.messageKey,
+                    messageVariables: exception.messageVariables,
+                    errors: exception.errors,
+                    _meta: meta
+                }
+            };
+        }
+        if (exception instanceof HttpException) {
+            const resolved = this.resolveHttpException(exception);
+            return {
+                statusCode: resolved.statusCode,
+                errorResponse: {
+                    success: false,
+                    message: resolved.message,
+                    messageKey: resolved.messageKey,
+                    messageVariables: resolved.messageVariables,
+                    errors: resolved.errors,
+                    _meta: meta
+                }
+            };
+        }
+        if (exception instanceof QueryFailedError) {
+            const resolved = this.resolveQueryFailedError(exception);
+            if (resolved) {
+                return {
+                    statusCode: resolved.getStatus(),
+                    errorResponse: {
+                        success: false,
+                        message: resolved.message,
+                        messageKey: resolved.messageKey,
+                        messageVariables: resolved.messageVariables,
+                        _meta: meta
+                    }
+                };
+            }
+        }
+        return {
+            statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+            errorResponse: {
+                success: false,
+                message: 'Internal server error',
+                messageKey: ERROR_MESSAGES.INTERNAL,
+                _meta: meta
+            }
+        };
+    }
+    resolveHttpException(exception) {
+        const statusCode = exception.getStatus();
+        const response = exception.getResponse();
+        if (typeof response === 'string') {
+            return {
+                statusCode,
+                message: response,
+                messageKey: ERROR_MESSAGES.HTTP
+            };
+        }
+        if (typeof response === 'object' && response !== null) {
+            const obj = response;
+            if (Array.isArray(obj.message)) {
+                const errors = obj.message.map((msg)=>{
+                    const [field, ...rest] = msg.split(' ');
+                    return {
+                        field: field || 'unknown',
+                        message: rest.join(' ') || msg
+                    };
+                });
+                return {
+                    statusCode,
+                    message: 'Validation failed',
+                    messageKey: ERROR_MESSAGES.VALIDATION,
+                    errors
+                };
+            }
+            return {
+                statusCode,
+                message: String(obj.message || 'Unknown error'),
+                messageKey: String(obj.messageKey || ERROR_MESSAGES.HTTP),
+                messageVariables: obj.messageVariables,
+                errors: obj.errors
+            };
+        }
+        return {
+            statusCode,
+            message: 'Unknown error',
+            messageKey: ERROR_MESSAGES.UNKNOWN
+        };
+    }
+    resolveQueryFailedError(exception) {
+        const dbError = exception;
+        const code = dbError.driverError?.code ?? dbError.code;
+        const number = dbError.driverError?.number ?? dbError.number;
+        const errno = dbError.driverError?.errno ?? dbError.errno;
+        const sqlMessage = dbError.driverError?.sqlMessage ?? '';
+        const detail = dbError.driverError?.detail ?? dbError.detail ?? '';
+        const table = dbError.driverError?.table ?? dbError.table ?? '';
+        const column = dbError.driverError?.column ?? dbError.column;
+        const pgField = detail.match(/Key \(([^)]+)\)/)?.[1] ?? column;
+        // DUPLICATE / UNIQUE VIOLATION
+        // PG: 23505 | MSSQL: 2627 (constraint), 2601 (index) | MySQL: ER_DUP_ENTRY / errno 1062
+        if (code === '23505' || number === 2627 || number === 2601 || code === 'ER_DUP_ENTRY' || errno === 1062) {
+            const mysqlTable = sqlMessage.match(/for key '([^'.]+)\./)?.[1];
+            const mysqlIndex = sqlMessage.match(/for key '(?:[^.]+\.)?([^']+)'/)?.[1];
+            const resolvedTable = table || mysqlTable || 'record';
+            const resolvedField = pgField ? this.toHumanReadable(pgField) : mysqlIndex ? this.toHumanReadable(mysqlIndex) : undefined;
+            return new ConflictException(this.toHumanReadable(resolvedTable), resolvedField);
+        }
+        // FOREIGN KEY VIOLATION
+        // PG: 23503 | MSSQL: 547 | MySQL: ER_NO_REFERENCED_ROW_2/1452 (insert), ER_ROW_IS_REFERENCED_2/1451 (delete)
+        if (code === '23503' || number === 547 || code === 'ER_NO_REFERENCED_ROW_2' || code === 'ER_ROW_IS_REFERENCED_2' || errno === 1452 || errno === 1451) {
+            const mysqlColumn = sqlMessage.match(/FOREIGN KEY \(`([^`]+)`\)/)?.[1];
+            const raw = pgField ?? mysqlColumn;
+            const humanField = raw ? this.toHumanReadable(raw) : undefined;
+            return new BaseAppException({
+                message: humanField ? `Invalid reference for '${humanField}'` : 'Invalid reference',
+                messageKey: ERROR_MESSAGES.DB_FOREIGN_KEY,
+                messageVariables: humanField ? {
+                    field: humanField
+                } : undefined,
+                status: HttpStatus.BAD_REQUEST
+            });
+        }
+        // NOT NULL VIOLATION
+        // PG: 23502 | MSSQL: 515 | MySQL: ER_BAD_NULL_ERROR / errno 1048
+        if (code === '23502' || number === 515 || code === 'ER_BAD_NULL_ERROR' || errno === 1048) {
+            const mysqlColumn = sqlMessage.match(/Column '([^']+)' cannot be null/)?.[1];
+            const humanField = this.toHumanReadable(column ?? mysqlColumn ?? 'field');
+            return new BaseAppException({
+                message: `Required field '${humanField}' cannot be null`,
+                messageKey: ERROR_MESSAGES.DB_NOT_NULL,
+                messageVariables: {
+                    field: humanField
+                },
+                status: HttpStatus.BAD_REQUEST
+            });
+        }
+        // INVALID INPUT SYNTAX — PostgreSQL only (MySQL silently coerces types)
+        if (code === '22P02') {
+            const typeMatch = exception.message.match(/invalid input syntax for(?:\s+type)?\s+(\w+)/i);
+            const type = typeMatch?.[1] ?? 'value';
+            const humanField = column ? this.toHumanReadable(column) : undefined;
+            return new BaseAppException({
+                message: humanField ? `Invalid ${type} value for '${humanField}'` : `Invalid ${type} value`,
+                messageKey: ERROR_MESSAGES.DB_INVALID_INPUT,
+                messageVariables: {
+                    type,
+                    ...humanField !== undefined && {
+                        field: humanField
+                    }
+                },
+                status: HttpStatus.BAD_REQUEST
+            });
+        }
+        // VALUE TOO LONG
+        // PG: 22001 | MySQL: ER_DATA_TOO_LONG / errno 1406
+        if (code === '22001' || code === 'ER_DATA_TOO_LONG' || errno === 1406) {
+            const mysqlColumn = sqlMessage.match(/Data too long for column '([^']+)'/)?.[1];
+            const resolvedColumn = column ?? mysqlColumn;
+            const humanField = resolvedColumn ? this.toHumanReadable(resolvedColumn) : undefined;
+            return new BaseAppException({
+                message: humanField ? `Value too long for '${humanField}'` : 'Value exceeds maximum length',
+                messageKey: ERROR_MESSAGES.DB_VALUE_TOO_LONG,
+                messageVariables: humanField !== undefined ? {
+                    field: humanField
+                } : undefined,
+                status: HttpStatus.BAD_REQUEST
+            });
+        }
+        // CHECK CONSTRAINT VIOLATION
+        // PG: 23514 | MySQL 8.0+: ER_CHECK_CONSTRAINT_VIOLATED / errno 3819
+        if (code === '23514' || code === 'ER_CHECK_CONSTRAINT_VIOLATED' || errno === 3819) {
+            const constraint = dbError.driverError?.constraint ?? dbError.constraint;
+            const humanTable = this.toHumanReadable(table || 'record');
+            return new BaseAppException({
+                message: `${humanTable} violates a validation rule`,
+                messageKey: ERROR_MESSAGES.DB_CHECK_CONSTRAINT,
+                messageVariables: {
+                    entity: humanTable,
+                    ...constraint !== undefined && {
+                        constraint
+                    }
+                },
+                status: HttpStatus.BAD_REQUEST
+            });
+        }
+        // DEADLOCK
+        // PG: 40P01 | MSSQL: 1205 | MySQL: ER_LOCK_DEADLOCK / errno 1213
+        if (code === '40P01' || number === 1205 || code === 'ER_LOCK_DEADLOCK' || errno === 1213) {
+            return new BaseAppException({
+                message: 'The request could not be completed due to a conflict, please try again',
+                messageKey: ERROR_MESSAGES.DB_DEADLOCK,
+                status: HttpStatus.SERVICE_UNAVAILABLE
+            });
+        }
+        return null;
+    }
+    toHumanReadable(dbName) {
+        return dbName.split(', ').map((part)=>part.split('_').map((word)=>word.toLowerCase() === 'id' ? 'ID' : word.charAt(0).toUpperCase() + word.slice(1)).join(' ')).join(', ');
+    }
+    constructor(){
+        _define_property(this, "logger", new Logger('ExceptionFilter'));
+    }
+}
+GlobalExceptionFilter = _ts_decorate([
+    Catch()
+], GlobalExceptionFilter);

package/fesm/filters/index.js

@@ -0,0 +1 @@
+export * from './global-exception.filter';

package/fesm/guards/jwt-auth.guard.js

@@ -25,7 +25,7 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { IS_PUBLIC_KEY } from '../constants';
+import { AUTH_MESSAGES, IS_PUBLIC_KEY } from '../constants';
 import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
@@ -43,7 +43,10 @@ export class JwtAuthGuard extends AuthGuard('jwt') {
     }
     handleRequest(err, user) {
         if (err || !user) {
-            throw err || new UnauthorizedException('Invalid or expired token');
+            throw err || new UnauthorizedException({
+                message: 'Invalid or expired token',
+                messageKey: AUTH_MESSAGES.TOKEN_INVALID
+            });
         }
         return user;
     }