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

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

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GlobalExceptionFilter", {
+    enumerable: true,
+    get: function() {
+        return GlobalExceptionFilter;
+    }
+});
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+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 responseTime = Date.now() - (request._startTime || Date.now());
+        const requestId = (0, _loggermiddleware.getRequestId)() || request.headers['x-request-id'] || 'no-request-id';
+        const { statusCode, errorResponse } = this.resolveException(exception, requestId, responseTime);
+        const logContext = {
+            requestId,
+            userId: (0, _loggermiddleware.getUserId)(),
+            tenantId: (0, _loggermiddleware.getTenantId)(),
+            companyId: (0, _loggermiddleware.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.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 _common.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 _typeorm.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: _common.HttpStatus.INTERNAL_SERVER_ERROR,
+            errorResponse: {
+                success: false,
+                message: 'Internal server error',
+                messageKey: _messagekeys.ERROR_MESSAGES.INTERNAL,
+                _meta: meta
+            }
+        };
+    }
+    resolveHttpException(exception) {
+        const statusCode = exception.getStatus();
+        const response = exception.getResponse();
+        if (typeof response === 'string') {
+            return {
+                statusCode,
+                message: response,
+                messageKey: _messagekeys.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: _messagekeys.ERROR_MESSAGES.VALIDATION,
+                    errors
+                };
+            }
+            return {
+                statusCode,
+                message: String(obj.message || 'Unknown error'),
+                messageKey: String(obj.messageKey || _messagekeys.ERROR_MESSAGES.HTTP),
+                messageVariables: obj.messageVariables,
+                errors: obj.errors
+            };
+        }
+        return {
+            statusCode,
+            message: 'Unknown error',
+            messageKey: _messagekeys.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 _baseappexception.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.BaseAppException({
+                message: humanField ? `Invalid reference for '${humanField}'` : 'Invalid reference',
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_FOREIGN_KEY,
+                messageVariables: humanField ? {
+                    field: humanField
+                } : undefined,
+                status: _common.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.BaseAppException({
+                message: `Required field '${humanField}' cannot be null`,
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_NOT_NULL,
+                messageVariables: {
+                    field: humanField
+                },
+                status: _common.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.BaseAppException({
+                message: humanField ? `Invalid ${type} value for '${humanField}'` : `Invalid ${type} value`,
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_INVALID_INPUT,
+                messageVariables: {
+                    type,
+                    ...humanField !== undefined && {
+                        field: humanField
+                    }
+                },
+                status: _common.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.BaseAppException({
+                message: humanField ? `Value too long for '${humanField}'` : 'Value exceeds maximum length',
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_VALUE_TOO_LONG,
+                messageVariables: humanField !== undefined ? {
+                    field: humanField
+                } : undefined,
+                status: _common.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.BaseAppException({
+                message: `${humanTable} violates a validation rule`,
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_CHECK_CONSTRAINT,
+                messageVariables: {
+                    entity: humanTable,
+                    ...constraint !== undefined && {
+                        constraint
+                    }
+                },
+                status: _common.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.BaseAppException({
+                message: 'The request could not be completed due to a conflict, please try again',
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_DEADLOCK,
+                status: _common.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 _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) {
@@ -45,206 +43,151 @@ function _ts_param(paramIndex, decorator) {
 }
 let PermissionGuard = class PermissionGuard {
     async canActivate(context) {
-        // Check if route is marked as public
         const isPublic = this.reflector.getAllAndOverride(_constants.IS_PUBLIC_KEY, [
             context.getHandler(),
             context.getClass()
         ]);
         if (isPublic) return true;
-        // Get required permissions from decorator
         const permissionConfig = this.reflector.getAllAndOverride(_constants.PERMISSIONS_KEY, [
             context.getHandler(),
             context.getClass()
         ]);
-        // If no permissions required, allow access
-        if (!permissionConfig) {
-            return true;
-        }
-        // Normalize permission config (support old format: string[])
-        const { permissions: requiredPermissions, operator } = this.normalizePermissionConfig(permissionConfig);
-        // If no permissions required, allow access
-        if (!requiredPermissions || requiredPermissions.length === 0) {
-            return true;
-        }
+        if (!permissionConfig) return true;
         const request = context.switchToHttp().getRequest();
         const user = request.user;
-        // User must be authenticated
-        if (!user) {
-            throw new _common.UnauthorizedException('Authentication required');
-        }
-        // Cache is required for permission checks - fail securely if unavailable
+        if (!user) throw new _common.UnauthorizedException({
+            message: 'Authentication required',
+            messageKey: _constants.AUTH_MESSAGES.TOKEN_REQUIRED
+        });
         if (!this.cache) {
-            // Log error (in production, this should be monitored)
-            this.logger.error(`Cache not available - permission system unavailable (userId: ${user.id})`, undefined, 'PermissionGuard');
-            // Fail securely - deny access rather than allowing without permission check
             throw new _permissionexception.PermissionSystemUnavailableException();
         }
-        // Get user's permissions from cache
         const userPermissions = await this.getUserPermissions(user);
-        // If no permissions found in cache, deny access
         if (!userPermissions || userPermissions.length === 0) {
-            this.logger.warn(`No permissions found for user (userId: ${user.id})`, 'PermissionGuard');
             throw new _permissionexception.NoPermissionsFoundException();
         }
-        // Check if this is a nested condition or simple permission list
-        if (this.isNestedCondition(permissionConfig)) {
-            // Complex nested permission check
-            const result = this.evaluateCondition(permissionConfig, userPermissions);
-            if (!result.passed) {
-                this.logger.warn(`Permission check failed (userId: ${user.id}, missing: ${result.missingPermissions.join(', ')})`, 'PermissionGuard');
-                throw new _permissionexception.InsufficientPermissionsException(result.missingPermissions, result.operator);
-            }
-        } else {
-            // Simple permission check (backward compatible)
-            let hasRequiredPermissions;
-            if (operator === 'or') {
-                // OR: User must have at least ONE permission
-                hasRequiredPermissions = requiredPermissions.some((permission)=>this.hasPermission(userPermissions, permission));
-                if (!hasRequiredPermissions) {
-                    throw new _permissionexception.InsufficientPermissionsException(requiredPermissions, 'or');
-                }
-            } else {
-                // AND (default): User must have ALL permissions
-                hasRequiredPermissions = requiredPermissions.every((permission)=>this.hasPermission(userPermissions, permission));
-                if (!hasRequiredPermissions) {
-                    const missing = requiredPermissions.filter((permission)=>!this.hasPermission(userPermissions, permission));
-                    throw new _permissionexception.InsufficientPermissionsException(missing, 'and');
-                }
-            }
+        const logicNode = this.normalizeToLogicNode(permissionConfig);
+        if (!logicNode) return true;
+        const result = this.evaluateLogicNode(logicNode, userPermissions);
+        if (!result.passed) {
+            throw new _permissionexception.InsufficientPermissionsException(result.missingPermissions, result.operator);
         }
         return true;
     }
-    /**
-   * Normalize permission config to handle both old and new formats
-   */ normalizePermissionConfig(config) {
-        // Old format: string[]
+    normalizeToLogicNode(config) {
+        // string - single permission
+        if (typeof config === 'string') {
+            return config ? {
+                type: 'action',
+                actionId: config
+            } : null;
+        }
+        // string[] - treat as AND of multiple permissions
         if (Array.isArray(config)) {
+            if (config.length === 0) return null;
+            if (config.length === 1) return {
+                type: 'action',
+                actionId: config[0]
+            };
             return {
-                permissions: config,
-                operator: 'and'
+                type: 'group',
+                operator: 'AND',
+                children: config.map((p)=>({
+                        type: 'action',
+                        actionId: p
+                    }))
             };
         }
-        // New format: PermissionConfig
-        return {
-            permissions: config.permissions || [],
-            operator: config.operator || 'and'
-        };
-    }
-    /**
-   * Check if config is a nested condition (has children)
-   */ isNestedCondition(config) {
-        if (Array.isArray(config)) return false;
-        return 'children' in config && Array.isArray(config.children) && config.children.length > 0;
+        // SimplePermissionConfig - { permissions: string[], operator: 'AND'|'OR' }
+        if ('permissions' in config && Array.isArray(config.permissions)) {
+            const simple = config;
+            if (simple.permissions.length === 0) return null;
+            if (simple.permissions.length === 1) return {
+                type: 'action',
+                actionId: simple.permissions[0]
+            };
+            return {
+                type: 'group',
+                operator: simple.operator || 'AND',
+                children: simple.permissions.map((p)=>({
+                        type: 'action',
+                        actionId: p
+                    }))
+            };
+        }
+        // ILogicNode
+        return config;
     }
-    /**
-   * Evaluate a nested permission condition recursively
-   */ evaluateCondition(condition, userPermissions) {
-        const { permissions = [], operator, children = [] } = condition;
-        // Results for this level
+    evaluateLogicNode(node, userPermissions) {
+        if (node.type === 'action') {
+            const passed = this.hasPermission(userPermissions, node.actionId);
+            return {
+                passed,
+                missingPermissions: passed ? [] : [
+                    node.actionId
+                ],
+                operator: 'AND'
+            };
+        }
+        // Group node
+        const { operator, children } = node;
+        // SECURITY: Fail-closed - deny access when no children configured
+        if (!children || children.length === 0) {
+            return {
+                passed: false,
+                missingPermissions: [],
+                operator
+            };
+        }
         const results = [];
-        const failureDetails = [];
         const missingPermissions = [];
-        // Check permissions at this level
-        if (permissions.length > 0) {
-            if (operator === 'or') {
-                const hasAny = permissions.some((p)=>this.hasPermission(userPermissions, p));
-                results.push(hasAny);
-                if (!hasAny) {
-                    failureDetails.push(`needs one of: [${permissions.join(', ')}]`);
-                    missingPermissions.push(...permissions);
-                }
-            } else {
-                const hasAll = permissions.every((p)=>this.hasPermission(userPermissions, p));
-                results.push(hasAll);
-                if (!hasAll) {
-                    const missing = permissions.filter((p)=>!this.hasPermission(userPermissions, p));
-                    failureDetails.push(`missing: [${missing.join(', ')}]`);
-                    missingPermissions.push(...missing);
-                }
-            }
-        }
-        // Evaluate children recursively
         for (const child of children){
-            const childResult = this.evaluateCondition(child, userPermissions);
+            const childResult = this.evaluateLogicNode(child, userPermissions);
             results.push(childResult.passed);
             if (!childResult.passed) {
-                failureDetails.push(`(${childResult.message})`);
                 missingPermissions.push(...childResult.missingPermissions);
             }
         }
-        // Combine results based on operator
-        let passed;
-        if (operator === 'or') {
-            passed = results.length === 0 || results.some((r)=>r);
-        } else {
-            passed = results.length === 0 || results.every((r)=>r);
-        }
-        const message = passed ? 'Permission granted' : `Permission denied: ${failureDetails.join(` ${operator.toUpperCase()} `)}`;
+        const passed = operator === 'OR' ? results.some((r)=>r) : results.every((r)=>r);
         return {
             passed,
-            message,
-            missingPermissions,
+            missingPermissions: passed ? [] : missingPermissions,
             operator
         };
     }
-    /**
-   * Get user's permissions from cache
-   */ async getUserPermissions(user) {
-        if (!this.cache) {
-            throw new _permissionexception.PermissionSystemUnavailableException();
-        }
-        let cacheKey;
+    async getUserPermissions(user) {
+        if (!this.cache) throw new _permissionexception.PermissionSystemUnavailableException();
+        const cacheKey = this.buildPermissionCacheKey(user);
+        return await this.cache.get(cacheKey) || [];
+    }
+    buildPermissionCacheKey(user) {
         if (this.config.enableCompanyFeature && user.companyId) {
-            // Company-based permissions (includes branchId for branch-scoped DIRECT permissions)
-            const format = this.config.companyPermissionKeyFormat || `${_constants.PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`;
-            cacheKey = format.replace('{userId}', user.id).replace('{companyId}', user.companyId).replace('{branchId}', user.branchId || 'null');
-        } else {
-            // User-based permissions
-            const format = this.config.userPermissionKeyFormat || `${_constants.PERMISSIONS_CACHE_PREFIX}:user:{userId}`;
-            cacheKey = format.replace('{userId}', user.id);
+            return (this.config.companyPermissionKeyFormat || `${_constants.PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`).replace('{userId}', user.id).replace('{companyId}', user.companyId).replace('{branchId}', user.branchId || 'null');
         }
-        const permissions = await this.cache.get(cacheKey);
-        return permissions || [];
+        return (this.config.userPermissionKeyFormat || `${_constants.PERMISSIONS_CACHE_PREFIX}:user:{userId}`).replace('{userId}', user.id);
     }
-    /**
-   * Check if user has a specific permission
-   * Supports wildcard matching (e.g., 'admin.*' matches 'admin.users.read')
-   */ hasPermission(userPermissions, requiredPermission) {
-        // Direct match
-        if (userPermissions.includes(requiredPermission)) {
-            return true;
-        }
-        // Wildcard match (e.g., '*' or 'admin.*')
+    hasPermission(userPermissions, requiredPermission) {
+        if (userPermissions.includes(requiredPermission)) return true;
         for (const permission of userPermissions){
-            if (permission === '*') {
-                return true; // Super admin
-            }
-            if (permission.endsWith('.*')) {
-                const prefix = permission.slice(0, -1); // Remove '*'
-                if (requiredPermission.startsWith(prefix)) {
-                    return true;
-                }
+            if (permission === '*') return true;
+            if (permission.endsWith('.*') && requiredPermission.startsWith(permission.slice(0, -1))) {
+                return true;
             }
         }
         return false;
     }
-    // NOTE: @Inject(Reflector) required for bundled code - external classes need explicit injection
-    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 = {
             enableCompanyFeature: false,
-            cacheKeyPrefix: _constants.PERMISSIONS_CACHE_PREFIX,
             userPermissionKeyFormat: `${_constants.PERMISSIONS_CACHE_PREFIX}:user:{userId}`,
             companyPermissionKeyFormat: `${_constants.PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`,
             ...config
         };
-        // Use provided logger or fallback to NestJS Logger wrapped in adapter
-        this.logger = logger || new _winstonloggeradapterclass.NestLoggerAdapter(new _common.Logger(PermissionGuard.name));
     }
 };
 PermissionGuard = _ts_decorate([
@@ -254,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

@@ -7,7 +7,9 @@ _export_star(require("./constants"), exports);
 _export_star(require("./decorators"), exports);
 _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