@flusys/nestjs-shared 3.0.1 → 4.0.0-rc

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

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BaseAppException () {
+        return BaseAppException;
+    },
+    get ConflictException () {
+        return ConflictException;
+    },
+    get ForbiddenException () {
+        return ForbiddenException;
+    },
+    get InternalServerException () {
+        return InternalServerException;
+    },
+    get NotFoundException () {
+        return NotFoundException;
+    },
+    get ServiceUnavailableException () {
+        return ServiceUnavailableException;
+    },
+    get UnauthorizedException () {
+        return UnauthorizedException;
+    },
+    get ValidationException () {
+        return ValidationException;
+    }
+});
+const _common = require("@nestjs/common");
+const _messagekeys = require("../constants/message-keys");
+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;
+}
+let BaseAppException = class BaseAppException extends _common.HttpException {
+    constructor(options){
+        const status = options.status || _common.HttpStatus.BAD_REQUEST;
+        super({
+            success: false,
+            message: options.message,
+            messageKey: options.messageKey || _messagekeys.ERROR_MESSAGES.GENERIC,
+            messageParams: options.messageParams,
+            errors: options.errors
+        }, status), _define_property(this, "messageKey", void 0), _define_property(this, "messageParams", void 0), _define_property(this, "errors", void 0), _define_property(this, "metadata", void 0);
+        this.messageKey = options.messageKey || _messagekeys.ERROR_MESSAGES.GENERIC;
+        this.messageParams = options.messageParams;
+        this.errors = options.errors;
+        this.metadata = options.metadata;
+    }
+};
+let NotFoundException = class NotFoundException extends BaseAppException {
+    constructor(entity, id){
+        super({
+            message: id ? `${entity} with id "${id}" not found` : `${entity} not found`,
+            messageKey: _messagekeys.ERROR_MESSAGES.NOT_FOUND,
+            status: _common.HttpStatus.NOT_FOUND,
+            metadata: {
+                entity,
+                id
+            }
+        });
+    }
+};
+let ValidationException = class ValidationException extends BaseAppException {
+    constructor(errors){
+        super({
+            message: 'Validation failed',
+            messageKey: _messagekeys.ERROR_MESSAGES.VALIDATION,
+            status: _common.HttpStatus.BAD_REQUEST,
+            errors
+        });
+    }
+};
+let UnauthorizedException = class UnauthorizedException extends BaseAppException {
+    constructor(message = 'Unauthorized access'){
+        super({
+            message,
+            messageKey: _messagekeys.ERROR_MESSAGES.UNAUTHORIZED,
+            status: _common.HttpStatus.UNAUTHORIZED
+        });
+    }
+};
+let ForbiddenException = class ForbiddenException extends BaseAppException {
+    constructor(message = 'Access forbidden'){
+        super({
+            message,
+            messageKey: _messagekeys.ERROR_MESSAGES.FORBIDDEN,
+            status: _common.HttpStatus.FORBIDDEN
+        });
+    }
+};
+let ConflictException = class ConflictException extends BaseAppException {
+    constructor(entity, field){
+        super({
+            message: field ? `${entity} with this ${field} already exists` : `${entity} already exists`,
+            messageKey: _messagekeys.ERROR_MESSAGES.CONFLICT,
+            status: _common.HttpStatus.CONFLICT,
+            metadata: {
+                entity,
+                field
+            }
+        });
+    }
+};
+let InternalServerException = class InternalServerException extends BaseAppException {
+    constructor(message = 'Internal server error'){
+        super({
+            message,
+            messageKey: _messagekeys.ERROR_MESSAGES.INTERNAL,
+            status: _common.HttpStatus.INTERNAL_SERVER_ERROR
+        });
+    }
+};
+let ServiceUnavailableException = class ServiceUnavailableException extends BaseAppException {
+    constructor(service){
+        super({
+            message: `${service} is temporarily unavailable`,
+            messageKey: _messagekeys.ERROR_MESSAGES.SERVICE_UNAVAILABLE,
+            messageParams: {
+                service
+            },
+            status: _common.HttpStatus.SERVICE_UNAVAILABLE,
+            metadata: {
+                service
+            }
+        });
+    }
+};

package/cjs/exceptions/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./base-app.exception"), exports);
 _export_star(require("./permission.exception"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/cjs/exceptions/permission.exception.js

@@ -20,22 +20,26 @@ _export(exports, {
     }
 });
 const _common = require("@nestjs/common");
+const _messagekeys = require("../constants/message-keys");
 let PermissionSystemUnavailableException = class PermissionSystemUnavailableException extends _common.InternalServerErrorException {
-    constructor(message = 'Permission system temporarily unavailable. Please try again later.'){
+    constructor(){
         super({
             success: false,
-            message,
-            code: 'PERMISSION_SYSTEM_UNAVAILABLE'
+            message: 'Permission system temporarily unavailable',
+            messageKey: _messagekeys.ERROR_MESSAGES.PERMISSION_SYSTEM_UNAVAILABLE
         });
     }
 };
 let InsufficientPermissionsException = class InsufficientPermissionsException extends _common.ForbiddenException {
     constructor(missingPermissions, operator = 'AND'){
-        const message = operator === 'OR' ? `Requires at least one of: ${missingPermissions.join(', ')}` : `Missing required permissions: ${missingPermissions.join(', ')}`;
+        const messageKey = operator === 'OR' ? _messagekeys.ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS_OR : _messagekeys.ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS;
         super({
             success: false,
-            message,
-            code: 'INSUFFICIENT_PERMISSIONS',
+            message: 'Insufficient permissions',
+            messageKey,
+            messageParams: {
+                permissions: missingPermissions.join(', ')
+            },
             missingPermissions,
             operator
         });
@@ -45,8 +49,8 @@ let NoPermissionsFoundException = class NoPermissionsFoundException extends _com
     constructor(){
         super({
             success: false,
-            message: 'No permissions found. Please contact administrator.',
-            code: 'NO_PERMISSIONS_FOUND'
+            message: 'No permissions found',
+            messageKey: _messagekeys.ERROR_MESSAGES.NO_PERMISSIONS_FOUND
         });
     }
 };

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GlobalExceptionFilter", {
+    enumerable: true,
+    get: function() {
+        return GlobalExceptionFilter;
+    }
+});
+const _common = require("@nestjs/common");
+const _messagekeys = require("../constants/message-keys");
+const _baseappexception = require("../exceptions/base-app.exception");
+const _loggermiddleware = require("../middlewares/logger.middleware");
+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;
+}
+let GlobalExceptionFilter = class GlobalExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const request = ctx.getRequest();
+        const response = ctx.getResponse();
+        const startTime = request._startTime || Date.now();
+        const responseTime = Date.now() - startTime;
+        const requestId = (0, _loggermiddleware.getRequestId)() || request.headers['x-request-id'] || 'no-request-id';
+        const userId = (0, _loggermiddleware.getUserId)();
+        const tenantId = (0, _loggermiddleware.getTenantId)();
+        const companyId = (0, _loggermiddleware.getCompanyId)();
+        const errorResponse = this.buildErrorResponse(exception, requestId, responseTime);
+        const statusCode = this.getStatusCode(exception);
+        const logContext = {
+            requestId,
+            userId,
+            tenantId,
+            companyId,
+            method: request.method,
+            url: request.originalUrl,
+            path: request.path,
+            statusCode,
+            duration: `${responseTime}ms`,
+            messageKey: errorResponse.messageKey
+        };
+        const logMessage = this.buildLogMessage(request, statusCode, responseTime, errorResponse);
+        if (statusCode >= 500) {
+            this.logger.error(logMessage, this.getStack(exception), logContext);
+        } else if (statusCode >= 400) {
+            this.logger.warn(logMessage, logContext);
+        }
+        response.status(statusCode).json(errorResponse);
+    }
+    buildErrorResponse(exception, requestId, responseTime) {
+        const timestamp = new Date().toISOString();
+        if (exception instanceof _baseappexception.BaseAppException) {
+            return {
+                success: false,
+                message: exception.message,
+                messageKey: exception.messageKey,
+                messageParams: exception.messageParams,
+                errors: exception.errors,
+                _meta: {
+                    requestId,
+                    timestamp,
+                    responseTime
+                }
+            };
+        }
+        if (exception instanceof _common.HttpException) {
+            const response = exception.getResponse();
+            const { message, messageKey, messageParams, errors } = this.extractHttpExceptionDetails(response);
+            return {
+                success: false,
+                message,
+                messageKey,
+                messageParams,
+                errors,
+                _meta: {
+                    requestId,
+                    timestamp,
+                    responseTime
+                }
+            };
+        }
+        return {
+            success: false,
+            message: 'Internal server error',
+            messageKey: _messagekeys.ERROR_MESSAGES.INTERNAL,
+            _meta: {
+                requestId,
+                timestamp,
+                responseTime
+            }
+        };
+    }
+    extractHttpExceptionDetails(response) {
+        if (typeof response === 'string') {
+            return {
+                message: response,
+                messageKey: _messagekeys.ERROR_MESSAGES.HTTP
+            };
+        }
+        if (typeof response === 'object' && response !== null) {
+            const obj = response;
+            // Handle class-validator validation errors
+            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 {
+                    message: 'Validation failed',
+                    messageKey: _messagekeys.ERROR_MESSAGES.VALIDATION,
+                    errors
+                };
+            }
+            return {
+                message: String(obj.message || 'Unknown error'),
+                messageKey: String(obj.messageKey || _messagekeys.ERROR_MESSAGES.HTTP),
+                messageParams: obj.messageParams,
+                errors: obj.errors
+            };
+        }
+        return {
+            message: 'Unknown error',
+            messageKey: _messagekeys.ERROR_MESSAGES.UNKNOWN
+        };
+    }
+    getStatusCode(exception) {
+        if (exception instanceof _common.HttpException) {
+            return exception.getStatus();
+        }
+        return _common.HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+    getStack(exception) {
+        if (exception instanceof Error) {
+            return exception.stack;
+        }
+        return undefined;
+    }
+    buildLogMessage(request, statusCode, responseTime, errorResponse) {
+        return `Exception caught "HTTP/1.1" "${request.method}" "${request.originalUrl}" - ${statusCode} "${errorResponse.messageKey}" ${responseTime}ms | ${errorResponse.message}`;
+    }
+    constructor(){
+        _define_property(this, "logger", new _common.Logger('ExceptionFilter'));
+    }
+};
+GlobalExceptionFilter = _ts_decorate([
+    (0, _common.Catch)()
+], GlobalExceptionFilter);

package/cjs/filters/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./global-exception.filter"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -53,7 +53,10 @@ let JwtAuthGuard = class JwtAuthGuard extends (0, _passport.AuthGuard)('jwt') {
     }
     handleRequest(err, user) {
         if (err || !user) {
-            throw err || new _common.UnauthorizedException('Invalid or expired token');
+            throw err || new _common.UnauthorizedException({
+                message: 'Invalid or expired token',
+                messageKey: _constants.AUTH_MESSAGES.TOKEN_INVALID
+            });
         }
         return user;
     }

package/cjs/guards/permission.guard.js

@@ -11,10 +11,8 @@ Object.defineProperty(exports, "PermissionGuard", {
 const _common = require("@nestjs/common");
 const _core = require("@nestjs/core");
 const _hybridcacheclass = require("../classes/hybrid-cache.class");
-const _winstonloggeradapterclass = require("../classes/winston-logger-adapter.class");
 const _constants = require("../constants");
 const _permissionexception = require("../exceptions/permission.exception");
-const _loggerinterface = require("../interfaces/logger.interface");
 const _permissioninterface = require("../interfaces/permission.interface");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -57,21 +55,21 @@ let PermissionGuard = class PermissionGuard {
         if (!permissionConfig) return true;
         const request = context.switchToHttp().getRequest();
         const user = request.user;
-        if (!user) throw new _common.UnauthorizedException('Authentication required');
+        if (!user) throw new _common.UnauthorizedException({
+            message: 'Authentication required',
+            messageKey: _constants.AUTH_MESSAGES.TOKEN_REQUIRED
+        });
         if (!this.cache) {
-            this.logger.error(`Cache not available (userId: ${user.id})`, undefined, 'PermissionGuard');
             throw new _permissionexception.PermissionSystemUnavailableException();
         }
         const userPermissions = await this.getUserPermissions(user);
         if (!userPermissions || userPermissions.length === 0) {
-            this.logger.warn(`No permissions found (userId: ${user.id})`, 'PermissionGuard');
             throw new _permissionexception.NoPermissionsFoundException();
         }
         const logicNode = this.normalizeToLogicNode(permissionConfig);
         if (!logicNode) return true;
         const result = this.evaluateLogicNode(logicNode, userPermissions);
         if (!result.passed) {
-            this.logger.warn(`Permission denied (userId: ${user.id})`, 'PermissionGuard');
             throw new _permissionexception.InsufficientPermissionsException(result.missingPermissions, result.operator);
         }
         return true;
@@ -178,11 +176,10 @@ let PermissionGuard = class PermissionGuard {
         }
         return false;
     }
-    constructor(reflector, cache, config, logger){
+    constructor(reflector, cache, config){
         _define_property(this, "reflector", void 0);
         _define_property(this, "cache", void 0);
         _define_property(this, "config", void 0);
-        _define_property(this, "logger", void 0);
         this.reflector = reflector;
         this.cache = cache;
         this.config = {
@@ -191,7 +188,6 @@ let PermissionGuard = class PermissionGuard {
             companyPermissionKeyFormat: `${_constants.PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`,
             ...config
         };
-        this.logger = logger || new _winstonloggeradapterclass.NestLoggerAdapter(new _common.Logger(PermissionGuard.name));
     }
 };
 PermissionGuard = _ts_decorate([
@@ -201,13 +197,10 @@ PermissionGuard = _ts_decorate([
     _ts_param(1, (0, _common.Inject)(_constants.CACHE_INSTANCE)),
     _ts_param(2, (0, _common.Optional)()),
     _ts_param(2, (0, _common.Inject)(_constants.PERMISSION_GUARD_CONFIG)),
-    _ts_param(3, (0, _common.Optional)()),
-    _ts_param(3, (0, _common.Inject)(_constants.LOGGER_INSTANCE)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _core.Reflector === "undefined" ? Object : _core.Reflector,
         typeof _hybridcacheclass.HybridCache === "undefined" ? Object : _hybridcacheclass.HybridCache,
-        typeof _permissioninterface.PermissionGuardConfig === "undefined" ? Object : _permissioninterface.PermissionGuardConfig,
-        typeof _loggerinterface.ILogger === "undefined" ? Object : _loggerinterface.ILogger
+        typeof _permissioninterface.PermissionGuardConfig === "undefined" ? Object : _permissioninterface.PermissionGuardConfig
     ])
 ], PermissionGuard);

package/cjs/index.js

@@ -9,6 +9,7 @@ _export_star(require("./dtos"), exports);
 _export_star(require("./entities"), exports);
 _export_star(require("./enums"), exports);
 _export_star(require("./exceptions"), exports);
+_export_star(require("./filters"), exports);
 _export_star(require("./guards"), exports);
 _export_star(require("./interceptors"), exports);
 _export_star(require("./interfaces"), exports);

package/cjs/interceptors/idempotency.interceptor.js

@@ -61,7 +61,7 @@ let IdempotencyInterceptor = class IdempotencyInterceptor {
                 throw new _common.ConflictException({
                     success: false,
                     message: 'Request is already being processed',
-                    code: 'DUPLICATE_REQUEST_IN_PROGRESS'
+                    messageKey: _constants.SYSTEM_MESSAGES.DUPLICATE_REQUEST
                 });
             }
             // Return cached response

package/cjs/interceptors/index.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./delete-empty-id-from-body.interceptor"), exports);
 _export_star(require("./idempotency.interceptor"), exports);
-_export_star(require("./query-performance.interceptor"), exports);
 _export_star(require("./response-meta.interceptor"), exports);
 _export_star(require("./set-user-field-on-body.interceptor"), exports);
 _export_star(require("./slug.interceptor"), exports);

package/cjs/interfaces/logger.interface.js

@@ -1,7 +1,4 @@
-/**
- * Logger interface for dependency injection
- * Compatible with Winston, NestJS Logger, and console
- */ "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });